generic-2.6: rename "files" directory to "files-2.6.24" to be consistent
authorNicolas Thill <nico@openwrt.org>
Sun, 3 May 2009 00:46:48 +0000 (00:46 +0000)
committerNicolas Thill <nico@openwrt.org>
Sun, 3 May 2009 00:46:48 +0000 (00:46 +0000)
SVN-Revision: 15566

132 files changed:
target/linux/generic-2.6/files-2.6.24/drivers/char/gpio_dev.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/input/misc/gpio_buttons.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/leds/leds-alix.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-default-on.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-morse.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-netdev.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/spi/spi_gpio.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/Kconfig [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/Makefile [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/b43_pci_bridge.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_chipcommon.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_extif.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_mipscore.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_pcicore.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/main.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/pci.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcihost_wrapper.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcmcia.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/scan.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/drivers/ssb/ssb_private.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Kconfig [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Makefile [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/devextras.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/moduleconfig.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_fs.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1-compat.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nandemul2k.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.c [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffsinterface.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yportenv.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/gpio_buttons.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/gpio_dev.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/spi/spi_gpio.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_chipcommon.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_extif.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_mips.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_pci.h [new file with mode: 0644]
target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_regs.h [new file with mode: 0644]
target/linux/generic-2.6/files/drivers/char/gpio_dev.c [deleted file]
target/linux/generic-2.6/files/drivers/input/misc/gpio_buttons.c [deleted file]
target/linux/generic-2.6/files/drivers/leds/leds-alix.c [deleted file]
target/linux/generic-2.6/files/drivers/leds/ledtrig-default-on.c [deleted file]
target/linux/generic-2.6/files/drivers/leds/ledtrig-morse.c [deleted file]
target/linux/generic-2.6/files/drivers/leds/ledtrig-netdev.c [deleted file]
target/linux/generic-2.6/files/drivers/net/phy/adm6996.c [deleted file]
target/linux/generic-2.6/files/drivers/net/phy/adm6996.h [deleted file]
target/linux/generic-2.6/files/drivers/net/phy/mvswitch.c [deleted file]
target/linux/generic-2.6/files/drivers/net/phy/mvswitch.h [deleted file]
target/linux/generic-2.6/files/drivers/spi/spi_gpio.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/Kconfig [deleted file]
target/linux/generic-2.6/files/drivers/ssb/Makefile [deleted file]
target/linux/generic-2.6/files/drivers/ssb/b43_pci_bridge.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/driver_chipcommon.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/driver_extif.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/driver_mipscore.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/driver_pcicore.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/main.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/pci.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/pcihost_wrapper.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/pcmcia.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/scan.c [deleted file]
target/linux/generic-2.6/files/drivers/ssb/ssb_private.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/Kconfig [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/Makefile [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/devextras.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/moduleconfig.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_fs.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1-compat.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_nandemul2k.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.c [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yaffsinterface.h [deleted file]
target/linux/generic-2.6/files/fs/yaffs2/yportenv.h [deleted file]
target/linux/generic-2.6/files/include/linux/gpio_buttons.h [deleted file]
target/linux/generic-2.6/files/include/linux/gpio_dev.h [deleted file]
target/linux/generic-2.6/files/include/linux/spi/spi_gpio.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_chipcommon.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_extif.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_mips.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_pci.h [deleted file]
target/linux/generic-2.6/files/include/linux/ssb/ssb_regs.h [deleted file]

diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/char/gpio_dev.c b/target/linux/generic-2.6/files-2.6.24/drivers/char/gpio_dev.c
new file mode 100644 (file)
index 0000000..4dc6374
--- /dev/null
@@ -0,0 +1,201 @@
+/*
+ * character device wrapper for generic gpio layer
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307USA
+ *
+ * Feedback, Bugs...  blogic@openwrt.org
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+#include <asm/gpio.h>
+#include <asm/atomic.h>
+#include <linux/init.h>
+#include <linux/genhd.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/gpio_dev.h>
+
+#define DRVNAME                "gpiodev"
+#define DEVNAME                "gpio"
+
+static int dev_major;
+static unsigned int gpio_access_mask;
+static struct class *gpiodev_class;
+
+/* Counter is 1, if the device is not opened and zero (or less) if opened. */
+static atomic_t gpio_open_cnt = ATOMIC_INIT(1);
+
+static int
+gpio_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
+{
+       int retval = 0;
+
+       if (((1 << arg) & gpio_access_mask) != (1 << arg))
+       {
+               retval = -EINVAL;
+               goto out;
+       }
+
+       switch (cmd)
+       {
+       case GPIO_GET:
+               retval = gpio_get_value(arg);
+               break;
+
+       case GPIO_SET:
+               gpio_set_value(arg, 1);
+               break;
+
+       case GPIO_CLEAR:
+               gpio_set_value(arg, 0);
+               break;
+
+       case GPIO_DIR_IN:
+               gpio_direction_input(arg);
+               break;
+
+       case GPIO_DIR_OUT:
+               gpio_direction_output(arg, 0);
+               break;
+
+       default:
+               retval = -EINVAL;
+               break;
+       }
+
+out:
+       return retval;
+}
+
+static int
+gpio_open(struct inode *inode, struct file *file)
+{
+       int result = 0;
+       unsigned int dev_minor = MINOR(inode->i_rdev);
+
+       if (dev_minor != 0)
+       {
+               printk(KERN_ERR DRVNAME ": trying to access unknown minor device -> %d\n", dev_minor);
+               result = -ENODEV;
+               goto out;
+       }
+
+       /* FIXME: We should really allow multiple applications to open the device
+        *        at the same time, as long as the apps access different IO pins.
+        *        The generic gpio-registration functions can be used for that.
+        *        Two new IOCTLs have to be introduced for that. Need to check userspace
+        *        compatibility first. --mb */
+       if (!atomic_dec_and_test(&gpio_open_cnt)) {
+               atomic_inc(&gpio_open_cnt);
+               printk(KERN_ERR DRVNAME ": Device with minor ID %d already in use\n", dev_minor);
+               result = -EBUSY;
+               goto out;
+       }
+
+out:
+       return result;
+}
+
+static int
+gpio_close(struct inode * inode, struct file * file)
+{
+       smp_mb__before_atomic_inc();
+       atomic_inc(&gpio_open_cnt);
+
+       return 0;
+}
+
+struct file_operations gpio_fops = {
+       ioctl:          gpio_ioctl,
+       open:           gpio_open,
+       release:        gpio_close
+};
+
+static int
+gpio_probe(struct platform_device *dev)
+{
+       int result = 0;
+
+       dev_major = register_chrdev(0, DEVNAME, &gpio_fops);
+       if (!dev_major)
+       {
+               printk(KERN_ERR DRVNAME ": Error whilst opening %s \n", DEVNAME);
+               result = -ENODEV;
+               goto out;
+       }
+
+       gpiodev_class = class_create(THIS_MODULE, DRVNAME);
+       class_device_create(gpiodev_class, NULL, MKDEV(dev_major, 0), NULL, DEVNAME);
+
+       printk(KERN_INFO DRVNAME ": gpio device registered with major %d\n", dev_major);
+
+       if (dev->num_resources != 1)
+       {
+               printk(KERN_ERR DRVNAME ": device may only have 1 resource\n");
+               result = -ENODEV;
+               goto out;
+       }
+
+       gpio_access_mask = dev->resource[0].start;
+
+       printk(KERN_INFO DRVNAME ": gpio platform device registered with access mask %08X\n", gpio_access_mask);
+out:
+       return result;
+}
+
+static int
+gpio_remove(struct platform_device *dev)
+{
+       unregister_chrdev(dev_major, DEVNAME);
+       return 0;
+}
+
+static struct
+platform_driver gpio_driver = {
+       .probe = gpio_probe,
+       .remove = gpio_remove,
+       .driver = {
+               .name = "GPIODEV",
+               .owner = THIS_MODULE,
+       },
+};
+
+static int __init
+gpio_mod_init(void)
+{
+       int ret = platform_driver_register(&gpio_driver);
+       if (ret)
+               printk(KERN_INFO DRVNAME ": Error registering platfom driver!");
+
+       return ret;
+}
+
+static void __exit
+gpio_mod_exit(void)
+{
+       platform_driver_unregister(&gpio_driver);
+}
+
+module_init (gpio_mod_init);
+module_exit (gpio_mod_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("John Crispin / OpenWrt");
+MODULE_DESCRIPTION("Character device for for generic gpio api");
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/input/misc/gpio_buttons.c b/target/linux/generic-2.6/files-2.6.24/drivers/input/misc/gpio_buttons.c
new file mode 100644 (file)
index 0000000..83a8178
--- /dev/null
@@ -0,0 +1,209 @@
+/*
+ *  Driver for buttons on GPIO lines not capable of generating interrupts
+ *
+ *  Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
+ *
+ *  This file was based on: /drivers/input/misc/cobalt_btns.c
+ *     Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
+ *
+ *  also was based on: /drivers/input/keyboard/gpio_keys.c
+ *     Copyright 2005 Phil Blundell
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+
+#include <linux/input.h>
+#include <linux/input-polldev.h>
+#include <linux/ioport.h>
+#include <linux/platform_device.h>
+
+#include <linux/gpio_buttons.h>
+
+#include <asm/gpio.h>
+
+#define DRV_NAME       "gpio-buttons"
+#define DRV_VERSION    "0.1.1"
+#define PFX            DRV_NAME ": "
+
+struct gpio_buttons_dev {
+       struct input_polled_dev *poll_dev;
+       struct gpio_buttons_platform_data *pdata;
+};
+
+static void gpio_buttons_poll(struct input_polled_dev *dev)
+{
+       struct gpio_buttons_dev *bdev = dev->private;
+       struct gpio_buttons_platform_data *pdata = bdev->pdata;
+       struct input_dev *input = dev->input;
+       int i;
+
+       for (i = 0; i < bdev->pdata->nbuttons; i++) {
+               struct gpio_button *button = &pdata->buttons[i];
+               unsigned int type = button->type ?: EV_KEY;
+               int state;
+
+               state = gpio_get_value(button->gpio) ? 1 : 0;
+               state ^= button->active_low;
+
+               if (state) {
+                       button->count++;
+               } else {
+                       if (button->count >= button->threshold) {
+                               input_event(input, type, button->code, 1);
+                               input_sync(input);
+                       }
+                       button->count = 0;
+               }
+
+               if (button->count == button->threshold) {
+                       input_event(input, type, button->code, 0);
+                       input_sync(input);
+               }
+       }
+}
+
+static int __devinit gpio_buttons_probe(struct platform_device *pdev)
+{
+       struct gpio_buttons_platform_data *pdata = pdev->dev.platform_data;
+       struct gpio_buttons_dev *bdev;
+       struct input_polled_dev *poll_dev;
+       struct input_dev *input;
+       int error, i;
+
+
+       if (!pdata)
+               return -ENXIO;
+
+       bdev = kzalloc(sizeof(*bdev), GFP_KERNEL);
+       if (!bdev) {
+               printk(KERN_ERR DRV_NAME "no memory for device\n");
+               return -ENOMEM;
+       }
+
+       poll_dev = input_allocate_polled_device();
+       if (!poll_dev) {
+               printk(KERN_ERR DRV_NAME "no memory for polled device\n");
+               error = -ENOMEM;
+               goto err_free_bdev;
+       }
+
+       poll_dev->private = bdev;
+       poll_dev->poll = gpio_buttons_poll;
+       poll_dev->poll_interval = pdata->poll_interval;
+
+       input = poll_dev->input;
+
+       input->evbit[0] = BIT(EV_KEY);
+       input->name = pdev->name;
+       input->phys = "gpio-buttons/input0";
+       input->dev.parent = &pdev->dev;
+
+       input->id.bustype = BUS_HOST;
+       input->id.vendor = 0x0001;
+       input->id.product = 0x0001;
+       input->id.version = 0x0100;
+
+       for (i = 0; i < pdata->nbuttons; i++) {
+               struct gpio_button *button = &pdata->buttons[i];
+               unsigned int gpio = button->gpio;
+               unsigned int type = button->type ?: EV_KEY;
+
+               error = gpio_request(gpio, button->desc ?
+                               button->desc : DRV_NAME);
+               if (error) {
+                       printk(KERN_ERR PFX "unable to claim gpio %u, "
+                               "error %d\n", gpio, error);
+                       goto err_free_gpio;
+               }
+
+               error = gpio_direction_input(gpio);
+               if (error) {
+                       printk(KERN_ERR PFX "unable to set direction on "
+                               "gpio %u, error %d\n", gpio, error);
+                       goto err_free_gpio;
+               }
+
+               input_set_capability(input, type, button->code);
+               button->count = 0;
+       }
+
+       bdev->poll_dev = poll_dev;
+       bdev->pdata = pdata;
+       platform_set_drvdata(pdev, bdev);
+
+       error = input_register_polled_device(poll_dev);
+       if (error) {
+               printk(KERN_ERR PFX "unable to register polled device, "
+                       "error %d\n", error);
+               goto err_free_gpio;
+       }
+
+       return 0;
+
+err_free_gpio:
+       for (i = i - 1; i >= 0; i--)
+               gpio_free(pdata->buttons[i].gpio);
+
+       input_free_polled_device(poll_dev);
+
+err_free_bdev:
+       kfree(bdev);
+
+       platform_set_drvdata(pdev, NULL);
+       return error;
+}
+
+static int __devexit gpio_buttons_remove(struct platform_device *pdev)
+{
+       struct gpio_buttons_dev *bdev = platform_get_drvdata(pdev);
+       struct gpio_buttons_platform_data *pdata = bdev->pdata;
+       int i;
+
+       input_unregister_polled_device(bdev->poll_dev);
+
+       for (i = 0; i < pdata->nbuttons; i++)
+               gpio_free(pdata->buttons[i].gpio);
+
+       input_free_polled_device(bdev->poll_dev);
+
+       kfree(bdev);
+       platform_set_drvdata(pdev, NULL);
+
+       return 0;
+}
+
+static struct platform_driver gpio_buttons_driver = {
+       .probe  = gpio_buttons_probe,
+       .remove = __devexit_p(gpio_buttons_remove),
+       .driver = {
+               .name   = DRV_NAME,
+               .owner  = THIS_MODULE,
+       },
+};
+
+static int __init gpio_buttons_init(void)
+{
+       printk(KERN_INFO DRV_NAME " driver version " DRV_VERSION "\n");
+       return platform_driver_register(&gpio_buttons_driver);
+}
+
+static void __exit gpio_buttons_exit(void)
+{
+       platform_driver_unregister(&gpio_buttons_driver);
+}
+
+module_init(gpio_buttons_init);
+module_exit(gpio_buttons_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
+MODULE_VERSION(DRV_VERSION);
+MODULE_DESCRIPTION("Polled buttons driver for CPU GPIOs");
+
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/leds/leds-alix.c b/target/linux/generic-2.6/files-2.6.24/drivers/leds/leds-alix.c
new file mode 100644 (file)
index 0000000..103ca7d
--- /dev/null
@@ -0,0 +1,172 @@
+/*
+ * LEDs driver for PCEngines ALIX 2/3 series
+ *
+ * Copyright (C) 2007 Petr Liebman
+ *
+ * Based on leds-wrap.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/leds.h>
+#include <linux/err.h>
+#include <asm/io.h>
+
+#define DRVNAME "alix-led"
+
+#define ALIX_LED1_PORT         (0x6100)
+#define ALIX_LED1_ON           (1<<22)
+#define ALIX_LED1_OFF          (1<<6)
+
+#define ALIX_LED2_PORT         (0x6180)
+#define ALIX_LED2_ON           (1<<25)
+#define ALIX_LED2_OFF          (1<<9)
+
+#define ALIX_LED3_PORT         (0x6180)
+#define ALIX_LED3_ON           (1<<27)
+#define ALIX_LED3_OFF          (1<<11)
+
+
+static struct platform_device *pdev;
+
+static void alix_led_set_1(struct led_classdev *led_cdev,
+               enum led_brightness value)
+{
+       if (value)
+               outl(ALIX_LED1_ON, ALIX_LED1_PORT);
+       else
+               outl(ALIX_LED1_OFF, ALIX_LED1_PORT);
+}
+
+static void alix_led_set_2(struct led_classdev *led_cdev,
+               enum led_brightness value)
+{
+       if (value)
+               outl(ALIX_LED2_ON, ALIX_LED2_PORT);
+       else
+               outl(ALIX_LED2_OFF, ALIX_LED2_PORT);
+}
+
+static void alix_led_set_3(struct led_classdev *led_cdev,
+               enum led_brightness value)
+{
+       if (value)
+               outl(ALIX_LED3_ON, ALIX_LED3_PORT);
+       else
+               outl(ALIX_LED3_OFF, ALIX_LED3_PORT);
+}
+
+static struct led_classdev alix_led_1 = {
+       .name           = "alix:1",
+       .brightness_set = alix_led_set_1,
+};
+
+static struct led_classdev alix_led_2 = {
+       .name           = "alix:2",
+       .brightness_set = alix_led_set_2,
+};
+
+static struct led_classdev alix_led_3 = {
+       .name           = "alix:3",
+       .brightness_set = alix_led_set_3,
+};
+
+
+#ifdef CONFIG_PM
+static int alix_led_suspend(struct platform_device *dev,
+               pm_message_t state)
+{
+       led_classdev_suspend(&alix_led_1);
+       led_classdev_suspend(&alix_led_2);
+       led_classdev_suspend(&alix_led_3);
+       return 0;
+}
+
+static int alix_led_resume(struct platform_device *dev)
+{
+       led_classdev_resume(&alix_led_1);
+       led_classdev_resume(&alix_led_2);
+       led_classdev_resume(&alix_led_3);
+       return 0;
+}
+#else
+#define alix_led_suspend NULL
+#define alix_led_resume NULL
+#endif
+
+static int alix_led_probe(struct platform_device *pdev)
+{
+       int ret;
+
+       ret = led_classdev_register(&pdev->dev, &alix_led_1);
+       if (ret >= 0)
+       {
+               ret = led_classdev_register(&pdev->dev, &alix_led_2);
+               if (ret >= 0)
+               {
+                       ret = led_classdev_register(&pdev->dev, &alix_led_3);
+                       if (ret < 0)
+                               led_classdev_unregister(&alix_led_2);
+               }
+               if (ret < 0)
+                       led_classdev_unregister(&alix_led_1);
+       }
+       return ret;
+}
+
+static int alix_led_remove(struct platform_device *pdev)
+{
+       led_classdev_unregister(&alix_led_1);
+       led_classdev_unregister(&alix_led_2);
+       led_classdev_unregister(&alix_led_3);
+       return 0;
+}
+
+static struct platform_driver alix_led_driver = {
+       .probe          = alix_led_probe,
+       .remove         = alix_led_remove,
+       .suspend        = alix_led_suspend,
+       .resume         = alix_led_resume,
+       .driver         = {
+               .name           = DRVNAME,
+               .owner          = THIS_MODULE,
+       },
+};
+
+static int __init alix_led_init(void)
+{
+       int ret;
+
+       ret = platform_driver_register(&alix_led_driver);
+       if (ret < 0)
+               goto out;
+
+       pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
+       if (IS_ERR(pdev)) {
+               ret = PTR_ERR(pdev);
+               platform_driver_unregister(&alix_led_driver);
+               goto out;
+       }
+
+out:
+       return ret;
+}
+
+static void __exit alix_led_exit(void)
+{
+       platform_device_unregister(pdev);
+       platform_driver_unregister(&alix_led_driver);
+}
+
+module_init(alix_led_init);
+module_exit(alix_led_exit);
+
+MODULE_AUTHOR("Petr Liebman");
+MODULE_DESCRIPTION("PCEngines ALIX LED driver");
+MODULE_LICENSE("GPL");
+
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-default-on.c b/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-default-on.c
new file mode 100644 (file)
index 0000000..92995e4
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * LED Kernel Default ON Trigger
+ *
+ * Copyright 2008 Nick Forbes <nick.forbes@incepta.com>
+ *
+ * Based on Richard Purdie's ledtrig-timer.c.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/leds.h>
+#include "leds.h"
+
+static void defon_trig_activate(struct led_classdev *led_cdev)
+{
+       led_set_brightness(led_cdev, LED_FULL);
+}
+
+static struct led_trigger defon_led_trigger = {
+       .name     = "default-on",
+       .activate = defon_trig_activate,
+};
+
+static int __init defon_trig_init(void)
+{
+       return led_trigger_register(&defon_led_trigger);
+}
+
+static void __exit defon_trig_exit(void)
+{
+       led_trigger_unregister(&defon_led_trigger);
+}
+
+module_init(defon_trig_init);
+module_exit(defon_trig_exit);
+
+MODULE_AUTHOR("Nick Forbes <nick.forbes@incepta.com>");
+MODULE_DESCRIPTION("Default-ON LED trigger");
+MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-morse.c b/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-morse.c
new file mode 100644 (file)
index 0000000..cb47480
--- /dev/null
@@ -0,0 +1,365 @@
+/*
+ *  LED Morse Trigger
+ *
+ *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
+ *
+ *  This file was based on: drivers/led/ledtrig-timer.c
+ *     Copyright 2005-2006 Openedhand Ltd.
+ *     Author: Richard Purdie <rpurdie@openedhand.com>
+ *
+ *  also based on the patch '[PATCH] 2.5.59 morse code panics' posted
+ *  in the LKML by Tomas Szepe at Thu, 30 Jan 2003
+ *     Copyright (C) 2002 Andrew Rodland <arodland@noln.com>
+ *     Copyright (C) 2003 Tomas Szepe <szepe@pinerecords.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify it
+ *  under the terms of the GNU General Public License version 2 as published
+ *  by the Free Software Foundation.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/device.h>
+#include <linux/sysdev.h>
+#include <linux/timer.h>
+#include <linux/ctype.h>
+#include <linux/leds.h>
+
+#include "leds.h"
+
+#define MORSE_DELAY_BASE       (HZ/2)
+
+#define MORSE_STATE_BLINK_START        0
+#define MORSE_STATE_BLINK_STOP 1
+
+#define MORSE_DIT_LEN  1
+#define MORSE_DAH_LEN  3
+#define MORSE_SPACE_LEN        7
+
+struct morse_trig_data {
+       unsigned long delay;
+       char *msg;
+
+       unsigned char morse;
+       unsigned char state;
+       char *msgpos;
+       struct timer_list timer;
+};
+
+const unsigned char morsetable[] = {
+       0122, 0, 0310, 0, 0, 0163,                              /* "#$%&' */
+       055, 0155, 0, 0, 0163, 0141, 0152, 0051,                /* ()*+,-./ */
+       077, 076, 074, 070, 060, 040, 041, 043, 047, 057,       /* 0-9 */
+       0107, 0125, 0, 0061, 0, 0114, 0,                        /* :;<=>?@ */
+       006, 021, 025, 011, 002, 024, 013, 020, 004,            /* A-I */
+       036, 015, 022, 007, 005, 017, 026, 033, 012,            /* J-R */
+       010, 003, 014, 030, 016, 031, 035, 023,                 /* S-Z */
+       0, 0, 0, 0, 0154                                        /* [\]^_ */
+};
+
+static inline unsigned char tomorse(char c) {
+       if (c >= 'a' && c <= 'z')
+               c = c - 'a' + 'A';
+       if (c >= '"' && c <= '_') {
+               return morsetable[c - '"'];
+       } else
+               return 0;
+}
+
+static inline unsigned long dit_len(struct morse_trig_data *morse_data)
+{
+       return MORSE_DIT_LEN*morse_data->delay;
+}
+
+static inline unsigned long dah_len(struct morse_trig_data *morse_data)
+{
+       return MORSE_DAH_LEN*morse_data->delay;
+}
+
+static inline unsigned long space_len(struct morse_trig_data *morse_data)
+{
+       return MORSE_SPACE_LEN*morse_data->delay;
+}
+
+static void morse_timer_function(unsigned long data)
+{
+       struct led_classdev *led_cdev = (struct led_classdev *)data;
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+       unsigned long brightness = LED_OFF;
+       unsigned long delay = 0;
+
+       if (!morse_data->msg)
+               goto set_led;
+
+       switch (morse_data->state) {
+       case MORSE_STATE_BLINK_START:
+               /* Starting a new blink.  We have a valid code in morse. */
+               delay = (morse_data->morse & 001) ? dah_len(morse_data):
+                       dit_len(morse_data);
+               brightness = LED_FULL;
+               morse_data->state = MORSE_STATE_BLINK_STOP;
+               morse_data->morse >>= 1;
+               break;
+       case MORSE_STATE_BLINK_STOP:
+               /* Coming off of a blink. */
+               morse_data->state = MORSE_STATE_BLINK_START;
+
+               if (morse_data->morse > 1) {
+                       /* Not done yet, just a one-dit pause. */
+                       delay = dit_len(morse_data);
+                       break;
+               }
+
+               /* Get a new char, figure out how much space. */
+               /* First time through */
+               if (!morse_data->msgpos)
+                       morse_data->msgpos = (char *)morse_data->msg;
+
+               if (!*morse_data->msgpos) {
+                       /* Repeating */
+                       morse_data->msgpos = (char *)morse_data->msg;
+                       delay = space_len(morse_data);
+               } else {
+                       /* Inter-letter space */
+                       delay = dah_len(morse_data);
+               }
+
+               if (!(morse_data->morse = tomorse(*morse_data->msgpos))) {
+                       delay = space_len(morse_data);
+                       /* And get us back here */
+                       morse_data->state = MORSE_STATE_BLINK_STOP;
+               }
+               morse_data->msgpos++;
+               break;
+       }
+
+       mod_timer(&morse_data->timer, jiffies + msecs_to_jiffies(delay));
+
+set_led:
+       led_set_brightness(led_cdev, brightness);
+}
+
+static ssize_t _morse_delay_show(struct led_classdev *led_cdev, char *buf)
+{
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+
+       sprintf(buf, "%lu\n", morse_data->delay);
+
+       return strlen(buf) + 1;
+}
+
+static ssize_t _morse_delay_store(struct led_classdev *led_cdev,
+               const char *buf, size_t size)
+{
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+       char *after;
+       unsigned long state = simple_strtoul(buf, &after, 10);
+       size_t count = after - buf;
+       int ret = -EINVAL;
+
+       if (*after && isspace(*after))
+               count++;
+
+       if (count == size) {
+               morse_data->delay = state;
+               mod_timer(&morse_data->timer, jiffies + 1);
+               ret = count;
+       }
+
+       return ret;
+}
+
+static ssize_t _morse_msg_show(struct led_classdev *led_cdev, char *buf)
+{
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+
+       if (!morse_data->msg)
+               sprintf(buf, "<none>\n");
+       else
+               sprintf(buf, "%s\n", morse_data->msg);
+
+       return strlen(buf) + 1;
+}
+
+static ssize_t _morse_msg_store(struct led_classdev *led_cdev,
+               const char *buf, size_t size)
+{
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+       char *m;
+
+       m = kmalloc(size, GFP_KERNEL);
+       if (!m)
+               return -ENOMEM;
+
+       memcpy(m,buf,size);
+       m[size]='\0';
+
+       if (morse_data->msg)
+               kfree(morse_data->msg);
+
+       morse_data->msg = m;
+       morse_data->msgpos = NULL;
+       morse_data->state = MORSE_STATE_BLINK_STOP;
+
+       mod_timer(&morse_data->timer, jiffies + 1);
+
+       return size;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
+static ssize_t morse_delay_show(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+       return _morse_delay_show(led_cdev, buf);
+}
+
+static ssize_t morse_delay_store(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t size)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+       return _morse_delay_store(led_cdev, buf, size);
+}
+
+static ssize_t morse_msg_show(struct device *dev,
+               struct device_attribute *attr, char *buf)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+       return _morse_msg_show(led_cdev, buf);
+}
+
+static ssize_t morse_msg_store(struct device *dev,
+               struct device_attribute *attr, const char *buf, size_t size)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+
+       return _morse_msg_store(led_cdev, buf, size);
+}
+
+static DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
+static DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
+
+#define led_device_create_file(leddev, attr) \
+       device_create_file(leddev->dev, &dev_attr_ ## attr)
+#define led_device_remove_file(leddev, attr) \
+       device_remove_file(leddev->dev, &dev_attr_ ## attr)
+
+#else
+static ssize_t morse_delay_show(struct class_device *dev, char *buf)
+{
+       struct led_classdev *led_cdev = class_get_devdata(dev);
+
+       return _morse_delay_show(led_cdev, buf);
+}
+
+static ssize_t morse_delay_store(struct class_device *dev, const char *buf,
+               size_t size)
+{
+       struct led_classdev *led_cdev = class_get_devdata(dev);
+
+       return _morse_delay_store(led_cdev, buf, size);
+}
+
+static ssize_t morse_msg_show(struct class_device *dev, char *buf)
+{
+       struct led_classdev *led_cdev = class_get_devdata(dev);
+
+       return _morse_msg_show(led_cdev, buf);
+}
+
+static ssize_t morse_msg_store(struct class_device *dev, const char *buf,
+                               size_t size)
+{
+       struct led_classdev *led_cdev = class_get_devdata(dev);
+
+       return _morse_msg_store(led_cdev, buf, size);
+}
+
+static CLASS_DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
+static CLASS_DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
+
+#define led_device_create_file(leddev, attr) \
+       class_device_create_file(leddev->class_dev, &class_device_attr_ ## attr)
+#define led_device_remove_file(leddev, attr) \
+       class_device_remove_file(leddev->class_dev, &class_device_attr_ ## attr)
+
+#endif
+
+static void morse_trig_activate(struct led_classdev *led_cdev)
+{
+       struct morse_trig_data *morse_data;
+       int rc;
+
+       morse_data = kzalloc(sizeof(*morse_data), GFP_KERNEL);
+       if (!morse_data)
+               return;
+
+       morse_data->delay = MORSE_DELAY_BASE;
+       init_timer(&morse_data->timer);
+       morse_data->timer.function = morse_timer_function;
+       morse_data->timer.data = (unsigned long)led_cdev;
+
+       rc = led_device_create_file(led_cdev, delay);
+       if (rc) goto err;
+
+       rc = led_device_create_file(led_cdev, message);
+       if (rc) goto err_delay;
+
+       led_cdev->trigger_data = morse_data;
+
+       return;
+
+err_delay:
+       led_device_remove_file(led_cdev, delay);
+err:
+       kfree(morse_data);
+}
+
+static void morse_trig_deactivate(struct led_classdev *led_cdev)
+{
+       struct morse_trig_data *morse_data = led_cdev->trigger_data;
+
+       if (!morse_data)
+               return;
+
+       led_device_remove_file(led_cdev, message);
+       led_device_remove_file(led_cdev, delay);
+
+       del_timer_sync(&morse_data->timer);
+       if (morse_data->msg)
+               kfree(morse_data->msg);
+
+       kfree(morse_data);
+}
+
+static struct led_trigger morse_led_trigger = {
+       .name           = "morse",
+       .activate       = morse_trig_activate,
+       .deactivate     = morse_trig_deactivate,
+};
+
+static int __init morse_trig_init(void)
+{
+       return led_trigger_register(&morse_led_trigger);
+}
+
+static void __exit morse_trig_exit(void)
+{
+       led_trigger_unregister(&morse_led_trigger);
+}
+
+module_init(morse_trig_init);
+module_exit(morse_trig_exit);
+
+MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
+MODULE_DESCRIPTION("Morse LED trigger");
+MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-netdev.c b/target/linux/generic-2.6/files-2.6.24/drivers/leds/ledtrig-netdev.c
new file mode 100644 (file)
index 0000000..fac3571
--- /dev/null
@@ -0,0 +1,451 @@
+/*
+ * LED Kernel Netdev Trigger
+ *
+ * Toggles the LED to reflect the link and traffic state of a named net device
+ *
+ * Copyright 2007 Oliver Jowett <oliver@opencloud.com>
+ *
+ * Derived from ledtrig-timer.c which is:
+ *  Copyright 2005-2006 Openedhand Ltd.
+ *  Author: Richard Purdie <rpurdie@openedhand.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/spinlock.h>
+#include <linux/device.h>
+#include <linux/sysdev.h>
+#include <linux/netdevice.h>
+#include <linux/timer.h>
+#include <linux/ctype.h>
+#include <linux/leds.h>
+#include <linux/version.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+#include <net/net_namespace.h>
+#endif
+
+#include "leds.h"
+
+/*
+ * Configurable sysfs attributes:
+ *
+ * device_name - network device name to monitor
+ *
+ * interval - duration of LED blink, in milliseconds
+ *
+ * mode - either "none" (LED is off) or a space separated list of one or more of:
+ *   link: LED's normal state reflects whether the link is up (has carrier) or not
+ *   tx:   LED blinks on transmitted data
+ *   rx:   LED blinks on receive data
+ * 
+ * Some suggestions:
+ *
+ *  Simple link status LED:
+ *  $ echo netdev >someled/trigger
+ *  $ echo eth0 >someled/device_name
+ *  $ echo link >someled/mode
+ *
+ *  Ethernet-style link/activity LED:
+ *  $ echo netdev >someled/trigger
+ *  $ echo eth0 >someled/device_name
+ *  $ echo "link tx rx" >someled/mode
+ *
+ *  Modem-style tx/rx LEDs:
+ *  $ echo netdev >led1/trigger
+ *  $ echo ppp0 >led1/device_name
+ *  $ echo tx >led1/mode
+ *  $ echo netdev >led2/trigger
+ *  $ echo ppp0 >led2/device_name
+ *  $ echo rx >led2/mode
+ *
+ */
+
+#define MODE_LINK 1
+#define MODE_TX   2
+#define MODE_RX   4
+
+struct led_netdev_data {
+       rwlock_t lock;
+
+       struct timer_list timer;
+       struct notifier_block notifier;
+
+       struct led_classdev *led_cdev;
+       struct net_device *net_dev;
+
+       char device_name[IFNAMSIZ];
+       unsigned interval;
+       unsigned mode;
+       unsigned link_up;
+       unsigned last_activity;
+};
+
+static void set_baseline_state(struct led_netdev_data *trigger_data)
+{
+       if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up)
+               led_set_brightness(trigger_data->led_cdev, LED_FULL);
+       else
+               led_set_brightness(trigger_data->led_cdev, LED_OFF);
+
+       if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up)
+               mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
+       else
+               del_timer(&trigger_data->timer);
+}
+
+static ssize_t led_device_name_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+
+       read_lock(&trigger_data->lock);
+       sprintf(buf, "%s\n", trigger_data->device_name);
+       read_unlock(&trigger_data->lock);
+
+       return strlen(buf) + 1;
+}
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
+extern struct net init_net;
+#endif
+
+static ssize_t led_device_name_store(struct device *dev,
+                                    struct device_attribute *attr, const char *buf, size_t size)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+
+       if (size < 0 || size >= IFNAMSIZ)
+               return -EINVAL;
+
+       write_lock(&trigger_data->lock);
+
+       strcpy(trigger_data->device_name, buf);
+       if (size > 0 && trigger_data->device_name[size-1] == '\n')
+               trigger_data->device_name[size-1] = 0;
+
+       if (trigger_data->device_name[0] != 0) {
+               /* check for existing device to update from */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
+               trigger_data->net_dev = dev_get_by_name(&init_net, trigger_data->device_name);
+#else
+               trigger_data->net_dev = dev_get_by_name(trigger_data->device_name);
+#endif
+               if (trigger_data->net_dev != NULL)
+                       trigger_data->link_up = (dev_get_flags(trigger_data->net_dev) & IFF_LOWER_UP) != 0;
+               set_baseline_state(trigger_data); /* updates LEDs, may start timers */
+       }
+
+       write_unlock(&trigger_data->lock);
+       return size;
+}
+
+static DEVICE_ATTR(device_name, 0644, led_device_name_show, led_device_name_store);
+
+static ssize_t led_mode_show(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+
+       read_lock(&trigger_data->lock);
+
+       if (trigger_data->mode == 0) {
+               strcpy(buf, "none\n");
+       } else {
+               if (trigger_data->mode & MODE_LINK)
+                       strcat(buf, "link ");
+               if (trigger_data->mode & MODE_TX)
+                       strcat(buf, "tx ");
+               if (trigger_data->mode & MODE_RX)
+                       strcat(buf, "rx ");
+               strcat(buf, "\n");
+       }
+
+       read_unlock(&trigger_data->lock);
+
+       return strlen(buf)+1;
+}
+
+static ssize_t led_mode_store(struct device *dev,
+                             struct device_attribute *attr, const char *buf, size_t size)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+       char copybuf[1024];
+       int new_mode = -1;
+       char *p, *token;
+
+       /* take a copy since we don't want to trash the inbound buffer when using strsep */
+       strncpy(copybuf, buf, sizeof(copybuf));
+       copybuf[1023] = 0;
+       p = copybuf;
+
+       while ((token = strsep(&p, " \t\n")) != NULL) {
+               if (!*token)
+                       continue;
+
+               if (new_mode == -1)
+                       new_mode = 0;
+
+               if (!strcmp(token, "none"))
+                       new_mode = 0;
+               else if (!strcmp(token, "tx"))
+                       new_mode |= MODE_TX;
+               else if (!strcmp(token, "rx"))
+                       new_mode |= MODE_RX;
+               else if (!strcmp(token, "link"))
+                       new_mode |= MODE_LINK;
+               else
+                       return -EINVAL;
+       }
+
+       if (new_mode == -1)
+               return -EINVAL;
+
+       write_lock(&trigger_data->lock);
+       trigger_data->mode = new_mode;
+       set_baseline_state(trigger_data);
+       write_unlock(&trigger_data->lock);
+
+       return size;
+}
+
+static DEVICE_ATTR(mode, 0644, led_mode_show, led_mode_store);
+
+static ssize_t led_interval_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+
+       read_lock(&trigger_data->lock);
+       sprintf(buf, "%u\n", jiffies_to_msecs(trigger_data->interval));
+       read_unlock(&trigger_data->lock);
+
+       return strlen(buf) + 1;
+}
+
+static ssize_t led_interval_store(struct device *dev,
+                                 struct device_attribute *attr, const char *buf, size_t size)
+{
+       struct led_classdev *led_cdev = dev_get_drvdata(dev);
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+       int ret = -EINVAL;
+       char *after;
+       unsigned long value = simple_strtoul(buf, &after, 10);
+       size_t count = after - buf;
+
+       if (*after && isspace(*after))
+               count++;
+
+       /* impose some basic bounds on the timer interval */
+       if (count == size && value >= 5 && value <= 10000) {
+               write_lock(&trigger_data->lock);
+               trigger_data->interval = msecs_to_jiffies(value);
+               set_baseline_state(trigger_data); // resets timer
+               write_unlock(&trigger_data->lock);
+               ret = count;
+       }
+
+       return ret;
+}
+
+static DEVICE_ATTR(interval, 0644, led_interval_show, led_interval_store);
+
+static int netdev_trig_notify(struct notifier_block *nb,
+                             unsigned long evt,
+                             void *dv)
+{
+       struct net_device *dev = dv;
+       struct led_netdev_data *trigger_data = container_of(nb, struct led_netdev_data, notifier);
+
+       if (evt != NETDEV_UP && evt != NETDEV_DOWN && evt != NETDEV_CHANGE && evt != NETDEV_REGISTER && evt != NETDEV_UNREGISTER)
+               return NOTIFY_DONE;
+
+       write_lock(&trigger_data->lock);
+
+       if (strcmp(dev->name, trigger_data->device_name))
+               goto done;
+
+       if (evt == NETDEV_REGISTER) {
+               if (trigger_data->net_dev != NULL)
+                       dev_put(trigger_data->net_dev);
+               dev_hold(dev);
+               trigger_data->net_dev = dev;
+               trigger_data->link_up = 0;
+               goto done;
+       }
+
+       if (evt == NETDEV_UNREGISTER && trigger_data->net_dev != NULL) {
+               dev_put(trigger_data->net_dev);
+               trigger_data->net_dev = NULL;
+               goto done;
+       }
+
+       /* UP / DOWN / CHANGE */
+
+       trigger_data->link_up = (evt != NETDEV_DOWN && netif_carrier_ok(dev));
+       set_baseline_state(trigger_data);
+
+done:
+       write_unlock(&trigger_data->lock);
+       return NOTIFY_DONE;
+}
+
+/* here's the real work! */
+static void netdev_trig_timer(unsigned long arg)
+{
+       struct led_netdev_data *trigger_data = (struct led_netdev_data *)arg;
+       struct net_device_stats *dev_stats;
+       unsigned new_activity;
+
+       write_lock(&trigger_data->lock);
+
+       if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) {
+               /* we don't need to do timer work, just reflect link state. */
+               led_set_brightness(trigger_data->led_cdev, ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) ? LED_FULL : LED_OFF);
+               goto no_restart;
+       }
+
+       dev_stats = trigger_data->net_dev->get_stats(trigger_data->net_dev);
+       new_activity =
+               ((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) +
+               ((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0);
+
+       if (trigger_data->mode & MODE_LINK) {
+               /* base state is ON (link present) */
+               /* if there's no link, we don't get this far and the LED is off */
+
+               /* OFF -> ON always */
+               /* ON -> OFF on activity */
+               if (trigger_data->led_cdev->brightness == LED_OFF) {
+                       led_set_brightness(trigger_data->led_cdev, LED_FULL);
+               } else if (trigger_data->last_activity != new_activity) {
+                       led_set_brightness(trigger_data->led_cdev, LED_OFF);
+               }
+       } else {
+               /* base state is OFF */
+               /* ON -> OFF always */
+               /* OFF -> ON on activity */
+               if (trigger_data->led_cdev->brightness == LED_FULL) {
+                       led_set_brightness(trigger_data->led_cdev, LED_OFF);
+               } else if (trigger_data->last_activity != new_activity) {
+                       led_set_brightness(trigger_data->led_cdev, LED_FULL);
+               }
+       }
+
+       trigger_data->last_activity = new_activity;
+       mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
+
+no_restart:
+       write_unlock(&trigger_data->lock);
+}
+
+static void netdev_trig_activate(struct led_classdev *led_cdev)
+{
+       struct led_netdev_data *trigger_data;
+       int rc;
+
+       trigger_data = kzalloc(sizeof(struct led_netdev_data), GFP_KERNEL);
+       if (!trigger_data)
+               return;
+
+       rwlock_init(&trigger_data->lock);
+
+       trigger_data->notifier.notifier_call = netdev_trig_notify;
+       trigger_data->notifier.priority = 10;
+
+       setup_timer(&trigger_data->timer, netdev_trig_timer, (unsigned long) trigger_data);
+
+       trigger_data->led_cdev = led_cdev;
+       trigger_data->net_dev = NULL;
+       trigger_data->device_name[0] = 0;
+
+       trigger_data->mode = 0;
+       trigger_data->interval = msecs_to_jiffies(50);
+       trigger_data->link_up = 0;
+       trigger_data->last_activity = 0;
+
+       led_cdev->trigger_data = trigger_data;
+
+       rc = device_create_file(led_cdev->dev, &dev_attr_device_name);
+       if (rc)
+               goto err_out;
+       rc = device_create_file(led_cdev->dev, &dev_attr_mode);
+       if (rc)
+               goto err_out_device_name;
+       rc = device_create_file(led_cdev->dev, &dev_attr_interval);
+       if (rc)
+               goto err_out_mode;
+
+       register_netdevice_notifier(&trigger_data->notifier);
+       return;
+
+err_out_mode:
+       device_remove_file(led_cdev->dev, &dev_attr_mode);
+err_out_device_name:
+       device_remove_file(led_cdev->dev, &dev_attr_device_name);
+err_out:
+       led_cdev->trigger_data = NULL;
+       kfree(trigger_data);
+}
+
+static void netdev_trig_deactivate(struct led_classdev *led_cdev)
+{
+       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
+
+       if (trigger_data) {
+               unregister_netdevice_notifier(&trigger_data->notifier);
+
+               device_remove_file(led_cdev->dev, &dev_attr_device_name);
+               device_remove_file(led_cdev->dev, &dev_attr_mode);
+               device_remove_file(led_cdev->dev, &dev_attr_interval);
+
+               write_lock(&trigger_data->lock);
+
+               if (trigger_data->net_dev) {
+                       dev_put(trigger_data->net_dev);
+                       trigger_data->net_dev = NULL;
+               }
+
+               write_unlock(&trigger_data->lock);
+
+               del_timer_sync(&trigger_data->timer);
+
+               kfree(trigger_data);
+       }
+}
+
+static struct led_trigger netdev_led_trigger = {
+       .name     = "netdev",
+       .activate = netdev_trig_activate,
+       .deactivate = netdev_trig_deactivate,
+};
+
+static int __init netdev_trig_init(void)
+{
+       return led_trigger_register(&netdev_led_trigger);
+}
+
+static void __exit netdev_trig_exit(void)
+{
+       led_trigger_unregister(&netdev_led_trigger);
+}
+
+module_init(netdev_trig_init);
+module_exit(netdev_trig_exit);
+
+MODULE_AUTHOR("Oliver Jowett <oliver@opencloud.com>");
+MODULE_DESCRIPTION("Netdev LED trigger");
+MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.c b/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.c
new file mode 100644 (file)
index 0000000..3033813
--- /dev/null
@@ -0,0 +1,170 @@
+/*
+ * ADM6996 switch driver
+ *
+ * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation
+ */
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/phy.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include "adm6996.h"
+
+MODULE_DESCRIPTION("Infineon ADM6996 Switch");
+MODULE_AUTHOR("Felix Fietkau");
+MODULE_LICENSE("GPL");
+
+struct adm6996_priv {
+       /* use abstraction for regops, we want to add gpio support in the future */
+       u16 (*read)(struct phy_device *phydev, enum admreg reg);
+       void (*write)(struct phy_device *phydev, enum admreg reg, u16 val);
+};
+
+#define to_adm(_phy) ((struct adm6996_priv *) (_phy)->priv)
+
+
+static inline u16
+r16(struct phy_device *pdev, enum admreg reg)
+{
+       return to_adm(pdev)->read(pdev, reg);
+}
+
+static inline void
+w16(struct phy_device *pdev, enum admreg reg, u16 val)
+{
+       to_adm(pdev)->write(pdev, reg, val);
+}
+
+
+static u16
+adm6996_read_mii_reg(struct phy_device *phydev, enum admreg reg)
+{
+       return phydev->bus->read(phydev->bus, PHYADDR(reg));
+}
+
+static void
+adm6996_write_mii_reg(struct phy_device *phydev, enum admreg reg, u16 val)
+{
+       phydev->bus->write(phydev->bus, PHYADDR(reg), val);
+}
+
+
+static int adm6996_config_init(struct phy_device *pdev)
+{
+       int i;
+
+       printk("%s: ADM6996 PHY driver attached.\n", pdev->attached_dev->name);
+       pdev->supported = ADVERTISED_100baseT_Full;
+       pdev->advertising = ADVERTISED_100baseT_Full;
+
+       /* initialize port and vlan settings */
+       for (i = 0; i < ADM_PHY_PORTS; i++) {
+               w16(pdev, adm_portcfg[i], ADM_PORTCFG_INIT |
+                       ADM_PORTCFG_PVID((i == ADM_WAN_PORT) ? 1 : 0));
+       }
+       w16(pdev, adm_portcfg[5], ADM_PORTCFG_CPU);
+
+       /* reset all ports */
+       for (i = 0; i < ADM_PHY_PORTS; i++) {
+               w16(pdev, ADM_PHY_PORT(i), ADM_PHYCFG_INIT);
+       }
+
+       return 0;
+}
+
+static int adm6996_read_status(struct phy_device *phydev)
+{
+       phydev->speed = SPEED_100;
+       phydev->duplex = DUPLEX_FULL;
+       phydev->state = PHY_UP;
+       return 0;
+}
+
+static int adm6996_config_aneg(struct phy_device *phydev)
+{
+       return 0;
+}
+
+static int adm6996_probe(struct phy_device *pdev)
+{
+       struct adm6996_priv *priv;
+
+       priv = kzalloc(sizeof(struct adm6996_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return -ENOMEM;
+
+       priv->read = adm6996_read_mii_reg;
+       priv->write = adm6996_write_mii_reg;
+       pdev->priv = priv;
+       return 0;
+}
+
+static void adm6996_remove(struct phy_device *pdev)
+{
+       kfree(pdev->priv);
+}
+
+static bool adm6996_detect(struct mii_bus *bus, int addr)
+{
+       u16 reg;
+
+       /* we only attach to phy id 0 */
+       if (addr != 0)
+               return false;
+
+       /* look for the switch on the bus */
+       reg = bus->read(bus, PHYADDR(ADM_SIG0)) & ADM_SIG0_MASK;
+       if (reg != ADM_SIG0_VAL)
+               return false;
+
+       reg = bus->read(bus, PHYADDR(ADM_SIG1)) & ADM_SIG1_MASK;
+       if (reg != ADM_SIG1_VAL)
+               return false;
+
+       return true;
+}
+
+static struct phy_driver adm6996_driver = {
+       .name           = "Infineon ADM6996",
+       .features       = PHY_BASIC_FEATURES,
+       .detect         = adm6996_detect,
+       .probe          = adm6996_probe,
+       .remove         = adm6996_remove,
+       .config_init    = &adm6996_config_init,
+       .config_aneg    = &adm6996_config_aneg,
+       .read_status    = &adm6996_read_status,
+       .driver         = { .owner = THIS_MODULE,},
+};
+
+static int __init adm6996_init(void)
+{
+       return phy_driver_register(&adm6996_driver);
+}
+
+static void __exit adm6996_exit(void)
+{
+       phy_driver_unregister(&adm6996_driver);
+}
+
+module_init(adm6996_init);
+module_exit(adm6996_exit);
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.h b/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/adm6996.h
new file mode 100644 (file)
index 0000000..e074901
--- /dev/null
@@ -0,0 +1,105 @@
+/*
+ * ADM6996 switch driver
+ *
+ * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation
+ */
+#ifndef __ADM6996_H
+#define __ADM6996_H
+
+#define ADM_PHY_PORTS  5
+#define ADM_CPU_PORT   5
+#define ADM_WAN_PORT   0 /* FIXME: dynamic ? */
+
+enum admreg {
+       ADM_EEPROM_BASE         = 0x0,
+               ADM_P0_CFG              = ADM_EEPROM_BASE + 1,
+               ADM_P1_CFG              = ADM_EEPROM_BASE + 3,
+               ADM_P2_CFG              = ADM_EEPROM_BASE + 5,
+               ADM_P3_CFG              = ADM_EEPROM_BASE + 7,
+               ADM_P4_CFG              = ADM_EEPROM_BASE + 8,
+               ADM_P5_CFG              = ADM_EEPROM_BASE + 9,
+       ADM_EEPROM_EXT_BASE     = 0x40,
+       ADM_COUNTER_BASE        = 0xa0,
+               ADM_SIG0                = ADM_COUNTER_BASE + 0,
+               ADM_SIG1                = ADM_COUNTER_BASE + 1,
+       ADM_PHY_BASE            = 0x200,
+#define ADM_PHY_PORT(n) (ADM_PHY_BASE + (0x20 * n))
+};
+
+/* Chip identification patterns */
+#define        ADM_SIG0_MASK   0xfff0
+#define ADM_SIG0_VAL   0x1020
+#define ADM_SIG1_MASK  0xffff
+#define ADM_SIG1_VAL   0x0007
+
+enum {
+       ADM_PHYCFG_COLTST     = (1 << 7),       /* Enable collision test */
+       ADM_PHYCFG_DPLX       = (1 << 8),       /* Enable full duplex */
+       ADM_PHYCFG_ANEN_RST   = (1 << 9),       /* Restart auto negotiation (self clear) */
+       ADM_PHYCFG_ISO        = (1 << 10),      /* Isolate PHY */
+       ADM_PHYCFG_PDN        = (1 << 11),      /* Power down PHY */
+       ADM_PHYCFG_ANEN       = (1 << 12),      /* Enable auto negotiation */
+       ADM_PHYCFG_SPEED_100  = (1 << 13),      /* Enable 100 Mbit/s */
+       ADM_PHYCFG_LPBK       = (1 << 14),      /* Enable loopback operation */
+       ADM_PHYCFG_RST        = (1 << 15),      /* Reset the port (self clear) */
+       ADM_PHYCFG_INIT = (
+               ADM_PHYCFG_RST |
+               ADM_PHYCFG_SPEED_100 |
+               ADM_PHYCFG_ANEN |
+               ADM_PHYCFG_ANEN_RST
+       )
+};
+
+enum {
+       ADM_PORTCFG_FC        = (1 << 0),       /* Enable 802.x flow control */
+       ADM_PORTCFG_AN        = (1 << 1),       /* Enable auto-negotiation */
+       ADM_PORTCFG_SPEED_100 = (1 << 2),       /* Enable 100 Mbit/s */
+       ADM_PORTCFG_DPLX      = (1 << 3),       /* Enable full duplex */
+       ADM_PORTCFG_OT        = (1 << 4),       /* Output tagged packets */
+       ADM_PORTCFG_PD        = (1 << 5),       /* Port disable */
+       ADM_PORTCFG_TV_PRIO   = (1 << 6),       /* 0 = VLAN based priority
+                                                * 1 = TOS based priority */
+       ADM_PORTCFG_PPE       = (1 << 7),       /* Port based priority enable */
+       ADM_PORTCFG_PP_S      = (1 << 8),       /* Port based priority, 2 bits */
+       ADM_PORTCFG_PVID_BASE = (1 << 10),      /* Primary VLAN id, 4 bits */
+       ADM_PORTCFG_FSE       = (1 << 14),      /* Fx select enable */
+       ADM_PORTCFG_CAM       = (1 << 15),      /* Crossover Auto MDIX */
+
+       ADM_PORTCFG_INIT = (
+               ADM_PORTCFG_FC |
+               ADM_PORTCFG_AN |
+               ADM_PORTCFG_SPEED_100 |
+               ADM_PORTCFG_DPLX |
+               ADM_PORTCFG_CAM
+       ),
+       ADM_PORTCFG_CPU = (
+               ADM_PORTCFG_FC |
+               ADM_PORTCFG_SPEED_100 |
+               ADM_PORTCFG_OT |
+               ADM_PORTCFG_DPLX
+       ),
+};
+
+#define ADM_PORTCFG_PPID(N) ((n & 0x3) << 8)
+#define ADM_PORTCFG_PVID(n) ((n & 0xf) << 10)
+
+static const u8 adm_portcfg[] = {
+       [0] = ADM_P0_CFG,
+       [1] = ADM_P1_CFG,
+       [2] = ADM_P2_CFG,
+       [3] = ADM_P3_CFG,
+       [4] = ADM_P4_CFG,
+       [5] = ADM_P5_CFG,
+};
+
+/*
+ * Split the register address in phy id and register
+ * it will get combined again by the mdio bus op
+ */
+#define PHYADDR(_reg)  ((_reg >> 5) & 0xff), (_reg & 0x1f)
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.c b/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.c
new file mode 100644 (file)
index 0000000..78e5afe
--- /dev/null
@@ -0,0 +1,474 @@
+/*
+ * Marvell 88E6060 switch driver
+ * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation
+ */
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/skbuff.h>
+#include <linux/spinlock.h>
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/mii.h>
+#include <linux/ethtool.h>
+#include <linux/phy.h>
+#include <linux/if_vlan.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <asm/uaccess.h>
+#include "mvswitch.h"
+
+/* Undefine this to use trailer mode instead.
+ * I don't know if header mode works with all chips */
+#define HEADER_MODE    1
+
+MODULE_DESCRIPTION("Marvell 88E6060 Switch driver");
+MODULE_AUTHOR("Felix Fietkau");
+MODULE_LICENSE("GPL");
+
+struct mvswitch_priv {
+       /* the driver's tx function */
+       int (*hardstart)(struct sk_buff *skb, struct net_device *dev);
+       struct vlan_group *grp;
+       u8 vlans[16];
+};
+
+#define to_mvsw(_phy) ((struct mvswitch_priv *) (_phy)->priv)
+
+static inline u16
+r16(struct phy_device *phydev, int addr, int reg)
+{
+       return phydev->bus->read(phydev->bus, addr, reg);
+}
+
+static inline void
+w16(struct phy_device *phydev, int addr, int reg, u16 val)
+{
+       phydev->bus->write(phydev->bus, addr, reg, val);
+}
+
+
+static int
+mvswitch_mangle_tx(struct sk_buff *skb, struct net_device *dev)
+{
+       struct mvswitch_priv *priv;
+       char *buf = NULL;
+       u16 vid;
+
+       priv = dev->phy_ptr;
+       if (unlikely(!priv))
+               goto error;
+
+       if (unlikely(skb->len < 16))
+               goto error;
+
+#ifdef HEADER_MODE
+       if (__vlan_hwaccel_get_tag(skb, &vid))
+               goto error;
+
+       if (skb_cloned(skb) || (skb->len <= 62) || (skb_headroom(skb) < MV_HEADER_SIZE)) {
+               if (pskb_expand_head(skb, MV_HEADER_SIZE, (skb->len < 62 ? 62 - skb->len : 0), GFP_ATOMIC))
+                       goto error_expand;
+               if (skb->len < 62)
+                       skb->len = 62;
+       }
+       buf = skb_push(skb, MV_HEADER_SIZE);
+#else
+       if (__vlan_get_tag(skb, &vid))
+               goto error;
+
+       if (unlikely((vid > 15 || !priv->vlans[vid])))
+               goto error;
+
+       if (skb->len <= 64) {
+               if (pskb_expand_head(skb, 0, 64 + MV_TRAILER_SIZE - skb->len, GFP_ATOMIC))
+                       goto error_expand;
+
+               buf = skb->data + 64;
+               skb->len = 64 + MV_TRAILER_SIZE;
+       } else {
+               if (skb_cloned(skb) || unlikely(skb_tailroom(skb) < 4)) {
+                       if (pskb_expand_head(skb, 0, 4, GFP_ATOMIC))
+                               goto error_expand;
+               }
+               buf = skb_put(skb, 4);
+       }
+
+       /* move the ethernet header 4 bytes forward, overwriting the vlan tag */
+       memmove(skb->data + 4, skb->data, 12);
+       skb->data += 4;
+       skb->len -= 4;
+       skb->mac_header += 4;
+#endif
+
+       if (!buf)
+               goto error;
+
+
+#ifdef HEADER_MODE
+       /* prepend the tag */
+       *((__be16 *) buf) = cpu_to_be16(
+               ((vid << MV_HEADER_VLAN_S) & MV_HEADER_VLAN_M) |
+               ((priv->vlans[vid] << MV_HEADER_PORTS_S) & MV_HEADER_PORTS_M)
+       );
+#else
+       /* append the tag */
+       *((__be32 *) buf) = cpu_to_be32((
+               (MV_TRAILER_OVERRIDE << MV_TRAILER_FLAGS_S) |
+               ((priv->vlans[vid] & MV_TRAILER_PORTS_M) << MV_TRAILER_PORTS_S)
+       ));
+#endif
+
+       return priv->hardstart(skb, dev);
+
+error_expand:
+       if (net_ratelimit())
+               printk("%s: failed to expand/update skb for the switch\n", dev->name);
+
+error:
+       /* any errors? drop the packet! */
+       dev_kfree_skb_any(skb);
+       return 0;
+}
+
+static int
+mvswitch_mangle_rx(struct sk_buff *skb, int napi)
+{
+       struct mvswitch_priv *priv;
+       struct net_device *dev;
+       int vlan = -1;
+       unsigned char *buf;
+       int i;
+
+       dev = skb->dev;
+       if (!dev)
+               goto error;
+
+       priv = dev->phy_ptr;
+       if (!priv)
+               goto error;
+
+       if (!priv->grp)
+               goto error;
+
+#ifdef HEADER_MODE
+       buf = skb->data;
+       skb_pull(skb, MV_HEADER_SIZE);
+#else
+       buf = skb->data + skb->len - MV_TRAILER_SIZE;
+       if (buf[0] != 0x80)
+               goto error;
+#endif
+
+       /* look for the vlan matching the incoming port */
+       for (i = 0; i < ARRAY_SIZE(priv->vlans); i++) {
+               if ((1 << buf[1]) & priv->vlans[i])
+                       vlan = i;
+       }
+
+       if (vlan == -1)
+               goto error;
+
+       skb->protocol = eth_type_trans(skb, skb->dev);
+
+       if (napi)
+               return vlan_hwaccel_receive_skb(skb, priv->grp, vlan);
+       else
+               return vlan_hwaccel_rx(skb, priv->grp, vlan);
+
+error:
+       /* no vlan? eat the packet! */
+       dev_kfree_skb_any(skb);
+       return 0;
+}
+
+
+static int
+mvswitch_netif_rx(struct sk_buff *skb)
+{
+       return mvswitch_mangle_rx(skb, 0);
+}
+
+static int
+mvswitch_netif_receive_skb(struct sk_buff *skb)
+{
+       return mvswitch_mangle_rx(skb, 1);
+}
+
+
+static void
+mvswitch_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
+{
+       struct mvswitch_priv *priv = dev->phy_ptr;
+       priv->grp = grp;
+}
+
+
+static int
+mvswitch_wait_mask(struct phy_device *pdev, int addr, int reg, u16 mask, u16 val)
+{
+       int i = 100;
+       u16 r;
+
+       do {
+               r = r16(pdev, addr, reg) & mask;
+               if (r == val)
+                       return 0;
+       } while(--i > 0);
+       return -ETIMEDOUT;
+}
+
+static int
+mvswitch_config_init(struct phy_device *pdev)
+{
+       struct mvswitch_priv *priv = to_mvsw(pdev);
+       struct net_device *dev = pdev->attached_dev;
+       u8 vlmap = 0;
+       int i;
+
+       if (!dev)
+               return -EINVAL;
+
+       printk("%s: Marvell 88E6060 PHY driver attached.\n", dev->name);
+       pdev->supported = ADVERTISED_100baseT_Full;
+       pdev->advertising = ADVERTISED_100baseT_Full;
+       dev->phy_ptr = priv;
+       dev->irq = PHY_POLL;
+
+       /* initialize default vlans */
+       for (i = 0; i < MV_PORTS; i++)
+               priv->vlans[(i == MV_WANPORT ? 1 : 0)] |= (1 << i);
+
+       /* before entering reset, disable all ports */
+       for (i = 0; i < MV_PORTS; i++)
+               w16(pdev, MV_PORTREG(CONTROL, i), 0x00);
+
+       msleep(2); /* wait for the status change to settle in */
+
+       /* put the ATU in reset */
+       w16(pdev, MV_SWITCHREG(ATU_CTRL), MV_ATUCTL_RESET);
+
+       i = mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_CTRL), MV_ATUCTL_RESET, 0);
+       if (i < 0) {
+               printk("%s: Timeout waiting for the switch to reset.\n", dev->name);
+               return i;
+       }
+
+       /* set the ATU flags */
+       w16(pdev, MV_SWITCHREG(ATU_CTRL),
+               MV_ATUCTL_NO_LEARN |
+               MV_ATUCTL_ATU_1K |
+               MV_ATUCTL_AGETIME(MV_ATUCTL_AGETIME_MIN) /* minimum without disabling ageing */
+       );
+
+       /* initialize the cpu port */
+       w16(pdev, MV_PORTREG(CONTROL, MV_CPUPORT),
+#ifdef HEADER_MODE
+               MV_PORTCTRL_HEADER |
+#else
+               MV_PORTCTRL_RXTR |
+               MV_PORTCTRL_TXTR |
+#endif
+               MV_PORTCTRL_ENABLED
+       );
+       /* wait for the phy change to settle in */
+       msleep(2);
+       for (i = 0; i < MV_PORTS; i++) {
+               u8 pvid = 0;
+               int j;
+
+               vlmap = 0;
+
+               /* look for the matching vlan */
+               for (j = 0; j < ARRAY_SIZE(priv->vlans); j++) {
+                       if (priv->vlans[j] & (1 << i)) {
+                               vlmap = priv->vlans[j];
+                               pvid = j;
+                       }
+               }
+               /* leave port unconfigured if it's not part of a vlan */
+               if (!vlmap)
+                       continue;
+
+               /* add the cpu port to the allowed destinations list */
+               vlmap |= (1 << MV_CPUPORT);
+
+               /* take port out of its own vlan destination map */
+               vlmap &= ~(1 << i);
+
+               /* apply vlan settings */
+               w16(pdev, MV_PORTREG(VLANMAP, i),
+                       MV_PORTVLAN_PORTS(vlmap) |
+                       MV_PORTVLAN_ID(i)
+               );
+
+               /* re-enable port */
+               w16(pdev, MV_PORTREG(CONTROL, i),
+                       MV_PORTCTRL_ENABLED
+               );
+       }
+
+       w16(pdev, MV_PORTREG(VLANMAP, MV_CPUPORT),
+               MV_PORTVLAN_ID(MV_CPUPORT)
+       );
+
+       /* set the port association vector */
+       for (i = 0; i <= MV_PORTS; i++) {
+               w16(pdev, MV_PORTREG(ASSOC, i),
+                       MV_PORTASSOC_PORTS(1 << i)
+               );
+       }
+
+       /* init switch control */
+       w16(pdev, MV_SWITCHREG(CTRL),
+               MV_SWITCHCTL_MSIZE |
+               MV_SWITCHCTL_DROP
+       );
+
+       /* hook into the tx function */
+       priv->hardstart = dev->hard_start_xmit;
+       pdev->netif_receive_skb = mvswitch_netif_receive_skb;
+       pdev->netif_rx = mvswitch_netif_rx;
+       dev->hard_start_xmit = mvswitch_mangle_tx;
+       dev->vlan_rx_register = mvswitch_vlan_rx_register;
+#ifdef HEADER_MODE
+       dev->features |= NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX;
+#else
+       dev->features |= NETIF_F_HW_VLAN_RX;
+#endif
+
+       return 0;
+}
+
+static int
+mvswitch_read_status(struct phy_device *pdev)
+{
+       pdev->speed = SPEED_100;
+       pdev->duplex = DUPLEX_FULL;
+       pdev->state = PHY_UP;
+
+       /* XXX ugly workaround: we can't force the switch
+        * to gracefully handle hosts moving from one port to another,
+        * so we have to regularly clear the ATU database */
+
+       /* wait for the ATU to become available */
+       mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_OP), MV_ATUOP_INPROGRESS, 0);
+
+       /* flush the ATU */
+       w16(pdev, MV_SWITCHREG(ATU_OP),
+               MV_ATUOP_INPROGRESS |
+               MV_ATUOP_FLUSH_ALL
+       );
+
+       /* wait for operation to complete */
+       mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_OP), MV_ATUOP_INPROGRESS, 0);
+
+       return 0;
+}
+
+static int
+mvswitch_config_aneg(struct phy_device *phydev)
+{
+       return 0;
+}
+
+static void
+mvswitch_remove(struct phy_device *pdev)
+{
+       struct mvswitch_priv *priv = to_mvsw(pdev);
+       struct net_device *dev = pdev->attached_dev;
+
+       /* restore old xmit handler */
+       if (priv->hardstart && dev)
+               dev->hard_start_xmit = priv->hardstart;
+       dev->vlan_rx_register = NULL;
+       dev->vlan_rx_kill_vid = NULL;
+       dev->phy_ptr = NULL;
+       dev->features &= ~NETIF_F_HW_VLAN_RX;
+       kfree(priv);
+}
+
+static bool
+mvswitch_detect(struct mii_bus *bus, int addr)
+{
+       u16 reg;
+       int i;
+
+       /* we attach to phy id 31 to make sure that the late probe works */
+       if (addr != 31)
+               return false;
+
+       /* look for the switch on the bus */
+       reg = bus->read(bus, MV_PORTREG(IDENT, 0)) & MV_IDENT_MASK;
+       if (reg != MV_IDENT_VALUE)
+               return false;
+
+       /* 
+        * Now that we've established that the switch actually exists, let's 
+        * get rid of the competition :)
+        */
+       for (i = 0; i < 31; i++) {
+               if (!bus->phy_map[i])
+                       continue;
+
+               device_unregister(&bus->phy_map[i]->dev);
+               kfree(bus->phy_map[i]);
+               bus->phy_map[i] = NULL;
+       }
+
+       return true;
+}
+
+static int
+mvswitch_probe(struct phy_device *pdev)
+{
+       struct mvswitch_priv *priv;
+
+       priv = kzalloc(sizeof(struct mvswitch_priv), GFP_KERNEL);
+       if (priv == NULL)
+               return -ENOMEM;
+
+       pdev->priv = priv;
+
+       return 0;
+}
+
+
+static struct phy_driver mvswitch_driver = {
+       .name           = "Marvell 88E6060",
+       .features       = PHY_BASIC_FEATURES,
+       .detect         = &mvswitch_detect,
+       .probe          = &mvswitch_probe,
+       .remove         = &mvswitch_remove,
+       .config_init    = &mvswitch_config_init,
+       .config_aneg    = &mvswitch_config_aneg,
+       .read_status    = &mvswitch_read_status,
+       .driver         = { .owner = THIS_MODULE,},
+};
+
+static int __init
+mvswitch_init(void)
+{
+       return phy_driver_register(&mvswitch_driver);
+}
+
+static void __exit
+mvswitch_exit(void)
+{
+       phy_driver_unregister(&mvswitch_driver);
+}
+
+module_init(mvswitch_init);
+module_exit(mvswitch_exit);
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.h b/target/linux/generic-2.6/files-2.6.24/drivers/net/phy/mvswitch.h
new file mode 100644 (file)
index 0000000..1563eec
--- /dev/null
@@ -0,0 +1,145 @@
+/*
+ * Marvell 88E6060 switch driver
+ * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of the GNU General Public License v2 as published by the
+ * Free Software Foundation
+ */
+#ifndef __MVSWITCH_H
+#define __MVSWITCH_H
+
+#define MV_HEADER_SIZE 2
+#define MV_HEADER_PORTS_M      0x001f
+#define MV_HEADER_PORTS_S      0
+#define MV_HEADER_VLAN_M       0xf000
+#define MV_HEADER_VLAN_S       12
+
+#define MV_TRAILER_SIZE        4
+#define MV_TRAILER_PORTS_M     0x1f
+#define MV_TRAILER_PORTS_S     16
+#define MV_TRAILER_FLAGS_S     24
+#define MV_TRAILER_OVERRIDE    0x80
+
+
+#define MV_PORTS       5
+#define MV_WANPORT     4
+#define MV_CPUPORT     5
+
+#define MV_BASE                0x10
+
+#define MV_PHYPORT_BASE                (MV_BASE + 0x0)
+#define MV_PHYPORT(_n)         (MV_PHYPORT_BASE + (_n))
+#define MV_SWITCHPORT_BASE     (MV_BASE + 0x8)
+#define MV_SWITCHPORT(_n)      (MV_SWITCHPORT_BASE + (_n))
+#define MV_SWITCHREGS          (MV_BASE + 0xf)
+
+enum {
+       MV_PHY_CONTROL      = 0x00,
+       MV_PHY_STATUS       = 0x01,
+       MV_PHY_IDENT0       = 0x02,
+       MV_PHY_IDENT1       = 0x03,
+       MV_PHY_ANEG         = 0x04,
+       MV_PHY_LINK_ABILITY = 0x05,
+       MV_PHY_ANEG_EXPAND  = 0x06,
+       MV_PHY_XMIT_NEXTP   = 0x07,
+       MV_PHY_LINK_NEXTP   = 0x08,
+       MV_PHY_CONTROL1     = 0x10,
+       MV_PHY_STATUS1      = 0x11,
+       MV_PHY_INTR_EN      = 0x12,
+       MV_PHY_INTR_STATUS  = 0x13,
+       MV_PHY_INTR_PORT    = 0x14,
+       MV_PHY_RECV_COUNTER = 0x16,
+       MV_PHY_LED_PARALLEL = 0x16,
+       MV_PHY_LED_STREAM   = 0x17,
+       MV_PHY_LED_CTRL     = 0x18,
+       MV_PHY_LED_OVERRIDE = 0x19,
+       MV_PHY_VCT_CTRL     = 0x1a,
+       MV_PHY_VCT_STATUS   = 0x1b,
+       MV_PHY_CONTROL2     = 0x1e
+};
+#define MV_PHYREG(_type, _port) MV_PHYPORT(_port), MV_PHY_##_type
+
+enum {
+       MV_PORT_STATUS      = 0x00,
+       MV_PORT_IDENT       = 0x03,
+       MV_PORT_CONTROL     = 0x04,
+       MV_PORT_VLANMAP     = 0x06,
+       MV_PORT_ASSOC       = 0x0b,
+       MV_PORT_RXCOUNT     = 0x10,
+       MV_PORT_TXCOUNT     = 0x11,
+};
+#define MV_PORTREG(_type, _port) MV_SWITCHPORT(_port), MV_PORT_##_type
+
+enum {
+       MV_PORTCTRL_BLOCK   =  (1 << 0),
+       MV_PORTCTRL_LEARN   =  (2 << 0),
+       MV_PORTCTRL_ENABLED =  (3 << 0),
+       MV_PORTCTRL_VLANTUN =  (1 << 7),        /* Enforce VLANs on packets */
+       MV_PORTCTRL_RXTR    =  (1 << 8),        /* Enable Marvell packet trailer for ingress */
+       MV_PORTCTRL_HEADER      = (1 << 11),    /* Enable Marvell packet header mode for port */
+       MV_PORTCTRL_TXTR    = (1 << 14),        /* Enable Marvell packet trailer for egress */
+       MV_PORTCTRL_FORCEFL = (1 << 15),        /* force flow control */
+};
+
+#define MV_PORTVLAN_ID(_n) (((_n) & 0xf) << 12)
+#define MV_PORTVLAN_PORTS(_n) ((_n) & 0x3f)
+
+#define MV_PORTASSOC_PORTS(_n) ((_n) & 0x1f)
+#define MV_PORTASSOC_MONITOR   (1 << 15)
+
+enum {
+       MV_SWITCH_MAC0      = 0x01,
+       MV_SWITCH_MAC1      = 0x02,
+       MV_SWITCH_MAC2      = 0x03,
+       MV_SWITCH_CTRL      = 0x04,
+       MV_SWITCH_ATU_CTRL  = 0x0a,
+       MV_SWITCH_ATU_OP    = 0x0b,
+       MV_SWITCH_ATU_DATA  = 0x0c,
+       MV_SWITCH_ATU_MAC0  = 0x0d,
+       MV_SWITCH_ATU_MAC1  = 0x0e,
+       MV_SWITCH_ATU_MAC2  = 0x0f,
+};
+#define MV_SWITCHREG(_type) MV_SWITCHREGS, MV_SWITCH_##_type
+
+enum {
+       MV_SWITCHCTL_EEIE   =  (1 << 0),        /* EEPROM interrupt enable */
+       MV_SWITCHCTL_PHYIE  =  (1 << 1),        /* PHY interrupt enable */
+       MV_SWITCHCTL_ATUDONE=  (1 << 2),        /* ATU done interrupt enable */
+       MV_SWITCHCTL_ATUIE  =  (1 << 3),        /* ATU interrupt enable */
+       MV_SWITCHCTL_CTRMODE=  (1 << 8),        /* statistics for rx and tx errors */
+       MV_SWITCHCTL_RELOAD =  (1 << 9),        /* reload registers from eeprom */
+       MV_SWITCHCTL_MSIZE  = (1 << 10),        /* increase maximum frame size */
+       MV_SWITCHCTL_DROP   = (1 << 13),        /* discard frames with excessive collisions */
+};
+
+enum {
+#define MV_ATUCTL_AGETIME_MIN  16
+#define MV_ATUCTL_AGETIME_MAX  4080
+#define MV_ATUCTL_AGETIME(_n)  ((((_n) / 16) & 0xff) << 4)
+       MV_ATUCTL_ATU_256   = (0 << 12),
+       MV_ATUCTL_ATU_512   = (1 << 12),
+       MV_ATUCTL_ATU_1K        = (2 << 12),
+       MV_ATUCTL_ATUMASK   = (3 << 12),
+       MV_ATUCTL_NO_LEARN  = (1 << 14),
+       MV_ATUCTL_RESET     = (1 << 15),
+};
+
+enum {
+#define MV_ATUOP_DBNUM(_n)     ((_n) & 0x0f)
+
+       MV_ATUOP_NOOP       = (0 << 12),
+       MV_ATUOP_FLUSH_ALL  = (1 << 12),
+       MV_ATUOP_FLUSH_U    = (2 << 12),
+       MV_ATUOP_LOAD_DB    = (3 << 12),
+       MV_ATUOP_GET_NEXT   = (4 << 12),
+       MV_ATUOP_FLUSH_DB   = (5 << 12),
+       MV_ATUOP_FLUSH_DB_UU= (6 << 12),
+
+       MV_ATUOP_INPROGRESS = (1 << 15),
+};
+
+#define MV_IDENT_MASK          0xfff0
+#define MV_IDENT_VALUE         0x0600
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/spi/spi_gpio.c b/target/linux/generic-2.6/files-2.6.24/drivers/spi/spi_gpio.c
new file mode 100644 (file)
index 0000000..31048ac
--- /dev/null
@@ -0,0 +1,242 @@
+/*
+ * Bitbanging SPI bus driver using GPIO API
+ *
+ * Copyright (c) 2008 Piotr Skamruk
+ * Copyright (c) 2008 Michael Buesch
+ *
+ * based on spi_s3c2410_gpio.c
+ *   Copyright (c) 2006 Ben Dooks
+ *   Copyright (c) 2006 Simtec Electronics
+ * and on i2c-gpio.c
+ *   Copyright (C) 2007 Atmel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+#include "linux/spi/spi_gpio.h" //XXX
+#include <asm/gpio.h>
+
+
+struct spi_gpio {
+       struct spi_bitbang bitbang;
+       struct spi_gpio_platform_data *info;
+       struct platform_device *pdev;
+       struct spi_board_info bi;
+};
+
+
+static inline struct spi_gpio *spidev_to_sg(struct spi_device *dev)
+{
+       return dev->controller_data;
+}
+
+static inline void setsck(struct spi_device *dev, int val)
+{
+       struct spi_gpio *sp = spidev_to_sg(dev);
+       gpio_set_value(sp->info->pin_clk, val ? 1 : 0);
+}
+
+static inline void setmosi(struct spi_device *dev, int val )
+{
+       struct spi_gpio *sp = spidev_to_sg(dev);
+       gpio_set_value(sp->info->pin_mosi, val ? 1 : 0);
+}
+
+static inline u32 getmiso(struct spi_device *dev)
+{
+       struct spi_gpio *sp = spidev_to_sg(dev);
+       return gpio_get_value(sp->info->pin_miso) ? 1 : 0;
+}
+
+static inline void do_spidelay(struct spi_device *dev, unsigned nsecs)
+{
+       struct spi_gpio *sp = spidev_to_sg(dev);
+
+       if (!sp->info->no_spi_delay)
+               ndelay(nsecs);
+}
+
+#define spidelay(nsecs) do {                                   \
+       /* Steal the spi_device pointer from our caller.        \
+        * The bitbang-API should probably get fixed here... */ \
+       do_spidelay(spi, nsecs);                                \
+  } while (0)
+
+#define EXPAND_BITBANG_TXRX
+#include <linux/spi/spi_bitbang.h>
+
+static u32 spi_gpio_txrx_mode0(struct spi_device *spi,
+                              unsigned nsecs, u32 word, u8 bits)
+{
+        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
+}
+
+static u32 spi_gpio_txrx_mode1(struct spi_device *spi,
+                              unsigned nsecs, u32 word, u8 bits)
+{
+        return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
+}
+
+static u32 spi_gpio_txrx_mode2(struct spi_device *spi,
+                              unsigned nsecs, u32 word, u8 bits)
+{
+        return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
+}
+
+static u32 spi_gpio_txrx_mode3(struct spi_device *spi,
+                              unsigned nsecs, u32 word, u8 bits)
+{
+        return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
+}
+
+static void spi_gpio_chipselect(struct spi_device *dev, int on)
+{
+       struct spi_gpio *sp = spidev_to_sg(dev);
+
+       if (sp->info->cs_activelow)
+               on = !on;
+       gpio_set_value(sp->info->pin_cs, on ? 1 : 0);
+}
+
+static int spi_gpio_probe(struct platform_device *pdev)
+{
+       struct spi_master *master;
+       struct spi_gpio_platform_data *pdata;
+       struct spi_gpio *sp;
+       struct spi_device *spidev;
+       int err;
+
+       pdata = pdev->dev.platform_data;
+       if (!pdata)
+               return -ENXIO;
+
+       err = -ENOMEM;
+       master = spi_alloc_master(&pdev->dev, sizeof(struct spi_gpio));
+       if (!master)
+               goto err_alloc_master;
+
+       sp = spi_master_get_devdata(master);
+       platform_set_drvdata(pdev, sp);
+       sp->info = pdata;
+
+       err = gpio_request(pdata->pin_clk, "spi_clock");
+       if (err)
+               goto err_request_clk;
+       err = gpio_request(pdata->pin_mosi, "spi_mosi");
+       if (err)
+               goto err_request_mosi;
+       err = gpio_request(pdata->pin_miso, "spi_miso");
+       if (err)
+               goto err_request_miso;
+       err = gpio_request(pdata->pin_cs, "spi_cs");
+       if (err)
+               goto err_request_cs;
+
+       sp->bitbang.master = spi_master_get(master);
+       sp->bitbang.master->bus_num = -1;
+       sp->bitbang.master->num_chipselect = 1;
+       sp->bitbang.chipselect = spi_gpio_chipselect;
+       sp->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_mode0;
+       sp->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_mode1;
+       sp->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_mode2;
+       sp->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_mode3;
+
+       gpio_direction_output(pdata->pin_clk, 0);
+       gpio_direction_output(pdata->pin_mosi, 0);
+       gpio_direction_output(pdata->pin_cs,
+                             pdata->cs_activelow ? 1 : 0);
+       gpio_direction_input(pdata->pin_miso);
+
+       err = spi_bitbang_start(&sp->bitbang);
+       if (err)
+               goto err_no_bitbang;
+       err = pdata->boardinfo_setup(&sp->bi, master,
+                                    pdata->boardinfo_setup_data);
+       if (err)
+               goto err_bi_setup;
+       sp->bi.controller_data = sp;
+       spidev = spi_new_device(master, &sp->bi);
+       if (!spidev)
+               goto err_new_dev;
+
+       return 0;
+
+err_new_dev:
+err_bi_setup:
+       spi_bitbang_stop(&sp->bitbang);
+err_no_bitbang:
+       spi_master_put(sp->bitbang.master);
+       gpio_free(pdata->pin_cs);
+err_request_cs:
+       gpio_free(pdata->pin_miso);
+err_request_miso:
+       gpio_free(pdata->pin_mosi);
+err_request_mosi:
+       gpio_free(pdata->pin_clk);
+err_request_clk:
+       kfree(master);
+
+err_alloc_master:
+       return err;
+}
+
+static int __devexit spi_gpio_remove(struct platform_device *pdev)
+{
+       struct spi_gpio *sp;
+       struct spi_gpio_platform_data *pdata;
+
+       pdata = pdev->dev.platform_data;
+       sp = platform_get_drvdata(pdev);
+
+       gpio_free(pdata->pin_clk);
+       gpio_free(pdata->pin_mosi);
+       gpio_free(pdata->pin_miso);
+       gpio_free(pdata->pin_cs);
+       spi_bitbang_stop(&sp->bitbang);
+       spi_master_put(sp->bitbang.master);
+
+       return 0;
+}
+
+static struct platform_driver spi_gpio_driver = {
+       .driver         = {
+               .name   = "spi-gpio",
+               .owner  = THIS_MODULE,
+       },
+       .probe          = spi_gpio_probe,
+       .remove         = __devexit_p(spi_gpio_remove),
+};
+
+static int __init spi_gpio_init(void)
+{
+       int err;
+
+       err = platform_driver_register(&spi_gpio_driver);
+       if (err)
+               printk(KERN_ERR "spi-gpio: register failed: %d\n", err);
+
+       return err;
+}
+module_init(spi_gpio_init);
+
+static void __exit spi_gpio_exit(void)
+{
+       platform_driver_unregister(&spi_gpio_driver);
+}
+module_exit(spi_gpio_exit);
+
+MODULE_AUTHOR("Piot Skamruk <piotr.skamruk at gmail.com>");
+MODULE_AUTHOR("Michael Buesch");
+MODULE_DESCRIPTION("Platform independent GPIO bitbangling SPI driver");
+MODULE_LICENSE("GPL v2");
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/Kconfig b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/Kconfig
new file mode 100644 (file)
index 0000000..d976660
--- /dev/null
@@ -0,0 +1,117 @@
+menu "Sonics Silicon Backplane"
+
+config SSB_POSSIBLE
+       bool
+       depends on HAS_IOMEM
+       default y
+
+config SSB
+       tristate "Sonics Silicon Backplane support"
+       depends on SSB_POSSIBLE
+       help
+         Support for the Sonics Silicon Backplane bus.
+         You only need to enable this option, if you are
+         configuring a kernel for an embedded system with
+         this bus.
+         It will be auto-selected if needed in other
+         environments.
+
+         The module will be called ssb.
+
+         If unsure, say N.
+
+config SSB_PCIHOST_POSSIBLE
+       bool
+       depends on SSB && (PCI = y || PCI = SSB)
+       default y
+
+config SSB_PCIHOST
+       bool "Support for SSB on PCI-bus host"
+       depends on SSB_PCIHOST_POSSIBLE
+       default y
+       help
+         Support for a Sonics Silicon Backplane on top
+         of a PCI device.
+
+         If unsure, say Y
+
+config SSB_PCMCIAHOST_POSSIBLE
+       bool
+       depends on SSB && (PCMCIA = y || PCMCIA = SSB) && EXPERIMENTAL
+       default y
+
+config SSB_PCMCIAHOST
+       bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)"
+       depends on SSB_PCMCIAHOST_POSSIBLE
+       help
+         Support for a Sonics Silicon Backplane on top
+         of a PCMCIA device.
+
+         If unsure, say N
+
+config SSB_SILENT
+       bool "No SSB kernel messages"
+       depends on SSB && EMBEDDED
+       help
+         This option turns off all Sonics Silicon Backplane printks.
+         Note that you won't be able to identify problems, once
+         messages are turned off.
+         This might only be desired for production kernels on
+         embedded devices to reduce the kernel size.
+
+         Say N
+
+config SSB_DEBUG
+       bool "SSB debugging"
+       depends on SSB && !SSB_SILENT
+       help
+         This turns on additional runtime checks and debugging
+         messages. Turn this on for SSB troubleshooting.
+
+         If unsure, say N
+
+config SSB_SERIAL
+       bool
+       depends on SSB
+       # ChipCommon and ExtIf serial support routines.
+
+config SSB_DRIVER_PCICORE_POSSIBLE
+       bool
+       depends on SSB_PCIHOST
+       default y
+
+config SSB_DRIVER_PCICORE
+       bool "SSB PCI core driver"
+       depends on SSB_DRIVER_PCICORE_POSSIBLE
+       help
+         Driver for the Sonics Silicon Backplane attached
+         Broadcom PCI core.
+
+         If unsure, say Y
+
+config SSB_PCICORE_HOSTMODE
+       bool "Hostmode support for SSB PCI core (EXPERIMENTAL)"
+       depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS && EXPERIMENTAL
+       help
+         PCIcore hostmode operation (external PCI bus).
+
+config SSB_DRIVER_MIPS
+       bool "SSB Broadcom MIPS core driver (EXPERIMENTAL)"
+       depends on SSB && MIPS && EXPERIMENTAL
+       select SSB_SERIAL
+       help
+         Driver for the Sonics Silicon Backplane attached
+         Broadcom MIPS core.
+
+         If unsure, say N
+
+config SSB_DRIVER_EXTIF
+       bool "SSB Broadcom EXTIF core driver (EXPERIMENTAL)"
+       depends on SSB_DRIVER_MIPS && EXPERIMENTAL
+       help
+         Driver for the Sonics Silicon Backplane attached
+         Broadcom EXTIF core.
+
+         If unsure, say N
+
+endmenu
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/Makefile b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/Makefile
new file mode 100644 (file)
index 0000000..7be3975
--- /dev/null
@@ -0,0 +1,18 @@
+# core
+ssb-y                                  += main.o scan.o
+
+# host support
+ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o
+ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o
+
+# built-in drivers
+ssb-y                                  += driver_chipcommon.o
+ssb-$(CONFIG_SSB_DRIVER_MIPS)          += driver_mipscore.o
+ssb-$(CONFIG_SSB_DRIVER_EXTIF)         += driver_extif.o
+ssb-$(CONFIG_SSB_DRIVER_PCICORE)       += driver_pcicore.o
+
+# b43 pci-ssb-bridge driver
+# Not strictly a part of SSB, but kept here for convenience
+ssb-$(CONFIG_SSB_PCIHOST)              += b43_pci_bridge.o
+
+obj-$(CONFIG_SSB)                      += ssb.o
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/b43_pci_bridge.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/b43_pci_bridge.c
new file mode 100644 (file)
index 0000000..2d27d6d
--- /dev/null
@@ -0,0 +1,50 @@
+/*
+ * Broadcom 43xx PCI-SSB bridge module
+ *
+ * This technically is a separate PCI driver module, but
+ * because of its small size we include it in the SSB core
+ * instead of creating a standalone module.
+ *
+ * Copyright 2007  Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/pci.h>
+#include <linux/ssb/ssb.h>
+
+#include "ssb_private.h"
+
+
+static const struct pci_device_id b43_pci_bridge_tbl[] = {
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4301) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4307) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4311) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4328) },
+       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4329) },
+       { 0, },
+};
+MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl);
+
+static struct pci_driver b43_pci_bridge_driver = {
+       .name = "b43-pci-bridge",
+       .id_table = b43_pci_bridge_tbl,
+};
+
+
+int __init b43_pci_ssb_bridge_init(void)
+{
+       return ssb_pcihost_register(&b43_pci_bridge_driver);
+}
+
+void __exit b43_pci_ssb_bridge_exit(void)
+{
+       ssb_pcihost_unregister(&b43_pci_bridge_driver);
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_chipcommon.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_chipcommon.c
new file mode 100644 (file)
index 0000000..6fbf1c5
--- /dev/null
@@ -0,0 +1,445 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom ChipCommon core driver
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/ssb/ssb_regs.h>
+#include <linux/pci.h>
+
+#include "ssb_private.h"
+
+
+/* Clock sources */
+enum ssb_clksrc {
+       /* PCI clock */
+       SSB_CHIPCO_CLKSRC_PCI,
+       /* Crystal slow clock oscillator */
+       SSB_CHIPCO_CLKSRC_XTALOS,
+       /* Low power oscillator */
+       SSB_CHIPCO_CLKSRC_LOPWROS,
+};
+
+
+static inline u32 chipco_read32(struct ssb_chipcommon *cc,
+                               u16 offset)
+{
+       return ssb_read32(cc->dev, offset);
+}
+
+static inline void chipco_write32(struct ssb_chipcommon *cc,
+                                 u16 offset,
+                                 u32 value)
+{
+       ssb_write32(cc->dev, offset, value);
+}
+
+static inline void chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset,
+                                        u32 mask, u32 value)
+{
+       value &= mask;
+       value |= chipco_read32(cc, offset) & ~mask;
+       chipco_write32(cc, offset, value);
+}
+
+void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc,
+                             enum ssb_clkmode mode)
+{
+       struct ssb_device *ccdev = cc->dev;
+       struct ssb_bus *bus;
+       u32 tmp;
+
+       if (!ccdev)
+               return;
+       bus = ccdev->bus;
+       /* chipcommon cores prior to rev6 don't support dynamic clock control */
+       if (ccdev->id.revision < 6)
+               return;
+       /* chipcommon cores rev10 are a whole new ball game */
+       if (ccdev->id.revision >= 10)
+               return;
+       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
+               return;
+
+       switch (mode) {
+       case SSB_CLKMODE_SLOW:
+               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
+               tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW;
+               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
+               break;
+       case SSB_CLKMODE_FAST:
+               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */
+               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
+               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
+               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL;
+               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
+               break;
+       case SSB_CLKMODE_DYNAMIC:
+               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
+               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
+               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL;
+               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
+               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL)
+                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
+               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
+
+               /* for dynamic control, we have to release our xtal_pu "force on" */
+               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL)
+                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0);
+               break;
+       default:
+               SSB_WARN_ON(1);
+       }
+}
+
+/* Get the Slow Clock Source */
+static enum ssb_clksrc chipco_pctl_get_slowclksrc(struct ssb_chipcommon *cc)
+{
+       struct ssb_bus *bus = cc->dev->bus;
+       u32 uninitialized_var(tmp);
+
+       if (cc->dev->id.revision < 6) {
+               if (bus->bustype == SSB_BUSTYPE_SSB ||
+                   bus->bustype == SSB_BUSTYPE_PCMCIA)
+                       return SSB_CHIPCO_CLKSRC_XTALOS;
+               if (bus->bustype == SSB_BUSTYPE_PCI) {
+                       pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT, &tmp);
+                       if (tmp & 0x10)
+                               return SSB_CHIPCO_CLKSRC_PCI;
+                       return SSB_CHIPCO_CLKSRC_XTALOS;
+               }
+       }
+       if (cc->dev->id.revision < 10) {
+               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
+               tmp &= 0x7;
+               if (tmp == 0)
+                       return SSB_CHIPCO_CLKSRC_LOPWROS;
+               if (tmp == 1)
+                       return SSB_CHIPCO_CLKSRC_XTALOS;
+               if (tmp == 2)
+                       return SSB_CHIPCO_CLKSRC_PCI;
+       }
+
+       return SSB_CHIPCO_CLKSRC_XTALOS;
+}
+
+/* Get maximum or minimum (depending on get_max flag) slowclock frequency. */
+static int chipco_pctl_clockfreqlimit(struct ssb_chipcommon *cc, int get_max)
+{
+       int uninitialized_var(limit);
+       enum ssb_clksrc clocksrc;
+       int divisor = 1;
+       u32 tmp;
+
+       clocksrc = chipco_pctl_get_slowclksrc(cc);
+       if (cc->dev->id.revision < 6) {
+               switch (clocksrc) {
+               case SSB_CHIPCO_CLKSRC_PCI:
+                       divisor = 64;
+                       break;
+               case SSB_CHIPCO_CLKSRC_XTALOS:
+                       divisor = 32;
+                       break;
+               default:
+                       SSB_WARN_ON(1);
+               }
+       } else if (cc->dev->id.revision < 10) {
+               switch (clocksrc) {
+               case SSB_CHIPCO_CLKSRC_LOPWROS:
+                       break;
+               case SSB_CHIPCO_CLKSRC_XTALOS:
+               case SSB_CHIPCO_CLKSRC_PCI:
+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
+                       divisor = (tmp >> 16) + 1;
+                       divisor *= 4;
+                       break;
+               }
+       } else {
+               tmp = chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL);
+               divisor = (tmp >> 16) + 1;
+               divisor *= 4;
+       }
+
+       switch (clocksrc) {
+       case SSB_CHIPCO_CLKSRC_LOPWROS:
+               if (get_max)
+                       limit = 43000;
+               else
+                       limit = 25000;
+               break;
+       case SSB_CHIPCO_CLKSRC_XTALOS:
+               if (get_max)
+                       limit = 20200000;
+               else
+                       limit = 19800000;
+               break;
+       case SSB_CHIPCO_CLKSRC_PCI:
+               if (get_max)
+                       limit = 34000000;
+               else
+                       limit = 25000000;
+               break;
+       }
+       limit /= divisor;
+
+       return limit;
+}
+
+static void chipco_powercontrol_init(struct ssb_chipcommon *cc)
+{
+       struct ssb_bus *bus = cc->dev->bus;
+
+       if (bus->chip_id == 0x4321) {
+               if (bus->chip_rev == 0)
+                       chipco_write32(cc, SSB_CHIPCO_CHIPCTL, 0x3A4);
+               else if (bus->chip_rev == 1)
+                       chipco_write32(cc, SSB_CHIPCO_CHIPCTL, 0xA4);
+       }
+
+       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
+               return;
+
+       if (cc->dev->id.revision >= 10) {
+               /* Set Idle Power clock rate to 1Mhz */
+               chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL,
+                              (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) &
+                               0x0000FFFF) | 0x00040000);
+       } else {
+               int maxfreq;
+
+               maxfreq = chipco_pctl_clockfreqlimit(cc, 1);
+               chipco_write32(cc, SSB_CHIPCO_PLLONDELAY,
+                              (maxfreq * 150 + 999999) / 1000000);
+               chipco_write32(cc, SSB_CHIPCO_FREFSELDELAY,
+                              (maxfreq * 15 + 999999) / 1000000);
+       }
+}
+
+static void calc_fast_powerup_delay(struct ssb_chipcommon *cc)
+{
+       struct ssb_bus *bus = cc->dev->bus;
+       int minfreq;
+       unsigned int tmp;
+       u32 pll_on_delay;
+
+       if (bus->bustype != SSB_BUSTYPE_PCI)
+               return;
+       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
+               return;
+
+       minfreq = chipco_pctl_clockfreqlimit(cc, 0);
+       pll_on_delay = chipco_read32(cc, SSB_CHIPCO_PLLONDELAY);
+       tmp = (((pll_on_delay + 2) * 1000000) + (minfreq - 1)) / minfreq;
+       SSB_WARN_ON(tmp & ~0xFFFF);
+
+       cc->fast_pwrup_delay = tmp;
+}
+
+void ssb_chipcommon_init(struct ssb_chipcommon *cc)
+{
+       if (!cc->dev)
+               return; /* We don't have a ChipCommon */
+       chipco_powercontrol_init(cc);
+       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
+       calc_fast_powerup_delay(cc);
+}
+
+void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state)
+{
+       if (!cc->dev)
+               return;
+       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW);
+}
+
+void ssb_chipco_resume(struct ssb_chipcommon *cc)
+{
+       if (!cc->dev)
+               return;
+       chipco_powercontrol_init(cc);
+       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
+}
+
+/* Get the processor clock */
+void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc,
+                             u32 *plltype, u32 *n, u32 *m)
+{
+       *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N);
+       *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
+       switch (*plltype) {
+       case SSB_PLLTYPE_2:
+       case SSB_PLLTYPE_4:
+       case SSB_PLLTYPE_6:
+       case SSB_PLLTYPE_7:
+               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS);
+               break;
+       case SSB_PLLTYPE_3:
+               /* 5350 uses m2 to control mips */
+               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2);
+               break;
+       default:
+               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB);
+               break;
+       }
+}
+
+/* Get the bus clock */
+void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc,
+                                u32 *plltype, u32 *n, u32 *m)
+{
+       *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N);
+       *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
+       switch (*plltype) {
+       case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */
+               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS);
+               break;
+       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
+               if (cc->dev->bus->chip_id != 0x5365) {
+                       *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2);
+                       break;
+               }
+               /* Fallthough */
+       default:
+               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB);
+       }
+}
+
+void ssb_chipco_timing_init(struct ssb_chipcommon *cc,
+                           unsigned long ns)
+{
+       struct ssb_device *dev = cc->dev;
+       struct ssb_bus *bus = dev->bus;
+       u32 tmp;
+
+       /* set register for external IO to control LED. */
+       chipco_write32(cc, SSB_CHIPCO_PROG_CFG, 0x11);
+       tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;            /* Waitcount-3 = 10ns */
+       tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT;   /* Waitcount-1 = 40ns */
+       tmp |= DIV_ROUND_UP(240, ns);                           /* Waitcount-0 = 240ns */
+       chipco_write32(cc, SSB_CHIPCO_PROG_WAITCNT, tmp);       /* 0x01020a0c for a 100Mhz clock */
+
+       /* Set timing for the flash */
+       tmp = DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_3_SHIFT;   /* Waitcount-3 = 10nS */
+       tmp |= DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_1_SHIFT;  /* Waitcount-1 = 10nS */
+       tmp |= DIV_ROUND_UP(120, ns);                           /* Waitcount-0 = 120nS */
+       if ((bus->chip_id == 0x5365) ||
+           (dev->id.revision < 9))
+               chipco_write32(cc, SSB_CHIPCO_FLASH_WAITCNT, tmp);
+       if ((bus->chip_id == 0x5365) ||
+           (dev->id.revision < 9) ||
+           ((bus->chip_id == 0x5350) && (bus->chip_rev == 0)))
+               chipco_write32(cc, SSB_CHIPCO_PCMCIA_MEMWAIT, tmp);
+
+       if (bus->chip_id == 0x5350) {
+               /* Enable EXTIF */
+               tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;      /* Waitcount-3 = 10ns */
+               tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT;  /* Waitcount-2 = 20ns */
+               tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT; /* Waitcount-1 = 100ns */
+               tmp |= DIV_ROUND_UP(120, ns);                     /* Waitcount-0 = 120ns */
+               chipco_write32(cc, SSB_CHIPCO_PROG_WAITCNT, tmp); /* 0x01020a0c for a 100Mhz clock */
+       }
+}
+
+/* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
+void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks)
+{
+       /* instant NMI */
+       chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks);
+}
+
+u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask)
+{
+       return chipco_read32(cc, SSB_CHIPCO_GPIOIN) & mask;
+}
+
+void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value)
+{
+       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value);
+}
+
+void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value)
+{
+       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value);
+}
+
+#ifdef CONFIG_SSB_SERIAL
+int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
+                          struct ssb_serial_port *ports)
+{
+       struct ssb_bus *bus = cc->dev->bus;
+       int nr_ports = 0;
+       u32 plltype;
+       unsigned int irq;
+       u32 baud_base, div;
+       u32 i, n;
+
+       plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
+       irq = ssb_mips_irq(cc->dev);
+
+       if (plltype == SSB_PLLTYPE_1) {
+               /* PLL clock */
+               baud_base = ssb_calc_clock_rate(plltype,
+                                               chipco_read32(cc, SSB_CHIPCO_CLOCK_N),
+                                               chipco_read32(cc, SSB_CHIPCO_CLOCK_M2));
+               div = 1;
+       } else {
+               if (cc->dev->id.revision >= 11) {
+                       /* Fixed ALP clock */
+                       baud_base = 20000000;
+                       div = 1;
+                       /* Set the override bit so we don't divide it */
+                       chipco_write32(cc, SSB_CHIPCO_CORECTL,
+                                      SSB_CHIPCO_CORECTL_UARTCLK0);
+               } else if (cc->dev->id.revision >= 3) {
+                       /* Internal backplane clock */
+                       baud_base = ssb_clockspeed(bus);
+                       div = chipco_read32(cc, SSB_CHIPCO_CLKDIV)
+                             & SSB_CHIPCO_CLKDIV_UART;
+               } else {
+                       /* Fixed internal backplane clock */
+                       baud_base = 88000000;
+                       div = 48;
+               }
+
+               /* Clock source depends on strapping if UartClkOverride is unset */
+               if ((cc->dev->id.revision > 0) &&
+                   !(chipco_read32(cc, SSB_CHIPCO_CORECTL) & SSB_CHIPCO_CORECTL_UARTCLK0)) {
+                       if ((cc->capabilities & SSB_CHIPCO_CAP_UARTCLK) ==
+                           SSB_CHIPCO_CAP_UARTCLK_INT) {
+                               /* Internal divided backplane clock */
+                               baud_base /= div;
+                       } else {
+                               /* Assume external clock of 1.8432 MHz */
+                               baud_base = 1843200;
+                       }
+               }
+       }
+
+       /* Determine the registers of the UARTs */
+       n = (cc->capabilities & SSB_CHIPCO_CAP_NRUART);
+       for (i = 0; i < n; i++) {
+               void __iomem *cc_mmio;
+               void __iomem *uart_regs;
+
+               cc_mmio = cc->dev->bus->mmio + (cc->dev->core_index * SSB_CORE_SIZE);
+               uart_regs = cc_mmio + SSB_CHIPCO_UART0_DATA;
+               /* Offset changed at after rev 0 */
+               if (cc->dev->id.revision == 0)
+                       uart_regs += (i * 8);
+               else
+                       uart_regs += (i * 256);
+
+               nr_ports++;
+               ports[i].regs = uart_regs;
+               ports[i].irq = irq;
+               ports[i].baud_base = baud_base;
+               ports[i].reg_shift = 0;
+       }
+
+       return nr_ports;
+}
+#endif /* CONFIG_SSB_SERIAL */
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_extif.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_extif.c
new file mode 100644 (file)
index 0000000..fe55eb8
--- /dev/null
@@ -0,0 +1,129 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom EXTIF core driver
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
+ * Copyright 2006, 2007, Felix Fietkau <nbd@openwrt.org>
+ * Copyright 2007, Aurelien Jarno <aurelien@aurel32.net>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/serial_reg.h>
+
+#include "ssb_private.h"
+
+
+static inline u32 extif_read32(struct ssb_extif *extif, u16 offset)
+{
+       return ssb_read32(extif->dev, offset);
+}
+
+static inline void extif_write32(struct ssb_extif *extif, u16 offset, u32 value)
+{
+       ssb_write32(extif->dev, offset, value);
+}
+
+static inline void extif_write32_masked(struct ssb_extif *extif, u16 offset,
+                                       u32 mask, u32 value)
+{
+       value &= mask;
+       value |= extif_read32(extif, offset) & ~mask;
+       extif_write32(extif, offset, value);
+}
+
+#ifdef CONFIG_SSB_SERIAL
+static bool serial_exists(u8 *regs)
+{
+       u8 save_mcr, msr = 0;
+
+       if (regs) {
+               save_mcr = regs[UART_MCR];
+               regs[UART_MCR] = (UART_MCR_LOOP | UART_MCR_OUT2 | UART_MCR_RTS);
+               msr = regs[UART_MSR] & (UART_MSR_DCD | UART_MSR_RI
+                                       | UART_MSR_CTS | UART_MSR_DSR);
+               regs[UART_MCR] = save_mcr;
+       }
+       return (msr == (UART_MSR_DCD | UART_MSR_CTS));
+}
+
+int ssb_extif_serial_init(struct ssb_extif *extif, struct ssb_serial_port *ports)
+{
+       u32 i, nr_ports = 0;
+
+       /* Disable GPIO interrupt initially */
+       extif_write32(extif, SSB_EXTIF_GPIO_INTPOL, 0);
+       extif_write32(extif, SSB_EXTIF_GPIO_INTMASK, 0);
+
+       for (i = 0; i < 2; i++) {
+               void __iomem *uart_regs;
+
+               uart_regs = ioremap_nocache(SSB_EUART, 16);
+               if (uart_regs) {
+                       uart_regs += (i * 8);
+
+                       if (serial_exists(uart_regs) && ports) {
+                               extif_write32(extif, SSB_EXTIF_GPIO_INTMASK, 2);
+
+                               nr_ports++;
+                               ports[i].regs = uart_regs;
+                               ports[i].irq = 2;
+                               ports[i].baud_base = 13500000;
+                               ports[i].reg_shift = 0;
+                       }
+                       iounmap(uart_regs);
+               }
+       }
+       return nr_ports;
+}
+#endif /* CONFIG_SSB_SERIAL */
+
+void ssb_extif_timing_init(struct ssb_extif *extif, unsigned long ns)
+{
+       u32 tmp;
+
+       /* Initialize extif so we can get to the LEDs and external UART */
+       extif_write32(extif, SSB_EXTIF_PROG_CFG, SSB_EXTCFG_EN);
+
+       /* Set timing for the flash */
+       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;
+       tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT;
+       tmp |= DIV_ROUND_UP(120, ns);
+       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp);
+
+       /* Set programmable interface timing for external uart */
+       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;
+       tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT;
+       tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT;
+       tmp |= DIV_ROUND_UP(120, ns);
+       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp);
+}
+
+void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
+                               u32 *pll_type, u32 *n, u32 *m)
+{
+       *pll_type = SSB_PLLTYPE_1;
+       *n = extif_read32(extif, SSB_EXTIF_CLOCK_N);
+       *m = extif_read32(extif, SSB_EXTIF_CLOCK_SB);
+}
+
+u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask)
+{
+       return extif_read32(extif, SSB_EXTIF_GPIO_IN) & mask;
+}
+
+void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value)
+{
+       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUT(0),
+                                  mask, value);
+}
+
+void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value)
+{
+       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUTEN(0),
+                                  mask, value);
+}
+
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_mipscore.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_mipscore.c
new file mode 100644 (file)
index 0000000..a9e7eb4
--- /dev/null
@@ -0,0 +1,225 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom MIPS core driver
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+
+#include <linux/serial.h>
+#include <linux/serial_core.h>
+#include <linux/serial_reg.h>
+#include <linux/time.h>
+
+#include "ssb_private.h"
+
+
+static inline u32 mips_read32(struct ssb_mipscore *mcore,
+                             u16 offset)
+{
+       return ssb_read32(mcore->dev, offset);
+}
+
+static inline void mips_write32(struct ssb_mipscore *mcore,
+                               u16 offset,
+                               u32 value)
+{
+       ssb_write32(mcore->dev, offset, value);
+}
+
+static const u32 ipsflag_irq_mask[] = {
+       0,
+       SSB_IPSFLAG_IRQ1,
+       SSB_IPSFLAG_IRQ2,
+       SSB_IPSFLAG_IRQ3,
+       SSB_IPSFLAG_IRQ4,
+};
+
+static const u32 ipsflag_irq_shift[] = {
+       0,
+       SSB_IPSFLAG_IRQ1_SHIFT,
+       SSB_IPSFLAG_IRQ2_SHIFT,
+       SSB_IPSFLAG_IRQ3_SHIFT,
+       SSB_IPSFLAG_IRQ4_SHIFT,
+};
+
+static inline u32 ssb_irqflag(struct ssb_device *dev)
+{
+       return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG;
+}
+
+/* Get the MIPS IRQ assignment for a specified device.
+ * If unassigned, 0 is returned.
+ */
+unsigned int ssb_mips_irq(struct ssb_device *dev)
+{
+       struct ssb_bus *bus = dev->bus;
+       u32 irqflag;
+       u32 ipsflag;
+       u32 tmp;
+       unsigned int irq;
+
+       irqflag = ssb_irqflag(dev);
+       ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG);
+       for (irq = 1; irq <= 4; irq++) {
+               tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]);
+               if (tmp == irqflag)
+                       break;
+       }
+       if (irq == 5)
+               irq = 0;
+
+       return irq;
+}
+
+static void clear_irq(struct ssb_bus *bus, unsigned int irq)
+{
+       struct ssb_device *dev = bus->mipscore.dev;
+
+       /* Clear the IRQ in the MIPScore backplane registers */
+       if (irq == 0) {
+               ssb_write32(dev, SSB_INTVEC, 0);
+       } else {
+               ssb_write32(dev, SSB_IPSFLAG,
+                           ssb_read32(dev, SSB_IPSFLAG) |
+                           ipsflag_irq_mask[irq]);
+       }
+}
+
+static void set_irq(struct ssb_device *dev, unsigned int irq)
+{
+       unsigned int oldirq = ssb_mips_irq(dev);
+       struct ssb_bus *bus = dev->bus;
+       struct ssb_device *mdev = bus->mipscore.dev;
+       u32 irqflag = ssb_irqflag(dev);
+
+       dev->irq = irq + 2;
+
+       ssb_dprintk(KERN_INFO PFX
+                   "set_irq: core 0x%04x, irq %d => %d\n",
+                   dev->id.coreid, oldirq, irq);
+       /* clear the old irq */
+       if (oldirq == 0)
+               ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)));
+       else
+               clear_irq(bus, oldirq);
+
+       /* assign the new one */
+       if (irq == 0) {
+               ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC)));
+       } else {
+               irqflag <<= ipsflag_irq_shift[irq];
+               irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]);
+               ssb_write32(mdev, SSB_IPSFLAG, irqflag);
+       }
+}
+
+static void ssb_mips_serial_init(struct ssb_mipscore *mcore)
+{
+       struct ssb_bus *bus = mcore->dev->bus;
+
+       if (bus->extif.dev)
+               mcore->nr_serial_ports = ssb_extif_serial_init(&bus->extif, mcore->serial_ports);
+       else if (bus->chipco.dev)
+               mcore->nr_serial_ports = ssb_chipco_serial_init(&bus->chipco, mcore->serial_ports);
+       else
+               mcore->nr_serial_ports = 0;
+}
+
+static void ssb_mips_flash_detect(struct ssb_mipscore *mcore)
+{
+       struct ssb_bus *bus = mcore->dev->bus;
+
+       mcore->flash_buswidth = 2;
+       if (bus->chipco.dev) {
+               mcore->flash_window = 0x1c000000;
+               mcore->flash_window_size = 0x02000000;
+               if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG)
+                              & SSB_CHIPCO_CFG_DS16) == 0)
+                       mcore->flash_buswidth = 1;
+       } else {
+               mcore->flash_window = 0x1fc00000;
+               mcore->flash_window_size = 0x00400000;
+       }
+}
+
+u32 ssb_cpu_clock(struct ssb_mipscore *mcore)
+{
+       struct ssb_bus *bus = mcore->dev->bus;
+       u32 pll_type, n, m, rate = 0;
+
+       if (bus->extif.dev) {
+               ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m);
+       } else if (bus->chipco.dev) {
+               ssb_chipco_get_clockcpu(&bus->chipco, &pll_type, &n, &m);
+       } else
+               return 0;
+
+       if ((pll_type == SSB_PLLTYPE_5) || (bus->chip_id == 0x5365)) {
+               rate = 200000000;
+       } else {
+               rate = ssb_calc_clock_rate(pll_type, n, m);
+       }
+
+       if (pll_type == SSB_PLLTYPE_6) {
+               rate *= 2;
+       }
+
+       return rate;
+}
+
+void ssb_mipscore_init(struct ssb_mipscore *mcore)
+{
+       struct ssb_bus *bus;
+       struct ssb_device *dev;
+       unsigned long hz, ns;
+       unsigned int irq, i;
+
+       if (!mcore->dev)
+               return; /* We don't have a MIPS core */
+
+       ssb_dprintk(KERN_INFO PFX "Initializing MIPS core...\n");
+
+       bus = mcore->dev->bus;
+       hz = ssb_clockspeed(bus);
+       if (!hz)
+               hz = 100000000;
+       ns = 1000000000 / hz;
+
+       if (bus->extif.dev)
+               ssb_extif_timing_init(&bus->extif, ns);
+       else if (bus->chipco.dev)
+               ssb_chipco_timing_init(&bus->chipco, ns);
+
+       /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */
+       for (irq = 2, i = 0; i < bus->nr_devices; i++) {
+               dev = &(bus->devices[i]);
+               dev->irq = ssb_mips_irq(dev) + 2;
+               switch (dev->id.coreid) {
+               case SSB_DEV_USB11_HOST:
+                       /* shouldn't need a separate irq line for non-4710, most of them have a proper
+                        * external usb controller on the pci */
+                       if ((bus->chip_id == 0x4710) && (irq <= 4)) {
+                               set_irq(dev, irq++);
+                               break;
+                       }
+                       /* fallthrough */
+               case SSB_DEV_PCI:
+               case SSB_DEV_ETHERNET:
+               case SSB_DEV_80211:
+               case SSB_DEV_USB20_HOST:
+                       /* These devices get their own IRQ line if available, the rest goes on IRQ0 */
+                       if (irq <= 4) {
+                               set_irq(dev, irq++);
+                               break;
+                       }
+               }
+       }
+
+       ssb_mips_serial_init(mcore);
+       ssb_mips_flash_detect(mcore);
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_pcicore.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/driver_pcicore.c
new file mode 100644 (file)
index 0000000..2faaa90
--- /dev/null
@@ -0,0 +1,576 @@
+/*
+ * Sonics Silicon Backplane
+ * Broadcom PCI-core driver
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+
+#include "ssb_private.h"
+
+
+static inline
+u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset)
+{
+       return ssb_read32(pc->dev, offset);
+}
+
+static inline
+void pcicore_write32(struct ssb_pcicore *pc, u16 offset, u32 value)
+{
+       ssb_write32(pc->dev, offset, value);
+}
+
+/**************************************************
+ * Code for hostmode operation.
+ **************************************************/
+
+#ifdef CONFIG_SSB_PCICORE_HOSTMODE
+
+#include <asm/paccess.h>
+/* Probe a 32bit value on the bus and catch bus exceptions.
+ * Returns nonzero on a bus exception.
+ * This is MIPS specific */
+#define mips_busprobe32(val, addr)     get_dbe((val), ((u32 *)(addr)))
+
+/* Assume one-hot slot wiring */
+#define SSB_PCI_SLOT_MAX       16
+
+/* Global lock is OK, as we won't have more than one extpci anyway. */
+static DEFINE_SPINLOCK(cfgspace_lock);
+/* Core to access the external PCI config space. Can only have one. */
+static struct ssb_pcicore *extpci_core;
+
+static u32 ssb_pcicore_pcibus_iobase = 0x100;
+static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA;
+
+int pcibios_plat_dev_init(struct pci_dev *d)
+{
+       struct resource *res;
+       int pos, size;
+       u32 *base;
+
+       ssb_printk(KERN_INFO "PCI: Fixing up device %s\n",
+                  pci_name(d));
+
+       /* Fix up resource bases */
+       for (pos = 0; pos < 6; pos++) {
+               res = &d->resource[pos];
+               if (res->flags & IORESOURCE_IO)
+                       base = &ssb_pcicore_pcibus_iobase;
+               else
+                       base = &ssb_pcicore_pcibus_membase;
+               if (res->end) {
+                       size = res->end - res->start + 1;
+                       if (*base & (size - 1))
+                               *base = (*base + size) & ~(size - 1);
+                       res->start = *base;
+                       res->end = res->start + size - 1;
+                       *base += size;
+                       pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start);
+               }
+               /* Fix up PCI bridge BAR0 only */
+               if (d->bus->number == 0 && PCI_SLOT(d->devfn) == 0)
+                       break;
+       }
+       /* Fix up interrupt lines */
+       d->irq = ssb_mips_irq(extpci_core->dev) + 2;
+       pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq);
+
+       return 0;
+}
+
+static void __init ssb_fixup_pcibridge(struct pci_dev *dev)
+{
+       if (dev->bus->number != 0 || PCI_SLOT(dev->devfn) != 0)
+               return;
+
+       ssb_printk(KERN_INFO "PCI: fixing up bridge\n");
+
+       /* Enable PCI bridge bus mastering and memory space */
+       pci_set_master(dev);
+       pcibios_enable_device(dev, ~0);
+
+       /* Enable PCI bridge BAR1 prefetch and burst */
+       pci_write_config_dword(dev, SSB_BAR1_CONTROL, 3);
+
+       /* Make sure our latency is high enough to handle the devices behind us */
+       pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xa8);
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, ssb_fixup_pcibridge);
+
+int __init pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
+{
+       return ssb_mips_irq(extpci_core->dev) + 2;
+}
+
+static u32 get_cfgspace_addr(struct ssb_pcicore *pc,
+                            unsigned int bus, unsigned int dev,
+                            unsigned int func, unsigned int off)
+{
+       u32 addr = 0;
+       u32 tmp;
+
+       if (unlikely(pc->cardbusmode && dev > 1))
+               goto out;
+       if (bus == 0) {
+               /* Type 0 transaction */
+               if (unlikely(dev >= SSB_PCI_SLOT_MAX))
+                       goto out;
+               /* Slide the window */
+               tmp = SSB_PCICORE_SBTOPCI_CFG0;
+               tmp |= ((1 << (dev + 16)) & SSB_PCICORE_SBTOPCI1_MASK);
+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI1, tmp);
+               /* Calculate the address */
+               addr = SSB_PCI_CFG;
+               addr |= ((1 << (dev + 16)) & ~SSB_PCICORE_SBTOPCI1_MASK);
+               addr |= (func << 8);
+               addr |= (off & ~3);
+       } else {
+               /* Type 1 transaction */
+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI1,
+                               SSB_PCICORE_SBTOPCI_CFG1);
+               /* Calculate the address */
+               addr = SSB_PCI_CFG;
+               addr |= (bus << 16);
+               addr |= (dev << 11);
+               addr |= (func << 8);
+               addr |= (off & ~3);
+       }
+out:
+       return addr;
+}
+
+static int ssb_extpci_read_config(struct ssb_pcicore *pc,
+                                 unsigned int bus, unsigned int dev,
+                                 unsigned int func, unsigned int off,
+                                 void *buf, int len)
+{
+       int err = -EINVAL;
+       u32 addr, val;
+       void __iomem *mmio;
+
+       SSB_WARN_ON(!pc->hostmode);
+       if (unlikely(len != 1 && len != 2 && len != 4))
+               goto out;
+       addr = get_cfgspace_addr(pc, bus, dev, func, off);
+       if (unlikely(!addr))
+               goto out;
+       err = -ENOMEM;
+       mmio = ioremap_nocache(addr, len);
+       if (!mmio)
+               goto out;
+
+       if (mips_busprobe32(val, mmio)) {
+               val = 0xffffffff;
+               goto unmap;
+       }
+
+       val = readl(mmio);
+       val >>= (8 * (off & 3));
+
+       switch (len) {
+       case 1:
+               *((u8 *)buf) = (u8)val;
+               break;
+       case 2:
+               *((u16 *)buf) = (u16)val;
+               break;
+       case 4:
+               *((u32 *)buf) = (u32)val;
+               break;
+       }
+       err = 0;
+unmap:
+       iounmap(mmio);
+out:
+       return err;
+}
+
+static int ssb_extpci_write_config(struct ssb_pcicore *pc,
+                                  unsigned int bus, unsigned int dev,
+                                  unsigned int func, unsigned int off,
+                                  const void *buf, int len)
+{
+       int err = -EINVAL;
+       u32 addr, val = 0;
+       void __iomem *mmio;
+
+       SSB_WARN_ON(!pc->hostmode);
+       if (unlikely(len != 1 && len != 2 && len != 4))
+               goto out;
+       addr = get_cfgspace_addr(pc, bus, dev, func, off);
+       if (unlikely(!addr))
+               goto out;
+       err = -ENOMEM;
+       mmio = ioremap_nocache(addr, len);
+       if (!mmio)
+               goto out;
+
+       if (mips_busprobe32(val, mmio)) {
+               val = 0xffffffff;
+               goto unmap;
+       }
+
+       switch (len) {
+       case 1:
+               val = readl(mmio);
+               val &= ~(0xFF << (8 * (off & 3)));
+               val |= *((const u8 *)buf) << (8 * (off & 3));
+               break;
+       case 2:
+               val = readl(mmio);
+               val &= ~(0xFFFF << (8 * (off & 3)));
+               val |= *((const u16 *)buf) << (8 * (off & 3));
+               break;
+       case 4:
+               val = *((const u32 *)buf);
+               break;
+       }
+       writel(val, mmio);
+
+       err = 0;
+unmap:
+       iounmap(mmio);
+out:
+       return err;
+}
+
+static int ssb_pcicore_read_config(struct pci_bus *bus, unsigned int devfn,
+                                  int reg, int size, u32 *val)
+{
+       unsigned long flags;
+       int err;
+
+       spin_lock_irqsave(&cfgspace_lock, flags);
+       err = ssb_extpci_read_config(extpci_core, bus->number, PCI_SLOT(devfn),
+                                    PCI_FUNC(devfn), reg, val, size);
+       spin_unlock_irqrestore(&cfgspace_lock, flags);
+
+       return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
+}
+
+static int ssb_pcicore_write_config(struct pci_bus *bus, unsigned int devfn,
+                                   int reg, int size, u32 val)
+{
+       unsigned long flags;
+       int err;
+
+       spin_lock_irqsave(&cfgspace_lock, flags);
+       err = ssb_extpci_write_config(extpci_core, bus->number, PCI_SLOT(devfn),
+                                     PCI_FUNC(devfn), reg, &val, size);
+       spin_unlock_irqrestore(&cfgspace_lock, flags);
+
+       return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
+}
+
+static struct pci_ops ssb_pcicore_pciops = {
+       .read   = ssb_pcicore_read_config,
+       .write  = ssb_pcicore_write_config,
+};
+
+static struct resource ssb_pcicore_mem_resource = {
+       .name   = "SSB PCIcore external memory",
+       .start  = SSB_PCI_DMA,
+       .end    = SSB_PCI_DMA + SSB_PCI_DMA_SZ - 1,
+       .flags  = IORESOURCE_MEM,
+};
+
+static struct resource ssb_pcicore_io_resource = {
+       .name   = "SSB PCIcore external I/O",
+       .start  = 0x100,
+       .end    = 0x7FF,
+       .flags  = IORESOURCE_IO,
+};
+
+static struct pci_controller ssb_pcicore_controller = {
+       .pci_ops        = &ssb_pcicore_pciops,
+       .io_resource    = &ssb_pcicore_io_resource,
+       .mem_resource   = &ssb_pcicore_mem_resource,
+       .mem_offset     = 0x24000000,
+};
+
+static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc)
+{
+       u32 val;
+
+       if (WARN_ON(extpci_core))
+               return;
+       extpci_core = pc;
+
+       ssb_dprintk(KERN_INFO PFX "PCIcore in host mode found\n");
+       /* Reset devices on the external PCI bus */
+       val = SSB_PCICORE_CTL_RST_OE;
+       val |= SSB_PCICORE_CTL_CLK_OE;
+       pcicore_write32(pc, SSB_PCICORE_CTL, val);
+       val |= SSB_PCICORE_CTL_CLK; /* Clock on */
+       pcicore_write32(pc, SSB_PCICORE_CTL, val);
+       udelay(150); /* Assertion time demanded by the PCI standard */
+       val |= SSB_PCICORE_CTL_RST; /* Deassert RST# */
+       pcicore_write32(pc, SSB_PCICORE_CTL, val);
+       val = SSB_PCICORE_ARBCTL_INTERN;
+       pcicore_write32(pc, SSB_PCICORE_ARBCTL, val);
+       udelay(1); /* Assertion time demanded by the PCI standard */
+
+       /*TODO cardbus mode */
+
+       /* 64MB I/O window */
+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI0,
+                       SSB_PCICORE_SBTOPCI_IO);
+       /* 64MB config space */
+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI1,
+                       SSB_PCICORE_SBTOPCI_CFG0);
+       /* 1GB memory window */
+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2,
+                       SSB_PCICORE_SBTOPCI_MEM | SSB_PCI_DMA);
+
+       /* Enable PCI bridge BAR0 prefetch and burst */
+       val = PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
+       ssb_extpci_write_config(pc, 0, 0, 0, PCI_COMMAND, &val, 2);
+       /* Clear error conditions */
+       val = 0;
+       ssb_extpci_write_config(pc, 0, 0, 0, PCI_STATUS, &val, 2);
+
+       /* Enable PCI interrupts */
+       pcicore_write32(pc, SSB_PCICORE_IMASK,
+                       SSB_PCICORE_IMASK_INTA);
+
+       /* Ok, ready to run, register it to the system.
+        * The following needs change, if we want to port hostmode
+        * to non-MIPS platform. */
+       set_io_port_base((unsigned long)ioremap_nocache(SSB_PCI_MEM, 0x04000000));
+       /* Give some time to the PCI controller to configure itself with the new
+        * values. Not waiting at this point causes crashes of the machine. */
+       mdelay(10);
+       register_pci_controller(&ssb_pcicore_controller);
+}
+
+static int pcicore_is_in_hostmode(struct ssb_pcicore *pc)
+{
+       struct ssb_bus *bus = pc->dev->bus;
+       u16 chipid_top;
+       u32 tmp;
+
+       chipid_top = (bus->chip_id & 0xFF00);
+       if (chipid_top != 0x4700 &&
+           chipid_top != 0x5300)
+               return 0;
+
+       if (bus->sprom.r1.boardflags_lo & SSB_PCICORE_BFL_NOPCI)
+               return 0;
+
+       /* The 200-pin BCM4712 package does not bond out PCI. Even when
+        * PCI is bonded out, some boards may leave the pins floating. */
+       if (bus->chip_id == 0x4712) {
+               if (bus->chip_package == SSB_CHIPPACK_BCM4712S)
+                       return 0;
+               if (bus->chip_package == SSB_CHIPPACK_BCM4712M)
+                       return 0;
+       }
+       if (bus->chip_id == 0x5350)
+               return 0;
+
+       return !mips_busprobe32(tmp, (bus->mmio + (pc->dev->core_index * SSB_CORE_SIZE)));
+}
+#endif /* CONFIG_SSB_PCICORE_HOSTMODE */
+
+
+/**************************************************
+ * Generic and Clientmode operation code.
+ **************************************************/
+
+static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc)
+{
+       /* Disable PCI interrupts. */
+       ssb_write32(pc->dev, SSB_INTVEC, 0);
+}
+
+void ssb_pcicore_init(struct ssb_pcicore *pc)
+{
+       struct ssb_device *dev = pc->dev;
+       struct ssb_bus *bus;
+
+       if (!dev)
+               return;
+       bus = dev->bus;
+       if (!ssb_device_is_enabled(dev))
+               ssb_device_enable(dev, 0);
+
+#ifdef CONFIG_SSB_PCICORE_HOSTMODE
+       pc->hostmode = pcicore_is_in_hostmode(pc);
+       if (pc->hostmode)
+               ssb_pcicore_init_hostmode(pc);
+#endif /* CONFIG_SSB_PCICORE_HOSTMODE */
+       if (!pc->hostmode)
+               ssb_pcicore_init_clientmode(pc);
+}
+
+static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address)
+{
+       pcicore_write32(pc, 0x130, address);
+       return pcicore_read32(pc, 0x134);
+}
+
+static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data)
+{
+       pcicore_write32(pc, 0x130, address);
+       pcicore_write32(pc, 0x134, data);
+}
+
+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device,
+                               u8 address, u16 data)
+{
+       const u16 mdio_control = 0x128;
+       const u16 mdio_data = 0x12C;
+       u32 v;
+       int i;
+
+       v = 0x80; /* Enable Preamble Sequence */
+       v |= 0x2; /* MDIO Clock Divisor */
+       pcicore_write32(pc, mdio_control, v);
+
+       v = (1 << 30); /* Start of Transaction */
+       v |= (1 << 28); /* Write Transaction */
+       v |= (1 << 17); /* Turnaround */
+       v |= (u32)device << 22;
+       v |= (u32)address << 18;
+       v |= data;
+       pcicore_write32(pc, mdio_data, v);
+       /* Wait for the device to complete the transaction */
+       udelay(10);
+       for (i = 0; i < 10; i++) {
+               v = pcicore_read32(pc, mdio_control);
+               if (v & 0x100 /* Trans complete */)
+                       break;
+               msleep(1);
+       }
+       pcicore_write32(pc, mdio_control, 0);
+}
+
+static void ssb_broadcast_value(struct ssb_device *dev,
+                               u32 address, u32 data)
+{
+       /* This is used for both, PCI and ChipCommon core, so be careful. */
+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR);
+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA);
+
+       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address);
+       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */
+       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data);
+       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */
+}
+
+static void ssb_commit_settings(struct ssb_bus *bus)
+{
+       struct ssb_device *dev;
+
+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev;
+       if (WARN_ON(!dev))
+               return;
+       /* This forces an update of the cached registers. */
+       ssb_broadcast_value(dev, 0xFD8, 0);
+}
+
+int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
+                                  struct ssb_device *dev)
+{
+       struct ssb_device *pdev = pc->dev;
+       struct ssb_bus *bus;
+       int err = 0;
+       u32 tmp;
+
+       might_sleep();
+
+       if (!pdev)
+               goto out;
+       bus = pdev->bus;
+
+       /* Enable interrupts for this device. */
+       if (bus->host_pci &&
+           ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) {
+               u32 coremask;
+
+               /* Calculate the "coremask" for the device. */
+               coremask = (1 << dev->core_index);
+
+               err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp);
+               if (err)
+                       goto out;
+               tmp |= coremask << 8;
+               err = pci_write_config_dword(bus->host_pci, SSB_PCI_IRQMASK, tmp);
+               if (err)
+                       goto out;
+       } else {
+               u32 intvec;
+
+               intvec = ssb_read32(pdev, SSB_INTVEC);
+               if ((bus->chip_id & 0xFF00) == 0x4400) {
+                       /* Workaround: On the BCM44XX the BPFLAG routing
+                        * bit is wrong. Use a hardcoded constant. */
+                       intvec |= 0x00000002;
+               } else {
+                       tmp = ssb_read32(dev, SSB_TPSFLAG);
+                       tmp &= SSB_TPSFLAG_BPFLAG;
+                       intvec |= tmp;
+               }
+               ssb_write32(pdev, SSB_INTVEC, intvec);
+       }
+
+       /* Setup PCIcore operation. */
+       if (pc->setup_done)
+               goto out;
+       if (pdev->id.coreid == SSB_DEV_PCI) {
+               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
+               tmp |= SSB_PCICORE_SBTOPCI_PREF;
+               tmp |= SSB_PCICORE_SBTOPCI_BURST;
+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
+
+               if (pdev->id.revision < 5) {
+                       tmp = ssb_read32(pdev, SSB_IMCFGLO);
+                       tmp &= ~SSB_IMCFGLO_SERTO;
+                       tmp |= 2;
+                       tmp &= ~SSB_IMCFGLO_REQTO;
+                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT;
+                       ssb_write32(pdev, SSB_IMCFGLO, tmp);
+                       ssb_commit_settings(bus);
+               } else if (pdev->id.revision >= 11) {
+                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
+                       tmp |= SSB_PCICORE_SBTOPCI_MRM;
+                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
+               }
+       } else {
+               WARN_ON(pdev->id.coreid != SSB_DEV_PCIE);
+               //TODO: Better make defines for all these magic PCIE values.
+               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) {
+                       /* TLP Workaround register. */
+                       tmp = ssb_pcie_read(pc, 0x4);
+                       tmp |= 0x8;
+                       ssb_pcie_write(pc, 0x4, tmp);
+               }
+               if (pdev->id.revision == 0) {
+                       const u8 serdes_rx_device = 0x1F;
+
+                       ssb_pcie_mdio_write(pc, serdes_rx_device,
+                                           2 /* Timer */, 0x8128);
+                       ssb_pcie_mdio_write(pc, serdes_rx_device,
+                                           6 /* CDR */, 0x0100);
+                       ssb_pcie_mdio_write(pc, serdes_rx_device,
+                                           7 /* CDR BW */, 0x1466);
+               } else if (pdev->id.revision == 1) {
+                       /* DLLP Link Control register. */
+                       tmp = ssb_pcie_read(pc, 0x100);
+                       tmp |= 0x40;
+                       ssb_pcie_write(pc, 0x100, tmp);
+               }
+       }
+       pc->setup_done = 1;
+out:
+       return err;
+}
+EXPORT_SYMBOL(ssb_pcicore_dev_irqvecs_enable);
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/main.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/main.c
new file mode 100644 (file)
index 0000000..9028ed5
--- /dev/null
@@ -0,0 +1,1169 @@
+/*
+ * Sonics Silicon Backplane
+ * Subsystem core
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include "ssb_private.h"
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/ssb/ssb.h>
+#include <linux/ssb/ssb_regs.h>
+#include <linux/dma-mapping.h>
+#include <linux/pci.h>
+
+#include <pcmcia/cs_types.h>
+#include <pcmcia/cs.h>
+#include <pcmcia/cistpl.h>
+#include <pcmcia/ds.h>
+
+
+MODULE_DESCRIPTION("Sonics Silicon Backplane driver");
+MODULE_LICENSE("GPL");
+
+
+/* Temporary list of yet-to-be-attached buses */
+static LIST_HEAD(attach_queue);
+/* List if running buses */
+static LIST_HEAD(buses);
+/* Software ID counter */
+static unsigned int next_busnumber;
+/* buses_mutes locks the two buslists and the next_busnumber.
+ * Don't lock this directly, but use ssb_buses_[un]lock() below. */
+static DEFINE_MUTEX(buses_mutex);
+
+/* There are differences in the codeflow, if the bus is
+ * initialized from early boot, as various needed services
+ * are not available early. This is a mechanism to delay
+ * these initializations to after early boot has finished.
+ * It's also used to avoid mutex locking, as that's not
+ * available and needed early. */
+static bool ssb_is_early_boot = 1;
+
+static void ssb_buses_lock(void);
+static void ssb_buses_unlock(void);
+
+
+#ifdef CONFIG_SSB_PCIHOST
+struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev)
+{
+       struct ssb_bus *bus;
+
+       ssb_buses_lock();
+       list_for_each_entry(bus, &buses, list) {
+               if (bus->bustype == SSB_BUSTYPE_PCI &&
+                   bus->host_pci == pdev)
+                       goto found;
+       }
+       bus = NULL;
+found:
+       ssb_buses_unlock();
+
+       return bus;
+}
+#endif /* CONFIG_SSB_PCIHOST */
+
+static struct ssb_device *ssb_device_get(struct ssb_device *dev)
+{
+       if (dev)
+               get_device(dev->dev);
+       return dev;
+}
+
+static void ssb_device_put(struct ssb_device *dev)
+{
+       if (dev)
+               put_device(dev->dev);
+}
+
+static int ssb_bus_resume(struct ssb_bus *bus)
+{
+       int err;
+
+       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
+       err = ssb_pcmcia_init(bus);
+       if (err) {
+               /* No need to disable XTAL, as we don't have one on PCMCIA. */
+               return err;
+       }
+       ssb_chipco_resume(&bus->chipco);
+
+       return 0;
+}
+
+static int ssb_device_resume(struct device *dev)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv;
+       struct ssb_bus *bus;
+       int err = 0;
+
+       bus = ssb_dev->bus;
+       if (bus->suspend_cnt == bus->nr_devices) {
+               err = ssb_bus_resume(bus);
+               if (err)
+                       return err;
+       }
+       bus->suspend_cnt--;
+       if (dev->driver) {
+               ssb_drv = drv_to_ssb_drv(dev->driver);
+               if (ssb_drv && ssb_drv->resume)
+                       err = ssb_drv->resume(ssb_dev);
+               if (err)
+                       goto out;
+       }
+out:
+       return err;
+}
+
+static void ssb_bus_suspend(struct ssb_bus *bus, pm_message_t state)
+{
+       ssb_chipco_suspend(&bus->chipco, state);
+       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
+
+       /* Reset HW state information in memory, so that HW is
+        * completely reinitialized on resume. */
+       bus->mapped_device = NULL;
+#ifdef CONFIG_SSB_DRIVER_PCICORE
+       bus->pcicore.setup_done = 0;
+#endif
+#ifdef CONFIG_SSB_DEBUG
+       bus->powered_up = 0;
+#endif
+}
+
+static int ssb_device_suspend(struct device *dev, pm_message_t state)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv;
+       struct ssb_bus *bus;
+       int err = 0;
+
+       if (dev->driver) {
+               ssb_drv = drv_to_ssb_drv(dev->driver);
+               if (ssb_drv && ssb_drv->suspend)
+                       err = ssb_drv->suspend(ssb_dev, state);
+               if (err)
+                       goto out;
+       }
+
+       bus = ssb_dev->bus;
+       bus->suspend_cnt++;
+       if (bus->suspend_cnt == bus->nr_devices) {
+               /* All devices suspended. Shutdown the bus. */
+               ssb_bus_suspend(bus, state);
+       }
+
+out:
+       return err;
+}
+
+#ifdef CONFIG_SSB_PCIHOST
+int ssb_devices_freeze(struct ssb_bus *bus)
+{
+       struct ssb_device *dev;
+       struct ssb_driver *drv;
+       int err = 0;
+       int i;
+       pm_message_t state = PMSG_FREEZE;
+
+       /* First check that we are capable to freeze all devices. */
+       for (i = 0; i < bus->nr_devices; i++) {
+               dev = &(bus->devices[i]);
+               if (!dev->dev ||
+                   !dev->dev->driver ||
+                   !device_is_registered(dev->dev))
+                       continue;
+               drv = drv_to_ssb_drv(dev->dev->driver);
+               if (!drv)
+                       continue;
+               if (!drv->suspend) {
+                       /* Nope, can't suspend this one. */
+                       return -EOPNOTSUPP;
+               }
+       }
+       /* Now suspend all devices */
+       for (i = 0; i < bus->nr_devices; i++) {
+               dev = &(bus->devices[i]);
+               if (!dev->dev ||
+                   !dev->dev->driver ||
+                   !device_is_registered(dev->dev))
+                       continue;
+               drv = drv_to_ssb_drv(dev->dev->driver);
+               if (!drv)
+                       continue;
+               err = drv->suspend(dev, state);
+               if (err) {
+                       ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n",
+                                  dev->dev->bus_id);
+                       goto err_unwind;
+               }
+       }
+
+       return 0;
+err_unwind:
+       for (i--; i >= 0; i--) {
+               dev = &(bus->devices[i]);
+               if (!dev->dev ||
+                   !dev->dev->driver ||
+                   !device_is_registered(dev->dev))
+                       continue;
+               drv = drv_to_ssb_drv(dev->dev->driver);
+               if (!drv)
+                       continue;
+               if (drv->resume)
+                       drv->resume(dev);
+       }
+       return err;
+}
+
+int ssb_devices_thaw(struct ssb_bus *bus)
+{
+       struct ssb_device *dev;
+       struct ssb_driver *drv;
+       int err;
+       int i;
+
+       for (i = 0; i < bus->nr_devices; i++) {
+               dev = &(bus->devices[i]);
+               if (!dev->dev ||
+                   !dev->dev->driver ||
+                   !device_is_registered(dev->dev))
+                       continue;
+               drv = drv_to_ssb_drv(dev->dev->driver);
+               if (!drv)
+                       continue;
+               if (SSB_WARN_ON(!drv->resume))
+                       continue;
+               err = drv->resume(dev);
+               if (err) {
+                       ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n",
+                                  dev->dev->bus_id);
+               }
+       }
+
+       return 0;
+}
+#endif /* CONFIG_SSB_PCIHOST */
+
+static void ssb_device_shutdown(struct device *dev)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv;
+
+       if (!dev->driver)
+               return;
+       ssb_drv = drv_to_ssb_drv(dev->driver);
+       if (ssb_drv && ssb_drv->shutdown)
+               ssb_drv->shutdown(ssb_dev);
+}
+
+static int ssb_device_remove(struct device *dev)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv = drv_to_ssb_drv(dev->driver);
+
+       if (ssb_drv && ssb_drv->remove)
+               ssb_drv->remove(ssb_dev);
+       ssb_device_put(ssb_dev);
+
+       return 0;
+}
+
+static int ssb_device_probe(struct device *dev)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv = drv_to_ssb_drv(dev->driver);
+       int err = 0;
+
+       ssb_device_get(ssb_dev);
+       if (ssb_drv && ssb_drv->probe)
+               err = ssb_drv->probe(ssb_dev, &ssb_dev->id);
+       if (err)
+               ssb_device_put(ssb_dev);
+
+       return err;
+}
+
+static int ssb_match_devid(const struct ssb_device_id *tabid,
+                          const struct ssb_device_id *devid)
+{
+       if ((tabid->vendor != devid->vendor) &&
+           tabid->vendor != SSB_ANY_VENDOR)
+               return 0;
+       if ((tabid->coreid != devid->coreid) &&
+           tabid->coreid != SSB_ANY_ID)
+               return 0;
+       if ((tabid->revision != devid->revision) &&
+           tabid->revision != SSB_ANY_REV)
+               return 0;
+       return 1;
+}
+
+static int ssb_bus_match(struct device *dev, struct device_driver *drv)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+       struct ssb_driver *ssb_drv = drv_to_ssb_drv(drv);
+       const struct ssb_device_id *id;
+
+       for (id = ssb_drv->id_table;
+            id->vendor || id->coreid || id->revision;
+            id++) {
+               if (ssb_match_devid(id, &ssb_dev->id))
+                       return 1; /* found */
+       }
+
+       return 0;
+}
+
+static int ssb_device_uevent(struct device *dev, struct kobj_uevent_env *env)
+{
+       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
+
+       if (!dev)
+               return -ENODEV;
+
+       return add_uevent_var(env,
+                            "MODALIAS=ssb:v%04Xid%04Xrev%02X",
+                            ssb_dev->id.vendor, ssb_dev->id.coreid,
+                            ssb_dev->id.revision);
+}
+
+static struct bus_type ssb_bustype = {
+       .name           = "ssb",
+       .match          = ssb_bus_match,
+       .probe          = ssb_device_probe,
+       .remove         = ssb_device_remove,
+       .shutdown       = ssb_device_shutdown,
+       .suspend        = ssb_device_suspend,
+       .resume         = ssb_device_resume,
+       .uevent         = ssb_device_uevent,
+};
+
+static void ssb_buses_lock(void)
+{
+       /* See the comment at the ssb_is_early_boot definition */
+       if (!ssb_is_early_boot)
+               mutex_lock(&buses_mutex);
+}
+
+static void ssb_buses_unlock(void)
+{
+       /* See the comment at the ssb_is_early_boot definition */
+       if (!ssb_is_early_boot)
+               mutex_unlock(&buses_mutex);
+}
+
+static void ssb_devices_unregister(struct ssb_bus *bus)
+{
+       struct ssb_device *sdev;
+       int i;
+
+       for (i = bus->nr_devices - 1; i >= 0; i--) {
+               sdev = &(bus->devices[i]);
+               if (sdev->dev)
+                       device_unregister(sdev->dev);
+       }
+}
+
+void ssb_bus_unregister(struct ssb_bus *bus)
+{
+       ssb_buses_lock();
+       ssb_devices_unregister(bus);
+       list_del(&bus->list);
+       ssb_buses_unlock();
+
+       /* ssb_pcmcia_exit(bus); */
+       ssb_pci_exit(bus);
+       ssb_iounmap(bus);
+}
+EXPORT_SYMBOL(ssb_bus_unregister);
+
+static void ssb_release_dev(struct device *dev)
+{
+       struct __ssb_dev_wrapper *devwrap;
+
+       devwrap = container_of(dev, struct __ssb_dev_wrapper, dev);
+       kfree(devwrap);
+}
+
+static int ssb_devices_register(struct ssb_bus *bus)
+{
+       struct ssb_device *sdev;
+       struct device *dev;
+       struct __ssb_dev_wrapper *devwrap;
+       int i, err = 0;
+       int dev_idx = 0;
+
+       for (i = 0; i < bus->nr_devices; i++) {
+               sdev = &(bus->devices[i]);
+
+               /* We don't register SSB-system devices to the kernel,
+                * as the drivers for them are built into SSB. */
+               switch (sdev->id.coreid) {
+               case SSB_DEV_CHIPCOMMON:
+               case SSB_DEV_PCI:
+               case SSB_DEV_PCIE:
+               case SSB_DEV_PCMCIA:
+               case SSB_DEV_MIPS:
+               case SSB_DEV_MIPS_3302:
+               case SSB_DEV_EXTIF:
+                       continue;
+               }
+
+               devwrap = kzalloc(sizeof(*devwrap), GFP_KERNEL);
+               if (!devwrap) {
+                       ssb_printk(KERN_ERR PFX
+                                  "Could not allocate device\n");
+                       err = -ENOMEM;
+                       goto error;
+               }
+               dev = &devwrap->dev;
+               devwrap->sdev = sdev;
+
+               dev->release = ssb_release_dev;
+               dev->bus = &ssb_bustype;
+               snprintf(dev->bus_id, sizeof(dev->bus_id),
+                        "ssb%u:%d", bus->busnumber, dev_idx);
+
+               switch (bus->bustype) {
+               case SSB_BUSTYPE_PCI:
+#ifdef CONFIG_SSB_PCIHOST
+                       sdev->irq = bus->host_pci->irq;
+                       dev->parent = &bus->host_pci->dev;
+#endif
+                       break;
+               case SSB_BUSTYPE_PCMCIA:
+#ifdef CONFIG_SSB_PCMCIAHOST
+                       sdev->irq = bus->host_pcmcia->irq.AssignedIRQ;
+                       dev->parent = &bus->host_pcmcia->dev;
+#endif
+                       break;
+               case SSB_BUSTYPE_SSB:
+                       break;
+               }
+
+               sdev->dev = dev;
+               err = device_register(dev);
+               if (err) {
+                       ssb_printk(KERN_ERR PFX
+                                  "Could not register %s\n",
+                                  dev->bus_id);
+                       /* Set dev to NULL to not unregister
+                        * dev on error unwinding. */
+                       sdev->dev = NULL;
+                       kfree(devwrap);
+                       goto error;
+               }
+               dev_idx++;
+       }
+
+       return 0;
+error:
+       /* Unwind the already registered devices. */
+       ssb_devices_unregister(bus);
+       return err;
+}
+
+/* Needs ssb_buses_lock() */
+static int ssb_attach_queued_buses(void)
+{
+       struct ssb_bus *bus, *n;
+       int err = 0;
+       int drop_them_all = 0;
+
+       list_for_each_entry_safe(bus, n, &attach_queue, list) {
+               if (drop_them_all) {
+                       list_del(&bus->list);
+                       continue;
+               }
+               /* Can't init the PCIcore in ssb_bus_register(), as that
+                * is too early in boot for embedded systems
+                * (no udelay() available). So do it here in attach stage.
+                */
+               err = ssb_bus_powerup(bus, 0);
+               if (err)
+                       goto error;
+               ssb_pcicore_init(&bus->pcicore);
+               ssb_bus_may_powerdown(bus);
+
+               err = ssb_devices_register(bus);
+error:
+               if (err) {
+                       drop_them_all = 1;
+                       list_del(&bus->list);
+                       continue;
+               }
+               list_move_tail(&bus->list, &buses);
+       }
+
+       return err;
+}
+
+static u16 ssb_ssb_read16(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       offset += dev->core_index * SSB_CORE_SIZE;
+       return readw(bus->mmio + offset);
+}
+
+static u32 ssb_ssb_read32(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       offset += dev->core_index * SSB_CORE_SIZE;
+       return readl(bus->mmio + offset);
+}
+
+static void ssb_ssb_write16(struct ssb_device *dev, u16 offset, u16 value)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       offset += dev->core_index * SSB_CORE_SIZE;
+       writew(value, bus->mmio + offset);
+}
+
+static void ssb_ssb_write32(struct ssb_device *dev, u16 offset, u32 value)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       offset += dev->core_index * SSB_CORE_SIZE;
+       writel(value, bus->mmio + offset);
+}
+
+/* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */
+static const struct ssb_bus_ops ssb_ssb_ops = {
+       .read16         = ssb_ssb_read16,
+       .read32         = ssb_ssb_read32,
+       .write16        = ssb_ssb_write16,
+       .write32        = ssb_ssb_write32,
+};
+
+static int ssb_fetch_invariants(struct ssb_bus *bus,
+                               ssb_invariants_func_t get_invariants)
+{
+       struct ssb_init_invariants iv;
+       int err;
+
+       memset(&iv, 0, sizeof(iv));
+       err = get_invariants(bus, &iv);
+       if (err)
+               goto out;
+       memcpy(&bus->boardinfo, &iv.boardinfo, sizeof(iv.boardinfo));
+       memcpy(&bus->sprom, &iv.sprom, sizeof(iv.sprom));
+out:
+       return err;
+}
+
+static int ssb_bus_register(struct ssb_bus *bus,
+                           ssb_invariants_func_t get_invariants,
+                           unsigned long baseaddr)
+{
+       int err;
+
+       spin_lock_init(&bus->bar_lock);
+       INIT_LIST_HEAD(&bus->list);
+
+       /* Powerup the bus */
+       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
+       if (err)
+               goto out;
+       ssb_buses_lock();
+       bus->busnumber = next_busnumber;
+       /* Scan for devices (cores) */
+       err = ssb_bus_scan(bus, baseaddr);
+       if (err)
+               goto err_disable_xtal;
+
+       /* Init PCI-host device (if any) */
+       err = ssb_pci_init(bus);
+       if (err)
+               goto err_unmap;
+       /* Init PCMCIA-host device (if any) */
+       err = ssb_pcmcia_init(bus);
+       if (err)
+               goto err_pci_exit;
+
+       /* Initialize basic system devices (if available) */
+       err = ssb_bus_powerup(bus, 0);
+       if (err)
+               goto err_pcmcia_exit;
+       ssb_chipcommon_init(&bus->chipco);
+       ssb_mipscore_init(&bus->mipscore);
+       err = ssb_fetch_invariants(bus, get_invariants);
+       if (err) {
+               ssb_bus_may_powerdown(bus);
+               goto err_pcmcia_exit;
+       }
+       ssb_bus_may_powerdown(bus);
+
+       /* Queue it for attach.
+        * See the comment at the ssb_is_early_boot definition. */
+       list_add_tail(&bus->list, &attach_queue);
+       if (!ssb_is_early_boot) {
+               /* This is not early boot, so we must attach the bus now */
+               err = ssb_attach_queued_buses();
+               if (err)
+                       goto err_dequeue;
+       }
+       next_busnumber++;
+       ssb_buses_unlock();
+
+out:
+       return err;
+
+err_dequeue:
+       list_del(&bus->list);
+err_pcmcia_exit:
+/*     ssb_pcmcia_exit(bus); */
+err_pci_exit:
+       ssb_pci_exit(bus);
+err_unmap:
+       ssb_iounmap(bus);
+err_disable_xtal:
+       ssb_buses_unlock();
+       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
+       return err;
+}
+
+#ifdef CONFIG_SSB_PCIHOST
+int ssb_bus_pcibus_register(struct ssb_bus *bus,
+                           struct pci_dev *host_pci)
+{
+       int err;
+
+       bus->bustype = SSB_BUSTYPE_PCI;
+       bus->host_pci = host_pci;
+       bus->ops = &ssb_pci_ops;
+
+       err = ssb_bus_register(bus, ssb_pci_get_invariants, 0);
+       if (!err) {
+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
+                          "PCI device %s\n", host_pci->dev.bus_id);
+       }
+
+       return err;
+}
+EXPORT_SYMBOL(ssb_bus_pcibus_register);
+#endif /* CONFIG_SSB_PCIHOST */
+
+#ifdef CONFIG_SSB_PCMCIAHOST
+int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
+                              struct pcmcia_device *pcmcia_dev,
+                              unsigned long baseaddr)
+{
+       int err;
+
+       bus->bustype = SSB_BUSTYPE_PCMCIA;
+       bus->host_pcmcia = pcmcia_dev;
+       bus->ops = &ssb_pcmcia_ops;
+
+       err = ssb_bus_register(bus, ssb_pcmcia_get_invariants, baseaddr);
+       if (!err) {
+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
+                          "PCMCIA device %s\n", pcmcia_dev->devname);
+       }
+
+       return err;
+}
+EXPORT_SYMBOL(ssb_bus_pcmciabus_register);
+#endif /* CONFIG_SSB_PCMCIAHOST */
+
+int ssb_bus_ssbbus_register(struct ssb_bus *bus,
+                           unsigned long baseaddr,
+                           ssb_invariants_func_t get_invariants)
+{
+       int err;
+
+       bus->bustype = SSB_BUSTYPE_SSB;
+       bus->ops = &ssb_ssb_ops;
+
+       err = ssb_bus_register(bus, get_invariants, baseaddr);
+       if (!err) {
+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found at "
+                          "address 0x%08lX\n", baseaddr);
+       }
+
+       return err;
+}
+
+int __ssb_driver_register(struct ssb_driver *drv, struct module *owner)
+{
+       drv->drv.name = drv->name;
+       drv->drv.bus = &ssb_bustype;
+       drv->drv.owner = owner;
+
+       return driver_register(&drv->drv);
+}
+EXPORT_SYMBOL(__ssb_driver_register);
+
+void ssb_driver_unregister(struct ssb_driver *drv)
+{
+       driver_unregister(&drv->drv);
+}
+EXPORT_SYMBOL(ssb_driver_unregister);
+
+void ssb_set_devtypedata(struct ssb_device *dev, void *data)
+{
+       struct ssb_bus *bus = dev->bus;
+       struct ssb_device *ent;
+       int i;
+
+       for (i = 0; i < bus->nr_devices; i++) {
+               ent = &(bus->devices[i]);
+               if (ent->id.vendor != dev->id.vendor)
+                       continue;
+               if (ent->id.coreid != dev->id.coreid)
+                       continue;
+
+               ent->devtypedata = data;
+       }
+}
+EXPORT_SYMBOL(ssb_set_devtypedata);
+
+static u32 clkfactor_f6_resolve(u32 v)
+{
+       /* map the magic values */
+       switch (v) {
+       case SSB_CHIPCO_CLK_F6_2:
+               return 2;
+       case SSB_CHIPCO_CLK_F6_3:
+               return 3;
+       case SSB_CHIPCO_CLK_F6_4:
+               return 4;
+       case SSB_CHIPCO_CLK_F6_5:
+               return 5;
+       case SSB_CHIPCO_CLK_F6_6:
+               return 6;
+       case SSB_CHIPCO_CLK_F6_7:
+               return 7;
+       }
+       return 0;
+}
+
+/* Calculate the speed the backplane would run at a given set of clockcontrol values */
+u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m)
+{
+       u32 n1, n2, clock, m1, m2, m3, mc;
+
+       n1 = (n & SSB_CHIPCO_CLK_N1);
+       n2 = ((n & SSB_CHIPCO_CLK_N2) >> SSB_CHIPCO_CLK_N2_SHIFT);
+
+       switch (plltype) {
+       case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */
+               if (m & SSB_CHIPCO_CLK_T6_MMASK)
+                       return SSB_CHIPCO_CLK_T6_M0;
+               return SSB_CHIPCO_CLK_T6_M1;
+       case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */
+       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
+       case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */
+       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
+               n1 = clkfactor_f6_resolve(n1);
+               n2 += SSB_CHIPCO_CLK_F5_BIAS;
+               break;
+       case SSB_PLLTYPE_2: /* 48Mhz, 4 dividers */
+               n1 += SSB_CHIPCO_CLK_T2_BIAS;
+               n2 += SSB_CHIPCO_CLK_T2_BIAS;
+               SSB_WARN_ON(!((n1 >= 2) && (n1 <= 7)));
+               SSB_WARN_ON(!((n2 >= 5) && (n2 <= 23)));
+               break;
+       case SSB_PLLTYPE_5: /* 25Mhz, 4 dividers */
+               return 100000000;
+       default:
+               SSB_WARN_ON(1);
+       }
+
+       switch (plltype) {
+       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
+       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
+               clock = SSB_CHIPCO_CLK_BASE2 * n1 * n2;
+               break;
+       default:
+               clock = SSB_CHIPCO_CLK_BASE1 * n1 * n2;
+       }
+       if (!clock)
+               return 0;
+
+       m1 = (m & SSB_CHIPCO_CLK_M1);
+       m2 = ((m & SSB_CHIPCO_CLK_M2) >> SSB_CHIPCO_CLK_M2_SHIFT);
+       m3 = ((m & SSB_CHIPCO_CLK_M3) >> SSB_CHIPCO_CLK_M3_SHIFT);
+       mc = ((m & SSB_CHIPCO_CLK_MC) >> SSB_CHIPCO_CLK_MC_SHIFT);
+
+       switch (plltype) {
+       case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */
+       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
+       case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */
+       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
+               m1 = clkfactor_f6_resolve(m1);
+               if ((plltype == SSB_PLLTYPE_1) ||
+                   (plltype == SSB_PLLTYPE_3))
+                       m2 += SSB_CHIPCO_CLK_F5_BIAS;
+               else
+                       m2 = clkfactor_f6_resolve(m2);
+               m3 = clkfactor_f6_resolve(m3);
+
+               switch (mc) {
+               case SSB_CHIPCO_CLK_MC_BYPASS:
+                       return clock;
+               case SSB_CHIPCO_CLK_MC_M1:
+                       return (clock / m1);
+               case SSB_CHIPCO_CLK_MC_M1M2:
+                       return (clock / (m1 * m2));
+               case SSB_CHIPCO_CLK_MC_M1M2M3:
+                       return (clock / (m1 * m2 * m3));
+               case SSB_CHIPCO_CLK_MC_M1M3:
+                       return (clock / (m1 * m3));
+               }
+               return 0;
+       case SSB_PLLTYPE_2:
+               m1 += SSB_CHIPCO_CLK_T2_BIAS;
+               m2 += SSB_CHIPCO_CLK_T2M2_BIAS;
+               m3 += SSB_CHIPCO_CLK_T2_BIAS;
+               SSB_WARN_ON(!((m1 >= 2) && (m1 <= 7)));
+               SSB_WARN_ON(!((m2 >= 3) && (m2 <= 10)));
+               SSB_WARN_ON(!((m3 >= 2) && (m3 <= 7)));
+
+               if (!(mc & SSB_CHIPCO_CLK_T2MC_M1BYP))
+                       clock /= m1;
+               if (!(mc & SSB_CHIPCO_CLK_T2MC_M2BYP))
+                       clock /= m2;
+               if (!(mc & SSB_CHIPCO_CLK_T2MC_M3BYP))
+                       clock /= m3;
+               return clock;
+       default:
+               SSB_WARN_ON(1);
+       }
+       return 0;
+}
+
+/* Get the current speed the backplane is running at */
+u32 ssb_clockspeed(struct ssb_bus *bus)
+{
+       u32 rate;
+       u32 plltype;
+       u32 clkctl_n, clkctl_m;
+
+       if (ssb_extif_available(&bus->extif))
+               ssb_extif_get_clockcontrol(&bus->extif, &plltype,
+                                          &clkctl_n, &clkctl_m);
+       else if (bus->chipco.dev)
+               ssb_chipco_get_clockcontrol(&bus->chipco, &plltype,
+                                           &clkctl_n, &clkctl_m);
+       else
+               return 0;
+
+       if (bus->chip_id == 0x5365) {
+               rate = 100000000;
+       } else {
+               rate = ssb_calc_clock_rate(plltype, clkctl_n, clkctl_m);
+               if (plltype == SSB_PLLTYPE_3) /* 25Mhz, 2 dividers */
+                       rate /= 2;
+       }
+
+       return rate;
+}
+EXPORT_SYMBOL(ssb_clockspeed);
+
+static u32 ssb_tmslow_reject_bitmask(struct ssb_device *dev)
+{
+       u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV;
+
+       /* The REJECT bit changed position in TMSLOW between
+        * Backplane revisions. */
+       switch (rev) {
+       case SSB_IDLOW_SSBREV_22:
+               return SSB_TMSLOW_REJECT_22;
+       case SSB_IDLOW_SSBREV_23:
+               return SSB_TMSLOW_REJECT_23;
+       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */
+       case SSB_IDLOW_SSBREV_25:     /* same here */
+       case SSB_IDLOW_SSBREV_26:     /* same here */
+       case SSB_IDLOW_SSBREV_27:     /* same here */
+               return SSB_TMSLOW_REJECT_23;    /* this is a guess */
+       default:
+               printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
+               WARN_ON(1);
+       }
+       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23);
+}
+
+int ssb_device_is_enabled(struct ssb_device *dev)
+{
+       u32 val;
+       u32 reject;
+
+       reject = ssb_tmslow_reject_bitmask(dev);
+       val = ssb_read32(dev, SSB_TMSLOW);
+       val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | reject;
+
+       return (val == SSB_TMSLOW_CLOCK);
+}
+EXPORT_SYMBOL(ssb_device_is_enabled);
+
+static void ssb_flush_tmslow(struct ssb_device *dev)
+{
+       /* Make _really_ sure the device has finished the TMSLOW
+        * register write transaction, as we risk running into
+        * a machine check exception otherwise.
+        * Do this by reading the register back to commit the
+        * PCI write and delay an additional usec for the device
+        * to react to the change. */
+       ssb_read32(dev, SSB_TMSLOW);
+       udelay(1);
+}
+
+void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags)
+{
+       u32 val;
+
+       ssb_device_disable(dev, core_specific_flags);
+       ssb_write32(dev, SSB_TMSLOW,
+                   SSB_TMSLOW_RESET | SSB_TMSLOW_CLOCK |
+                   SSB_TMSLOW_FGC | core_specific_flags);
+       ssb_flush_tmslow(dev);
+
+       /* Clear SERR if set. This is a hw bug workaround. */
+       if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_SERR)
+               ssb_write32(dev, SSB_TMSHIGH, 0);
+
+       val = ssb_read32(dev, SSB_IMSTATE);
+       if (val & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO)) {
+               val &= ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO);
+               ssb_write32(dev, SSB_IMSTATE, val);
+       }
+
+       ssb_write32(dev, SSB_TMSLOW,
+                   SSB_TMSLOW_CLOCK | SSB_TMSLOW_FGC |
+                   core_specific_flags);
+       ssb_flush_tmslow(dev);
+
+       ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_CLOCK |
+                   core_specific_flags);
+       ssb_flush_tmslow(dev);
+}
+EXPORT_SYMBOL(ssb_device_enable);
+
+/* Wait for a bit in a register to get set or unset.
+ * timeout is in units of ten-microseconds */
+static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask,
+                       int timeout, int set)
+{
+       int i;
+       u32 val;
+
+       for (i = 0; i < timeout; i++) {
+               val = ssb_read32(dev, reg);
+               if (set) {
+                       if (val & bitmask)
+                               return 0;
+               } else {
+                       if (!(val & bitmask))
+                               return 0;
+               }
+               udelay(10);
+       }
+       printk(KERN_ERR PFX "Timeout waiting for bitmask %08X on "
+                           "register %04X to %s.\n",
+              bitmask, reg, (set ? "set" : "clear"));
+
+       return -ETIMEDOUT;
+}
+
+void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags)
+{
+       u32 reject;
+
+       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET)
+               return;
+
+       reject = ssb_tmslow_reject_bitmask(dev);
+       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
+       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1);
+       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
+       ssb_write32(dev, SSB_TMSLOW,
+                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
+                   reject | SSB_TMSLOW_RESET |
+                   core_specific_flags);
+       ssb_flush_tmslow(dev);
+
+       ssb_write32(dev, SSB_TMSLOW,
+                   reject | SSB_TMSLOW_RESET |
+                   core_specific_flags);
+       ssb_flush_tmslow(dev);
+}
+EXPORT_SYMBOL(ssb_device_disable);
+
+u32 ssb_dma_translation(struct ssb_device *dev)
+{
+       switch (dev->bus->bustype) {
+       case SSB_BUSTYPE_SSB:
+               return 0;
+       case SSB_BUSTYPE_PCI:
+       case SSB_BUSTYPE_PCMCIA:
+               return SSB_PCI_DMA;
+       }
+       return 0;
+}
+EXPORT_SYMBOL(ssb_dma_translation);
+
+int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask)
+{
+       struct device *dev = ssb_dev->dev;
+
+#ifdef CONFIG_SSB_PCIHOST
+       if (ssb_dev->bus->bustype == SSB_BUSTYPE_PCI &&
+           !dma_supported(dev, mask))
+               return -EIO;
+#endif
+       dev->coherent_dma_mask = mask;
+       dev->dma_mask = &dev->coherent_dma_mask;
+
+       return 0;
+}
+EXPORT_SYMBOL(ssb_dma_set_mask);
+
+int ssb_bus_may_powerdown(struct ssb_bus *bus)
+{
+       struct ssb_chipcommon *cc;
+       int err = 0;
+
+       /* On buses where more than one core may be working
+        * at a time, we must not powerdown stuff if there are
+        * still cores that may want to run. */
+       if (bus->bustype == SSB_BUSTYPE_SSB)
+               goto out;
+
+       cc = &bus->chipco;
+       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW);
+       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
+       if (err)
+               goto error;
+out:
+#ifdef CONFIG_SSB_DEBUG
+       bus->powered_up = 0;
+#endif
+       return err;
+error:
+       ssb_printk(KERN_ERR PFX "Bus powerdown failed\n");
+       goto out;
+}
+EXPORT_SYMBOL(ssb_bus_may_powerdown);
+
+int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl)
+{
+       struct ssb_chipcommon *cc;
+       int err;
+       enum ssb_clkmode mode;
+
+       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
+       if (err)
+               goto error;
+       cc = &bus->chipco;
+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST;
+       ssb_chipco_set_clockmode(cc, mode);
+
+#ifdef CONFIG_SSB_DEBUG
+       bus->powered_up = 1;
+#endif
+       return 0;
+error:
+       ssb_printk(KERN_ERR PFX "Bus powerup failed\n");
+       return err;
+}
+EXPORT_SYMBOL(ssb_bus_powerup);
+
+u32 ssb_admatch_base(u32 adm)
+{
+       u32 base = 0;
+
+       switch (adm & SSB_ADM_TYPE) {
+       case SSB_ADM_TYPE0:
+               base = (adm & SSB_ADM_BASE0);
+               break;
+       case SSB_ADM_TYPE1:
+               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
+               base = (adm & SSB_ADM_BASE1);
+               break;
+       case SSB_ADM_TYPE2:
+               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
+               base = (adm & SSB_ADM_BASE2);
+               break;
+       default:
+               SSB_WARN_ON(1);
+       }
+
+       return base;
+}
+EXPORT_SYMBOL(ssb_admatch_base);
+
+u32 ssb_admatch_size(u32 adm)
+{
+       u32 size = 0;
+
+       switch (adm & SSB_ADM_TYPE) {
+       case SSB_ADM_TYPE0:
+               size = ((adm & SSB_ADM_SZ0) >> SSB_ADM_SZ0_SHIFT);
+               break;
+       case SSB_ADM_TYPE1:
+               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
+               size = ((adm & SSB_ADM_SZ1) >> SSB_ADM_SZ1_SHIFT);
+               break;
+       case SSB_ADM_TYPE2:
+               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
+               size = ((adm & SSB_ADM_SZ2) >> SSB_ADM_SZ2_SHIFT);
+               break;
+       default:
+               SSB_WARN_ON(1);
+       }
+       size = (1 << (size + 1));
+
+       return size;
+}
+EXPORT_SYMBOL(ssb_admatch_size);
+
+static int __init ssb_modinit(void)
+{
+       int err;
+
+       /* See the comment at the ssb_is_early_boot definition */
+       ssb_is_early_boot = 0;
+       err = bus_register(&ssb_bustype);
+       if (err)
+               return err;
+
+       /* Maybe we already registered some buses at early boot.
+        * Check for this and attach them
+        */
+       ssb_buses_lock();
+       err = ssb_attach_queued_buses();
+       ssb_buses_unlock();
+       if (err)
+               bus_unregister(&ssb_bustype);
+
+       err = b43_pci_ssb_bridge_init();
+       if (err) {
+               ssb_printk(KERN_ERR "Broadcom 43xx PCI-SSB-bridge "
+                          "initialization failed");
+               /* don't fail SSB init because of this */
+               err = 0;
+       }
+
+       return err;
+}
+/* ssb must be initialized after PCI but before the ssb drivers.
+ * That means we must use some initcall between subsys_initcall
+ * and device_initcall. */
+fs_initcall(ssb_modinit);
+
+static void __exit ssb_modexit(void)
+{
+       b43_pci_ssb_bridge_exit();
+       bus_unregister(&ssb_bustype);
+}
+module_exit(ssb_modexit)
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pci.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pci.c
new file mode 100644 (file)
index 0000000..b434df7
--- /dev/null
@@ -0,0 +1,790 @@
+/*
+ * Sonics Silicon Backplane PCI-Hostbus related functions.
+ *
+ * Copyright (C) 2005-2006 Michael Buesch <mb@bu3sch.de>
+ * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
+ * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
+ * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
+ * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
+ *
+ * Derived from the Broadcom 4400 device driver.
+ * Copyright (C) 2002 David S. Miller (davem@redhat.com)
+ * Fixed by Pekka Pietikainen (pp@ee.oulu.fi)
+ * Copyright (C) 2006 Broadcom Corporation.
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/ssb/ssb_regs.h>
+#include <linux/pci.h>
+#include <linux/delay.h>
+
+#include "ssb_private.h"
+
+
+/* Define the following to 1 to enable a printk on each coreswitch. */
+#define SSB_VERBOSE_PCICORESWITCH_DEBUG                0
+
+
+/* Lowlevel coreswitching */
+int ssb_pci_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
+{
+       int err;
+       int attempts = 0;
+       u32 cur_core;
+
+       while (1) {
+               err = pci_write_config_dword(bus->host_pci, SSB_BAR0_WIN,
+                                            (coreidx * SSB_CORE_SIZE)
+                                            + SSB_ENUM_BASE);
+               if (err)
+                       goto error;
+               err = pci_read_config_dword(bus->host_pci, SSB_BAR0_WIN,
+                                           &cur_core);
+               if (err)
+                       goto error;
+               cur_core = (cur_core - SSB_ENUM_BASE)
+                          / SSB_CORE_SIZE;
+               if (cur_core == coreidx)
+                       break;
+
+               if (attempts++ > SSB_BAR0_MAX_RETRIES)
+                       goto error;
+               udelay(10);
+       }
+       return 0;
+error:
+       ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
+       return -ENODEV;
+}
+
+int ssb_pci_switch_core(struct ssb_bus *bus,
+                       struct ssb_device *dev)
+{
+       int err;
+       unsigned long flags;
+
+#if SSB_VERBOSE_PCICORESWITCH_DEBUG
+       ssb_printk(KERN_INFO PFX
+                  "Switching to %s core, index %d\n",
+                  ssb_core_name(dev->id.coreid),
+                  dev->core_index);
+#endif
+
+       spin_lock_irqsave(&bus->bar_lock, flags);
+       err = ssb_pci_switch_coreidx(bus, dev->core_index);
+       if (!err)
+               bus->mapped_device = dev;
+       spin_unlock_irqrestore(&bus->bar_lock, flags);
+
+       return err;
+}
+
+/* Enable/disable the on board crystal oscillator and/or PLL. */
+int ssb_pci_xtal(struct ssb_bus *bus, u32 what, int turn_on)
+{
+       int err;
+       u32 in, out, outenable;
+       u16 pci_status;
+
+       if (bus->bustype != SSB_BUSTYPE_PCI)
+               return 0;
+
+       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_IN, &in);
+       if (err)
+               goto err_pci;
+       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT, &out);
+       if (err)
+               goto err_pci;
+       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, &outenable);
+       if (err)
+               goto err_pci;
+
+       outenable |= what;
+
+       if (turn_on) {
+               /* Avoid glitching the clock if GPRS is already using it.
+                * We can't actually read the state of the PLLPD so we infer it
+                * by the value of XTAL_PU which *is* readable via gpioin.
+                */
+               if (!(in & SSB_GPIO_XTAL)) {
+                       if (what & SSB_GPIO_XTAL) {
+                               /* Turn the crystal on */
+                               out |= SSB_GPIO_XTAL;
+                               if (what & SSB_GPIO_PLL)
+                                       out |= SSB_GPIO_PLL;
+                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
+                               if (err)
+                                       goto err_pci;
+                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE,
+                                                            outenable);
+                               if (err)
+                                       goto err_pci;
+                               msleep(1);
+                       }
+                       if (what & SSB_GPIO_PLL) {
+                               /* Turn the PLL on */
+                               out &= ~SSB_GPIO_PLL;
+                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
+                               if (err)
+                                       goto err_pci;
+                               msleep(5);
+                       }
+               }
+
+               err = pci_read_config_word(bus->host_pci, PCI_STATUS, &pci_status);
+               if (err)
+                       goto err_pci;
+               pci_status &= ~PCI_STATUS_SIG_TARGET_ABORT;
+               err = pci_write_config_word(bus->host_pci, PCI_STATUS, pci_status);
+               if (err)
+                       goto err_pci;
+       } else {
+               if (what & SSB_GPIO_XTAL) {
+                       /* Turn the crystal off */
+                       out &= ~SSB_GPIO_XTAL;
+               }
+               if (what & SSB_GPIO_PLL) {
+                       /* Turn the PLL off */
+                       out |= SSB_GPIO_PLL;
+               }
+               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
+               if (err)
+                       goto err_pci;
+               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, outenable);
+               if (err)
+                       goto err_pci;
+       }
+
+out:
+       return err;
+
+err_pci:
+       printk(KERN_ERR PFX "Error: ssb_pci_xtal() could not access PCI config space!\n");
+       err = -EBUSY;
+       goto out;
+}
+
+/* Get the word-offset for a SSB_SPROM_XXX define. */
+#define SPOFF(offset)  (((offset) - SSB_SPROM_BASE) / sizeof(u16))
+/* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */
+#define SPEX(_outvar, _offset, _mask, _shift)  \
+       out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift))
+
+static inline u8 ssb_crc8(u8 crc, u8 data)
+{
+       /* Polynomial:   x^8 + x^7 + x^6 + x^4 + x^2 + 1   */
+       static const u8 t[] = {
+               0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
+               0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
+               0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
+               0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
+               0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
+               0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
+               0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
+               0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
+               0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
+               0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
+               0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
+               0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
+               0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
+               0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
+               0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
+               0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
+               0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
+               0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
+               0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
+               0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
+               0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
+               0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
+               0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
+               0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
+               0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
+               0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
+               0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
+               0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
+               0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
+               0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
+               0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
+               0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
+       };
+       return t[crc ^ data];
+}
+
+static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
+{
+       int word;
+       u8 crc = 0xFF;
+
+       for (word = 0; word < size - 1; word++) {
+               crc = ssb_crc8(crc, sprom[word] & 0x00FF);
+               crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);
+       }
+       crc = ssb_crc8(crc, sprom[size - 1] & 0x00FF);
+       crc ^= 0xFF;
+
+       return crc;
+}
+
+static int sprom_check_crc(const u16 *sprom, u16 size)
+{
+       u8 crc;
+       u8 expected_crc;
+       u16 tmp;
+
+       crc = ssb_sprom_crc(sprom, size);
+       tmp = sprom[size - 1] & SSB_SPROM_REVISION_CRC;
+       expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
+       if (crc != expected_crc)
+               return -EPROTO;
+
+       return 0;
+}
+
+static void sprom_do_read(struct ssb_bus *bus, u16 *sprom)
+{
+       int i;
+
+       for (i = 0; i < bus->sprom_size; i++)
+               sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2));
+}
+
+static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom)
+{
+       struct pci_dev *pdev = bus->host_pci;
+       int i, err;
+       u32 spromctl;
+       u16 size = bus->sprom_size;
+
+       ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
+       err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
+       if (err)
+               goto err_ctlreg;
+       spromctl |= SSB_SPROMCTL_WE;
+       err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
+       if (err)
+               goto err_ctlreg;
+       ssb_printk(KERN_NOTICE PFX "[ 0%%");
+       msleep(500);
+       for (i = 0; i < size; i++) {
+               if (i == size / 4)
+                       ssb_printk("25%%");
+               else if (i == size / 2)
+                       ssb_printk("50%%");
+               else if (i == (size * 3) / 4)
+                       ssb_printk("75%%");
+               else if (i % 2)
+                       ssb_printk(".");
+               writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2));
+               mmiowb();
+               msleep(20);
+       }
+       err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
+       if (err)
+               goto err_ctlreg;
+       spromctl &= ~SSB_SPROMCTL_WE;
+       err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
+       if (err)
+               goto err_ctlreg;
+       msleep(500);
+       ssb_printk("100%% ]\n");
+       ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
+
+       return 0;
+err_ctlreg:
+       ssb_printk(KERN_ERR PFX "Could not access SPROM control register.\n");
+       return err;
+}
+
+static s8 r123_extract_antgain(u8 sprom_revision, const u16 *in,
+                              u16 mask, u16 shift)
+{
+       u16 v;
+       u8 gain;
+
+       v = in[SPOFF(SSB_SPROM1_AGAIN)];
+       gain = (v & mask) >> shift;
+       if (gain == 0xFF)
+               gain = 2; /* If unset use 2dBm */
+       if (sprom_revision == 1) {
+               /* Convert to Q5.2 */
+               gain <<= 2;
+       } else {
+               /* Q5.2 Fractional part is stored in 0xC0 */
+               gain = ((gain & 0xC0) >> 6) | ((gain & 0x3F) << 2);
+       }
+
+       return (s8)gain;
+}
+
+static void sprom_extract_r123(struct ssb_sprom *out, const u16 *in)
+{
+       int i;
+       u16 v;
+       s8 gain;
+       u16 loc[3];
+
+       if (out->revision == 3) {                       /* rev 3 moved MAC */
+               loc[0] = SSB_SPROM3_IL0MAC;
+               loc[1] = SSB_SPROM3_ET0MAC;
+               loc[2] = SSB_SPROM3_ET1MAC;
+       } else {
+               loc[0] = SSB_SPROM1_IL0MAC;
+               loc[1] = SSB_SPROM1_ET0MAC;
+               loc[2] = SSB_SPROM1_ET1MAC;
+       }
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(loc[0]) + i];
+               *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
+       }
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(loc[1]) + i];
+               *(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
+       }
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(loc[2]) + i];
+               *(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
+       }
+       SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
+       SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
+            SSB_SPROM1_ETHPHY_ET1A_SHIFT);
+       SPEX(et0mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0M, 14);
+       SPEX(et1mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1M, 15);
+       SPEX(board_rev, SSB_SPROM1_BINF, SSB_SPROM1_BINF_BREV, 0);
+       SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
+            SSB_SPROM1_BINF_CCODE_SHIFT);
+       SPEX(ant_available_a, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTA,
+            SSB_SPROM1_BINF_ANTA_SHIFT);
+       SPEX(ant_available_bg, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTBG,
+            SSB_SPROM1_BINF_ANTBG_SHIFT);
+       SPEX(pa0b0, SSB_SPROM1_PA0B0, 0xFFFF, 0);
+       SPEX(pa0b1, SSB_SPROM1_PA0B1, 0xFFFF, 0);
+       SPEX(pa0b2, SSB_SPROM1_PA0B2, 0xFFFF, 0);
+       SPEX(pa1b0, SSB_SPROM1_PA1B0, 0xFFFF, 0);
+       SPEX(pa1b1, SSB_SPROM1_PA1B1, 0xFFFF, 0);
+       SPEX(pa1b2, SSB_SPROM1_PA1B2, 0xFFFF, 0);
+       SPEX(gpio0, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P0, 0);
+       SPEX(gpio1, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P1,
+            SSB_SPROM1_GPIOA_P1_SHIFT);
+       SPEX(gpio2, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P2, 0);
+       SPEX(gpio3, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P3,
+            SSB_SPROM1_GPIOB_P3_SHIFT);
+       SPEX(maxpwr_a, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_A,
+            SSB_SPROM1_MAXPWR_A_SHIFT);
+       SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG, 0);
+       SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A,
+            SSB_SPROM1_ITSSI_A_SHIFT);
+       SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
+       SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
+       if (out->revision >= 2)
+               SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);
+
+       /* Extract the antenna gain values. */
+       gain = r123_extract_antgain(out->revision, in,
+                                   SSB_SPROM1_AGAIN_BG,
+                                   SSB_SPROM1_AGAIN_BG_SHIFT);
+       out->antenna_gain.ghz24.a0 = gain;
+       out->antenna_gain.ghz24.a1 = gain;
+       out->antenna_gain.ghz24.a2 = gain;
+       out->antenna_gain.ghz24.a3 = gain;
+       gain = r123_extract_antgain(out->revision, in,
+                                   SSB_SPROM1_AGAIN_A,
+                                   SSB_SPROM1_AGAIN_A_SHIFT);
+       out->antenna_gain.ghz5.a0 = gain;
+       out->antenna_gain.ghz5.a1 = gain;
+       out->antenna_gain.ghz5.a2 = gain;
+       out->antenna_gain.ghz5.a3 = gain;
+}
+
+static void sprom_extract_r4(struct ssb_sprom *out, const u16 *in)
+{
+       int i;
+       u16 v;
+
+       /* extract the equivalent of the r1 variables */
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(SSB_SPROM4_IL0MAC) + i];
+               *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
+       }
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(SSB_SPROM4_ET0MAC) + i];
+               *(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
+       }
+       for (i = 0; i < 3; i++) {
+               v = in[SPOFF(SSB_SPROM4_ET1MAC) + i];
+               *(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
+       }
+       SPEX(et0phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET0A, 0);
+       SPEX(et1phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET1A,
+            SSB_SPROM4_ETHPHY_ET1A_SHIFT);
+       SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
+       SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
+       SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0);
+       SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A,
+            SSB_SPROM4_ANTAVAIL_A_SHIFT);
+       SPEX(ant_available_bg, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_BG,
+            SSB_SPROM4_ANTAVAIL_BG_SHIFT);
+       SPEX(maxpwr_bg, SSB_SPROM4_MAXP_BG, SSB_SPROM4_MAXP_BG_MASK, 0);
+       SPEX(itssi_bg, SSB_SPROM4_MAXP_BG, SSB_SPROM4_ITSSI_BG,
+            SSB_SPROM4_ITSSI_BG_SHIFT);
+       SPEX(maxpwr_a, SSB_SPROM4_MAXP_A, SSB_SPROM4_MAXP_A_MASK, 0);
+       SPEX(itssi_a, SSB_SPROM4_MAXP_A, SSB_SPROM4_ITSSI_A,
+            SSB_SPROM4_ITSSI_A_SHIFT);
+       SPEX(gpio0, SSB_SPROM4_GPIOA, SSB_SPROM4_GPIOA_P0, 0);
+       SPEX(gpio1, SSB_SPROM4_GPIOA, SSB_SPROM4_GPIOA_P1,
+            SSB_SPROM4_GPIOA_P1_SHIFT);
+       SPEX(gpio2, SSB_SPROM4_GPIOB, SSB_SPROM4_GPIOB_P2, 0);
+       SPEX(gpio3, SSB_SPROM4_GPIOB, SSB_SPROM4_GPIOB_P3,
+            SSB_SPROM4_GPIOB_P3_SHIFT);
+
+       /* Extract the antenna gain values. */
+       SPEX(antenna_gain.ghz24.a0, SSB_SPROM4_AGAIN01,
+            SSB_SPROM4_AGAIN0, SSB_SPROM4_AGAIN0_SHIFT);
+       SPEX(antenna_gain.ghz24.a1, SSB_SPROM4_AGAIN01,
+            SSB_SPROM4_AGAIN1, SSB_SPROM4_AGAIN1_SHIFT);
+       SPEX(antenna_gain.ghz24.a2, SSB_SPROM4_AGAIN23,
+            SSB_SPROM4_AGAIN2, SSB_SPROM4_AGAIN2_SHIFT);
+       SPEX(antenna_gain.ghz24.a3, SSB_SPROM4_AGAIN23,
+            SSB_SPROM4_AGAIN3, SSB_SPROM4_AGAIN3_SHIFT);
+       memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
+              sizeof(out->antenna_gain.ghz5));
+
+       /* TODO - get remaining rev 4 stuff needed */
+}
+
+static int sprom_extract(struct ssb_bus *bus, struct ssb_sprom *out,
+                        const u16 *in, u16 size)
+{
+       memset(out, 0, sizeof(*out));
+
+       out->revision = in[size - 1] & 0x00FF;
+       ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision);
+       if ((bus->chip_id & 0xFF00) == 0x4400) {
+               /* Workaround: The BCM44XX chip has a stupid revision
+                * number stored in the SPROM.
+                * Always extract r1. */
+               out->revision = 1;
+               sprom_extract_r123(out, in);
+       } else if (bus->chip_id == 0x4321) {
+               /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
+               out->revision = 4;
+               sprom_extract_r4(out, in);
+       } else {
+               if (out->revision == 0)
+                       goto unsupported;
+               if (out->revision >= 1 && out->revision <= 3) {
+                       sprom_extract_r123(out, in);
+               }
+               if (out->revision == 4)
+                       sprom_extract_r4(out, in);
+               if (out->revision >= 5)
+                       goto unsupported;
+       }
+
+       return 0;
+unsupported:
+       ssb_printk(KERN_WARNING PFX "Unsupported SPROM revision %d "
+                  "detected. Will extract v1\n", out->revision);
+       sprom_extract_r123(out, in);
+       return 0;
+}
+
+static int ssb_pci_sprom_get(struct ssb_bus *bus,
+                            struct ssb_sprom *sprom)
+{
+       int err = -ENOMEM;
+       u16 *buf;
+
+       buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
+       if (!buf)
+               goto out;
+       bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
+       sprom_do_read(bus, buf);
+       err = sprom_check_crc(buf, bus->sprom_size);
+       if (err) {
+               /* check for rev 4 sprom - has special signature */
+               if (buf[32] == 0x5372) {
+                       kfree(buf);
+                       buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
+                                     GFP_KERNEL);
+                       if (!buf)
+                               goto out;
+                       bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
+                       sprom_do_read(bus, buf);
+                       err = sprom_check_crc(buf, bus->sprom_size);
+               }
+               if (err)
+                       ssb_printk(KERN_WARNING PFX "WARNING: Invalid"
+                                  " SPROM CRC (corrupt SPROM)\n");
+       }
+       err = sprom_extract(bus, sprom, buf, bus->sprom_size);
+
+       kfree(buf);
+out:
+       return err;
+}
+
+static void ssb_pci_get_boardinfo(struct ssb_bus *bus,
+                                 struct ssb_boardinfo *bi)
+{
+       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID,
+                            &bi->vendor);
+       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID,
+                            &bi->type);
+       pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
+                            &bi->rev);
+}
+
+int ssb_pci_get_invariants(struct ssb_bus *bus,
+                          struct ssb_init_invariants *iv)
+{
+       int err;
+
+       err = ssb_pci_sprom_get(bus, &iv->sprom);
+       if (err)
+               goto out;
+       ssb_pci_get_boardinfo(bus, &iv->boardinfo);
+
+out:
+       return err;
+}
+
+#ifdef CONFIG_SSB_DEBUG
+static int ssb_pci_assert_buspower(struct ssb_bus *bus)
+{
+       if (likely(bus->powered_up))
+               return 0;
+
+       printk(KERN_ERR PFX "FATAL ERROR: Bus powered down "
+              "while accessing PCI MMIO space\n");
+       if (bus->power_warn_count <= 10) {
+               bus->power_warn_count++;
+               dump_stack();
+       }
+
+       return -ENODEV;
+}
+#else /* DEBUG */
+static inline int ssb_pci_assert_buspower(struct ssb_bus *bus)
+{
+       return 0;
+}
+#endif /* DEBUG */
+
+static u16 ssb_pci_read16(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       if (unlikely(ssb_pci_assert_buspower(bus)))
+               return 0xFFFF;
+       if (unlikely(bus->mapped_device != dev)) {
+               if (unlikely(ssb_pci_switch_core(bus, dev)))
+                       return 0xFFFF;
+       }
+       return ioread16(bus->mmio + offset);
+}
+
+static u32 ssb_pci_read32(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       if (unlikely(ssb_pci_assert_buspower(bus)))
+               return 0xFFFFFFFF;
+       if (unlikely(bus->mapped_device != dev)) {
+               if (unlikely(ssb_pci_switch_core(bus, dev)))
+                       return 0xFFFFFFFF;
+       }
+       return ioread32(bus->mmio + offset);
+}
+
+static void ssb_pci_write16(struct ssb_device *dev, u16 offset, u16 value)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       if (unlikely(ssb_pci_assert_buspower(bus)))
+               return;
+       if (unlikely(bus->mapped_device != dev)) {
+               if (unlikely(ssb_pci_switch_core(bus, dev)))
+                       return;
+       }
+       iowrite16(value, bus->mmio + offset);
+}
+
+static void ssb_pci_write32(struct ssb_device *dev, u16 offset, u32 value)
+{
+       struct ssb_bus *bus = dev->bus;
+
+       if (unlikely(ssb_pci_assert_buspower(bus)))
+               return;
+       if (unlikely(bus->mapped_device != dev)) {
+               if (unlikely(ssb_pci_switch_core(bus, dev)))
+                       return;
+       }
+       iowrite32(value, bus->mmio + offset);
+}
+
+/* Not "static", as it's used in main.c */
+const struct ssb_bus_ops ssb_pci_ops = {
+       .read16         = ssb_pci_read16,
+       .read32         = ssb_pci_read32,
+       .write16        = ssb_pci_write16,
+       .write32        = ssb_pci_write32,
+};
+
+static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, u16 size)
+{
+       int i, pos = 0;
+
+       for (i = 0; i < size; i++)
+               pos += snprintf(buf + pos, buf_len - pos - 1,
+                               "%04X", swab16(sprom[i]) & 0xFFFF);
+       pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
+
+       return pos + 1;
+}
+
+static int hex2sprom(u16 *sprom, const char *dump, size_t len, u16 size)
+{
+       char tmp[5] = { 0 };
+       int cnt = 0;
+       unsigned long parsed;
+
+       if (len < size * 2)
+               return -EINVAL;
+
+       while (cnt < size) {
+               memcpy(tmp, dump, 4);
+               dump += 4;
+               parsed = simple_strtoul(tmp, NULL, 16);
+               sprom[cnt++] = swab16((u16)parsed);
+       }
+
+       return 0;
+}
+
+static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev,
+                                      struct device_attribute *attr,
+                                      char *buf)
+{
+       struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
+       struct ssb_bus *bus;
+       u16 *sprom;
+       int err = -ENODEV;
+       ssize_t count = 0;
+
+       bus = ssb_pci_dev_to_bus(pdev);
+       if (!bus)
+               goto out;
+       err = -ENOMEM;
+       sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
+       if (!sprom)
+               goto out;
+
+       /* Use interruptible locking, as the SPROM write might
+        * be holding the lock for several seconds. So allow userspace
+        * to cancel operation. */
+       err = -ERESTARTSYS;
+       if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
+               goto out_kfree;
+       sprom_do_read(bus, sprom);
+       mutex_unlock(&bus->pci_sprom_mutex);
+
+       count = sprom2hex(sprom, buf, PAGE_SIZE, bus->sprom_size);
+       err = 0;
+
+out_kfree:
+       kfree(sprom);
+out:
+       return err ? err : count;
+}
+
+static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
+                                       struct device_attribute *attr,
+                                       const char *buf, size_t count)
+{
+       struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
+       struct ssb_bus *bus;
+       u16 *sprom;
+       int res = 0, err = -ENODEV;
+
+       bus = ssb_pci_dev_to_bus(pdev);
+       if (!bus)
+               goto out;
+       err = -ENOMEM;
+       sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
+       if (!sprom)
+               goto out;
+       err = hex2sprom(sprom, buf, count, bus->sprom_size);
+       if (err) {
+               err = -EINVAL;
+               goto out_kfree;
+       }
+       err = sprom_check_crc(sprom, bus->sprom_size);
+       if (err) {
+               err = -EINVAL;
+               goto out_kfree;
+       }
+
+       /* Use interruptible locking, as the SPROM write might
+        * be holding the lock for several seconds. So allow userspace
+        * to cancel operation. */
+       err = -ERESTARTSYS;
+       if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
+               goto out_kfree;
+       err = ssb_devices_freeze(bus);
+       if (err == -EOPNOTSUPP) {
+               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. "
+                          "No suspend support. Is CONFIG_PM enabled?\n");
+               goto out_unlock;
+       }
+       if (err) {
+               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
+               goto out_unlock;
+       }
+       res = sprom_do_write(bus, sprom);
+       err = ssb_devices_thaw(bus);
+       if (err)
+               ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
+out_unlock:
+       mutex_unlock(&bus->pci_sprom_mutex);
+out_kfree:
+       kfree(sprom);
+out:
+       if (res)
+               return res;
+       return err ? err : count;
+}
+
+static DEVICE_ATTR(ssb_sprom, 0600,
+                  ssb_pci_attr_sprom_show,
+                  ssb_pci_attr_sprom_store);
+
+void ssb_pci_exit(struct ssb_bus *bus)
+{
+       struct pci_dev *pdev;
+
+       if (bus->bustype != SSB_BUSTYPE_PCI)
+               return;
+
+       pdev = bus->host_pci;
+       device_remove_file(&pdev->dev, &dev_attr_ssb_sprom);
+}
+
+int ssb_pci_init(struct ssb_bus *bus)
+{
+       struct pci_dev *pdev;
+       int err;
+
+       if (bus->bustype != SSB_BUSTYPE_PCI)
+               return 0;
+
+       pdev = bus->host_pci;
+       mutex_init(&bus->pci_sprom_mutex);
+       err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom);
+       if (err)
+               goto out;
+
+out:
+       return err;
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcihost_wrapper.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcihost_wrapper.c
new file mode 100644 (file)
index 0000000..82a10ab
--- /dev/null
@@ -0,0 +1,104 @@
+/*
+ * Sonics Silicon Backplane
+ * PCI Hostdevice wrapper
+ *
+ * Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>
+ * Copyright (c) 2005 Stefano Brivio <st3@riseup.net>
+ * Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org>
+ * Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
+ * Copyright (c) 2005-2007 Michael Buesch <mbuesch@freenet.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/pci.h>
+#include <linux/ssb/ssb.h>
+
+
+#ifdef CONFIG_PM
+static int ssb_pcihost_suspend(struct pci_dev *dev, pm_message_t state)
+{
+       pci_save_state(dev);
+       pci_disable_device(dev);
+       pci_set_power_state(dev, pci_choose_state(dev, state));
+
+       return 0;
+}
+
+static int ssb_pcihost_resume(struct pci_dev *dev)
+{
+       int err;
+
+       pci_set_power_state(dev, 0);
+       err = pci_enable_device(dev);
+       if (err)
+               return err;
+       pci_restore_state(dev);
+
+       return 0;
+}
+#else /* CONFIG_PM */
+# define ssb_pcihost_suspend   NULL
+# define ssb_pcihost_resume    NULL
+#endif /* CONFIG_PM */
+
+static int ssb_pcihost_probe(struct pci_dev *dev,
+                            const struct pci_device_id *id)
+{
+       struct ssb_bus *ssb;
+       int err = -ENOMEM;
+       const char *name;
+
+       ssb = kzalloc(sizeof(*ssb), GFP_KERNEL);
+       if (!ssb)
+               goto out;
+       err = pci_enable_device(dev);
+       if (err)
+               goto err_kfree_ssb;
+       name = dev->dev.bus_id;
+       if (dev->driver && dev->driver->name)
+               name = dev->driver->name;
+       err = pci_request_regions(dev, name);
+       if (err)
+               goto err_pci_disable;
+       pci_set_master(dev);
+
+       err = ssb_bus_pcibus_register(ssb, dev);
+       if (err)
+               goto err_pci_release_regions;
+
+       pci_set_drvdata(dev, ssb);
+
+out:
+       return err;
+
+err_pci_release_regions:
+       pci_release_regions(dev);
+err_pci_disable:
+       pci_disable_device(dev);
+err_kfree_ssb:
+       kfree(ssb);
+       return err;
+}
+
+static void ssb_pcihost_remove(struct pci_dev *dev)
+{
+       struct ssb_bus *ssb = pci_get_drvdata(dev);
+
+       ssb_bus_unregister(ssb);
+       pci_release_regions(dev);
+       pci_disable_device(dev);
+       kfree(ssb);
+       pci_set_drvdata(dev, NULL);
+}
+
+int ssb_pcihost_register(struct pci_driver *driver)
+{
+       driver->probe = ssb_pcihost_probe;
+       driver->remove = ssb_pcihost_remove;
+       driver->suspend = ssb_pcihost_suspend;
+       driver->resume = ssb_pcihost_resume;
+
+       return pci_register_driver(driver);
+}
+EXPORT_SYMBOL(ssb_pcihost_register);
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcmcia.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/pcmcia.c
new file mode 100644 (file)
index 0000000..46816cd
--- /dev/null
@@ -0,0 +1,287 @@
+/*
+ * Sonics Silicon Backplane
+ * PCMCIA-Hostbus related functions
+ *
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2007 Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+
+#include <pcmcia/cs_types.h>
+#include <pcmcia/cs.h>
+#include <pcmcia/cistpl.h>
+#include <pcmcia/ciscode.h>
+#include <pcmcia/ds.h>
+#include <pcmcia/cisreg.h>
+
+#include "ssb_private.h"
+
+
+/* Define the following to 1 to enable a printk on each coreswitch. */
+#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG             0
+
+
+int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
+                             u8 coreidx)
+{
+       struct pcmcia_device *pdev = bus->host_pcmcia;
+       int err;
+       int attempts = 0;
+       u32 cur_core;
+       conf_reg_t reg;
+       u32 addr;
+       u32 read_addr;
+
+       addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
+       while (1) {
+               reg.Action = CS_WRITE;
+               reg.Offset = 0x2E;
+               reg.Value = (addr & 0x0000F000) >> 12;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+               reg.Offset = 0x30;
+               reg.Value = (addr & 0x00FF0000) >> 16;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+               reg.Offset = 0x32;
+               reg.Value = (addr & 0xFF000000) >> 24;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+
+               read_addr = 0;
+
+               reg.Action = CS_READ;
+               reg.Offset = 0x2E;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+               read_addr |= ((u32)(reg.Value & 0x0F)) << 12;
+               reg.Offset = 0x30;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+               read_addr |= ((u32)reg.Value) << 16;
+               reg.Offset = 0x32;
+               err = pcmcia_access_configuration_register(pdev, &reg);
+               if (err != CS_SUCCESS)
+                       goto error;
+               read_addr |= ((u32)reg.Value) << 24;
+
+               cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
+               if (cur_core == coreidx)
+                       break;
+
+               if (attempts++ > SSB_BAR0_MAX_RETRIES)
+                       goto error;
+               udelay(10);
+       }
+
+       return 0;
+error:
+       ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
+       return -ENODEV;
+}
+
+int ssb_pcmcia_switch_core(struct ssb_bus *bus,
+                          struct ssb_device *dev)
+{
+       int err;
+
+#if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
+       ssb_printk(KERN_INFO PFX
+                  "Switching to %s core, index %d\n",
+                  ssb_core_name(dev->id.coreid),
+                  dev->core_index);
+#endif
+
+       err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
+       if (!err)
+               bus->mapped_device = dev;
+
+       return err;
+}
+
+int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
+{
+       int attempts = 0;
+       conf_reg_t reg;
+       int res;
+
+       SSB_WARN_ON((seg != 0) && (seg != 1));
+       reg.Offset = 0x34;
+       reg.Function = 0;
+       while (1) {
+               reg.Action = CS_WRITE;
+               reg.Value = seg;
+               res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
+               if (unlikely(res != CS_SUCCESS))
+                       goto error;
+               reg.Value = 0xFF;
+               reg.Action = CS_READ;
+               res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
+               if (unlikely(res != CS_SUCCESS))
+                       goto error;
+
+               if (reg.Value == seg)
+                       break;
+
+               if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
+                       goto error;
+               udelay(10);
+       }
+       bus->mapped_pcmcia_seg = seg;
+
+       return 0;
+error:
+       ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
+       return -ENODEV;
+}
+
+static int select_core_and_segment(struct ssb_device *dev,
+                                  u16 *offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       int err;
+       u8 need_segment;
+
+       if (*offset >= 0x800) {
+               *offset -= 0x800;
+               need_segment = 1;
+       } else
+               need_segment = 0;
+
+       if (unlikely(dev != bus->mapped_device)) {
+               err = ssb_pcmcia_switch_core(bus, dev);
+               if (unlikely(err))
+                       return err;
+       }
+       if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
+               err = ssb_pcmcia_switch_segment(bus, need_segment);
+               if (unlikely(err))
+                       return err;
+       }
+
+       return 0;
+}
+
+static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       unsigned long flags;
+       int err;
+       u16 value = 0xFFFF;
+
+       spin_lock_irqsave(&bus->bar_lock, flags);
+       err = select_core_and_segment(dev, &offset);
+       if (likely(!err))
+               value = readw(bus->mmio + offset);
+       spin_unlock_irqrestore(&bus->bar_lock, flags);
+
+       return value;
+}
+
+static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       unsigned long flags;
+       int err;
+       u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
+
+       spin_lock_irqsave(&bus->bar_lock, flags);
+       err = select_core_and_segment(dev, &offset);
+       if (likely(!err)) {
+               lo = readw(bus->mmio + offset);
+               hi = readw(bus->mmio + offset + 2);
+       }
+       spin_unlock_irqrestore(&bus->bar_lock, flags);
+
+       return (lo | (hi << 16));
+}
+
+static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
+{
+       struct ssb_bus *bus = dev->bus;
+       unsigned long flags;
+       int err;
+
+       spin_lock_irqsave(&bus->bar_lock, flags);
+       err = select_core_and_segment(dev, &offset);
+       if (likely(!err))
+               writew(value, bus->mmio + offset);
+       mmiowb();
+       spin_unlock_irqrestore(&bus->bar_lock, flags);
+}
+
+static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
+{
+       struct ssb_bus *bus = dev->bus;
+       unsigned long flags;
+       int err;
+
+       spin_lock_irqsave(&bus->bar_lock, flags);
+       err = select_core_and_segment(dev, &offset);
+       if (likely(!err)) {
+               writew((value & 0x0000FFFF), bus->mmio + offset);
+               writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
+       }
+       mmiowb();
+       spin_unlock_irqrestore(&bus->bar_lock, flags);
+}
+
+/* Not "static", as it's used in main.c */
+const struct ssb_bus_ops ssb_pcmcia_ops = {
+       .read16         = ssb_pcmcia_read16,
+       .read32         = ssb_pcmcia_read32,
+       .write16        = ssb_pcmcia_write16,
+       .write32        = ssb_pcmcia_write32,
+};
+
+#include <linux/etherdevice.h>
+int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
+                             struct ssb_init_invariants *iv)
+{
+       //TODO
+       random_ether_addr(iv->sprom.il0mac);
+       return 0;
+}
+
+int ssb_pcmcia_init(struct ssb_bus *bus)
+{
+       conf_reg_t reg;
+       int err;
+
+       if (bus->bustype != SSB_BUSTYPE_PCMCIA)
+               return 0;
+
+       /* Switch segment to a known state and sync
+        * bus->mapped_pcmcia_seg with hardware state. */
+       ssb_pcmcia_switch_segment(bus, 0);
+
+       /* Init IRQ routing */
+       reg.Action = CS_READ;
+       reg.Function = 0;
+       if (bus->chip_id == 0x4306)
+               reg.Offset = 0x00;
+       else
+               reg.Offset = 0x80;
+       err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
+       if (err != CS_SUCCESS)
+               goto error;
+       reg.Action = CS_WRITE;
+       reg.Value |= 0x04 | 0x01;
+       err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
+       if (err != CS_SUCCESS)
+               goto error;
+
+       return 0;
+error:
+       return -ENODEV;
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/scan.c b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/scan.c
new file mode 100644 (file)
index 0000000..63ee5cf
--- /dev/null
@@ -0,0 +1,424 @@
+/*
+ * Sonics Silicon Backplane
+ * Bus scanning
+ *
+ * Copyright (C) 2005-2007 Michael Buesch <mb@bu3sch.de>
+ * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
+ * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
+ * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
+ * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
+ * Copyright (C) 2006 Broadcom Corporation.
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/ssb/ssb_regs.h>
+#include <linux/pci.h>
+#include <linux/io.h>
+
+#include <pcmcia/cs_types.h>
+#include <pcmcia/cs.h>
+#include <pcmcia/cistpl.h>
+#include <pcmcia/ds.h>
+
+#include "ssb_private.h"
+
+
+const char *ssb_core_name(u16 coreid)
+{
+       switch (coreid) {
+       case SSB_DEV_CHIPCOMMON:
+               return "ChipCommon";
+       case SSB_DEV_ILINE20:
+               return "ILine 20";
+       case SSB_DEV_SDRAM:
+               return "SDRAM";
+       case SSB_DEV_PCI:
+               return "PCI";
+       case SSB_DEV_MIPS:
+               return "MIPS";
+       case SSB_DEV_ETHERNET:
+               return "Fast Ethernet";
+       case SSB_DEV_V90:
+               return "V90";
+       case SSB_DEV_USB11_HOSTDEV:
+               return "USB 1.1 Hostdev";
+       case SSB_DEV_ADSL:
+               return "ADSL";
+       case SSB_DEV_ILINE100:
+               return "ILine 100";
+       case SSB_DEV_IPSEC:
+               return "IPSEC";
+       case SSB_DEV_PCMCIA:
+               return "PCMCIA";
+       case SSB_DEV_INTERNAL_MEM:
+               return "Internal Memory";
+       case SSB_DEV_MEMC_SDRAM:
+               return "MEMC SDRAM";
+       case SSB_DEV_EXTIF:
+               return "EXTIF";
+       case SSB_DEV_80211:
+               return "IEEE 802.11";
+       case SSB_DEV_MIPS_3302:
+               return "MIPS 3302";
+       case SSB_DEV_USB11_HOST:
+               return "USB 1.1 Host";
+       case SSB_DEV_USB11_DEV:
+               return "USB 1.1 Device";
+       case SSB_DEV_USB20_HOST:
+               return "USB 2.0 Host";
+       case SSB_DEV_USB20_DEV:
+               return "USB 2.0 Device";
+       case SSB_DEV_SDIO_HOST:
+               return "SDIO Host";
+       case SSB_DEV_ROBOSWITCH:
+               return "Roboswitch";
+       case SSB_DEV_PARA_ATA:
+               return "PATA";
+       case SSB_DEV_SATA_XORDMA:
+               return "SATA XOR-DMA";
+       case SSB_DEV_ETHERNET_GBIT:
+               return "GBit Ethernet";
+       case SSB_DEV_PCIE:
+               return "PCI-E";
+       case SSB_DEV_MIMO_PHY:
+               return "MIMO PHY";
+       case SSB_DEV_SRAM_CTRLR:
+               return "SRAM Controller";
+       case SSB_DEV_MINI_MACPHY:
+               return "Mini MACPHY";
+       case SSB_DEV_ARM_1176:
+               return "ARM 1176";
+       case SSB_DEV_ARM_7TDMI:
+               return "ARM 7TDMI";
+       }
+       return "UNKNOWN";
+}
+
+static u16 pcidev_to_chipid(struct pci_dev *pci_dev)
+{
+       u16 chipid_fallback = 0;
+
+       switch (pci_dev->device) {
+       case 0x4301:
+               chipid_fallback = 0x4301;
+               break;
+       case 0x4305 ... 0x4307:
+               chipid_fallback = 0x4307;
+               break;
+       case 0x4403:
+               chipid_fallback = 0x4402;
+               break;
+       case 0x4610 ... 0x4615:
+               chipid_fallback = 0x4610;
+               break;
+       case 0x4710 ... 0x4715:
+               chipid_fallback = 0x4710;
+               break;
+       case 0x4320 ... 0x4325:
+               chipid_fallback = 0x4309;
+               break;
+       case PCI_DEVICE_ID_BCM4401:
+       case PCI_DEVICE_ID_BCM4401B0:
+       case PCI_DEVICE_ID_BCM4401B1:
+               chipid_fallback = 0x4401;
+               break;
+       default:
+               ssb_printk(KERN_ERR PFX
+                          "PCI-ID not in fallback list\n");
+       }
+
+       return chipid_fallback;
+}
+
+static u8 chipid_to_nrcores(u16 chipid)
+{
+       switch (chipid) {
+       case 0x5365:
+               return 7;
+       case 0x4306:
+               return 6;
+       case 0x4310:
+               return 8;
+       case 0x4307:
+       case 0x4301:
+               return 5;
+       case 0x4401:
+       case 0x4402:
+               return 3;
+       case 0x4710:
+       case 0x4610:
+       case 0x4704:
+               return 9;
+       default:
+               ssb_printk(KERN_ERR PFX
+                          "CHIPID not in nrcores fallback list\n");
+       }
+
+       return 1;
+}
+
+static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx,
+                      u16 offset)
+{
+       switch (bus->bustype) {
+       case SSB_BUSTYPE_SSB:
+               offset += current_coreidx * SSB_CORE_SIZE;
+               break;
+       case SSB_BUSTYPE_PCI:
+               break;
+       case SSB_BUSTYPE_PCMCIA:
+               if (offset >= 0x800) {
+                       ssb_pcmcia_switch_segment(bus, 1);
+                       offset -= 0x800;
+               } else
+                       ssb_pcmcia_switch_segment(bus, 0);
+               break;
+       }
+       return readl(bus->mmio + offset);
+}
+
+static int scan_switchcore(struct ssb_bus *bus, u8 coreidx)
+{
+       switch (bus->bustype) {
+       case SSB_BUSTYPE_SSB:
+               break;
+       case SSB_BUSTYPE_PCI:
+               return ssb_pci_switch_coreidx(bus, coreidx);
+       case SSB_BUSTYPE_PCMCIA:
+               return ssb_pcmcia_switch_coreidx(bus, coreidx);
+       }
+       return 0;
+}
+
+void ssb_iounmap(struct ssb_bus *bus)
+{
+       switch (bus->bustype) {
+       case SSB_BUSTYPE_SSB:
+       case SSB_BUSTYPE_PCMCIA:
+               iounmap(bus->mmio);
+               break;
+       case SSB_BUSTYPE_PCI:
+#ifdef CONFIG_SSB_PCIHOST
+               pci_iounmap(bus->host_pci, bus->mmio);
+#else
+               SSB_BUG_ON(1); /* Can't reach this code. */
+#endif
+               break;
+       }
+       bus->mmio = NULL;
+       bus->mapped_device = NULL;
+}
+
+static void __iomem *ssb_ioremap(struct ssb_bus *bus,
+                                unsigned long baseaddr)
+{
+       void __iomem *mmio = NULL;
+
+       switch (bus->bustype) {
+       case SSB_BUSTYPE_SSB:
+               /* Only map the first core for now. */
+               /* fallthrough... */
+       case SSB_BUSTYPE_PCMCIA:
+               mmio = ioremap(baseaddr, SSB_CORE_SIZE);
+               break;
+       case SSB_BUSTYPE_PCI:
+#ifdef CONFIG_SSB_PCIHOST
+               mmio = pci_iomap(bus->host_pci, 0, ~0UL);
+#else
+               SSB_BUG_ON(1); /* Can't reach this code. */
+#endif
+               break;
+       }
+
+       return mmio;
+}
+
+static int we_support_multiple_80211_cores(struct ssb_bus *bus)
+{
+       /* More than one 802.11 core is only supported by special chips.
+        * There are chips with two 802.11 cores, but with dangling
+        * pins on the second core. Be careful and reject them here.
+        */
+
+#ifdef CONFIG_SSB_PCIHOST
+       if (bus->bustype == SSB_BUSTYPE_PCI) {
+               if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM &&
+                   bus->host_pci->device == 0x4324)
+                       return 1;
+       }
+#endif /* CONFIG_SSB_PCIHOST */
+       return 0;
+}
+
+int ssb_bus_scan(struct ssb_bus *bus,
+                unsigned long baseaddr)
+{
+       int err = -ENOMEM;
+       void __iomem *mmio;
+       u32 idhi, cc, rev, tmp;
+       int dev_i, i;
+       struct ssb_device *dev;
+       int nr_80211_cores = 0;
+
+       mmio = ssb_ioremap(bus, baseaddr);
+       if (!mmio)
+               goto out;
+       bus->mmio = mmio;
+
+       err = scan_switchcore(bus, 0); /* Switch to first core */
+       if (err)
+               goto err_unmap;
+
+       idhi = scan_read32(bus, 0, SSB_IDHIGH);
+       cc = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT;
+       rev = (idhi & SSB_IDHIGH_RCLO);
+       rev |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT;
+
+       bus->nr_devices = 0;
+       if (cc == SSB_DEV_CHIPCOMMON) {
+               tmp = scan_read32(bus, 0, SSB_CHIPCO_CHIPID);
+
+               bus->chip_id = (tmp & SSB_CHIPCO_IDMASK);
+               bus->chip_rev = (tmp & SSB_CHIPCO_REVMASK) >>
+                               SSB_CHIPCO_REVSHIFT;
+               bus->chip_package = (tmp & SSB_CHIPCO_PACKMASK) >>
+                                   SSB_CHIPCO_PACKSHIFT;
+               if (rev >= 4) {
+                       bus->nr_devices = (tmp & SSB_CHIPCO_NRCORESMASK) >>
+                                         SSB_CHIPCO_NRCORESSHIFT;
+               }
+               tmp = scan_read32(bus, 0, SSB_CHIPCO_CAP);
+               bus->chipco.capabilities = tmp;
+       } else {
+               if (bus->bustype == SSB_BUSTYPE_PCI) {
+                       bus->chip_id = pcidev_to_chipid(bus->host_pci);
+                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
+                                            &bus->chip_rev);
+                       bus->chip_package = 0;
+               } else {
+                       bus->chip_id = 0x4710;
+                       bus->chip_rev = 0;
+                       bus->chip_package = 0;
+               }
+       }
+       if (!bus->nr_devices)
+               bus->nr_devices = chipid_to_nrcores(bus->chip_id);
+       if (bus->nr_devices > ARRAY_SIZE(bus->devices)) {
+               ssb_printk(KERN_ERR PFX
+                          "More than %d ssb cores found (%d)\n",
+                          SSB_MAX_NR_CORES, bus->nr_devices);
+               goto err_unmap;
+       }
+       if (bus->bustype == SSB_BUSTYPE_SSB) {
+               /* Now that we know the number of cores,
+                * remap the whole IO space for all cores.
+                */
+               err = -ENOMEM;
+               iounmap(mmio);
+               mmio = ioremap(baseaddr, SSB_CORE_SIZE * bus->nr_devices);
+               if (!mmio)
+                       goto out;
+               bus->mmio = mmio;
+       }
+
+       /* Fetch basic information about each core/device */
+       for (i = 0, dev_i = 0; i < bus->nr_devices; i++) {
+               err = scan_switchcore(bus, i);
+               if (err)
+                       goto err_unmap;
+               dev = &(bus->devices[dev_i]);
+
+               idhi = scan_read32(bus, i, SSB_IDHIGH);
+               dev->id.coreid = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT;
+               dev->id.revision = (idhi & SSB_IDHIGH_RCLO);
+               dev->id.revision |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT;
+               dev->id.vendor = (idhi & SSB_IDHIGH_VC) >> SSB_IDHIGH_VC_SHIFT;
+               dev->core_index = i;
+               dev->bus = bus;
+               dev->ops = bus->ops;
+
+               ssb_dprintk(KERN_INFO PFX
+                           "Core %d found: %s "
+                           "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n",
+                           i, ssb_core_name(dev->id.coreid),
+                           dev->id.coreid, dev->id.revision, dev->id.vendor);
+
+               switch (dev->id.coreid) {
+               case SSB_DEV_80211:
+                       nr_80211_cores++;
+                       if (nr_80211_cores > 1) {
+                               if (!we_support_multiple_80211_cores(bus)) {
+                                       ssb_dprintk(KERN_INFO PFX "Ignoring additional "
+                                                   "802.11 core\n");
+                                       continue;
+                               }
+                       }
+                       break;
+               case SSB_DEV_EXTIF:
+#ifdef CONFIG_SSB_DRIVER_EXTIF
+                       if (bus->extif.dev) {
+                               ssb_printk(KERN_WARNING PFX
+                                          "WARNING: Multiple EXTIFs found\n");
+                               break;
+                       }
+                       bus->extif.dev = dev;
+#endif /* CONFIG_SSB_DRIVER_EXTIF */
+                       break;
+               case SSB_DEV_CHIPCOMMON:
+                       if (bus->chipco.dev) {
+                               ssb_printk(KERN_WARNING PFX
+                                          "WARNING: Multiple ChipCommon found\n");
+                               break;
+                       }
+                       bus->chipco.dev = dev;
+                       break;
+               case SSB_DEV_MIPS:
+               case SSB_DEV_MIPS_3302:
+#ifdef CONFIG_SSB_DRIVER_MIPS
+                       if (bus->mipscore.dev) {
+                               ssb_printk(KERN_WARNING PFX
+                                          "WARNING: Multiple MIPS cores found\n");
+                               break;
+                       }
+                       bus->mipscore.dev = dev;
+#endif /* CONFIG_SSB_DRIVER_MIPS */
+                       break;
+               case SSB_DEV_PCI:
+               case SSB_DEV_PCIE:
+#ifdef CONFIG_SSB_DRIVER_PCICORE
+                       if (bus->bustype == SSB_BUSTYPE_PCI) {
+                               /* Ignore PCI cores on PCI-E cards.
+                                * Ignore PCI-E cores on PCI cards. */
+                               if (dev->id.coreid == SSB_DEV_PCI) {
+                                       if (bus->host_pci->is_pcie)
+                                               continue;
+                               } else {
+                                       if (!bus->host_pci->is_pcie)
+                                               continue;
+                               }
+                       }
+                       if (bus->pcicore.dev) {
+                               ssb_printk(KERN_WARNING PFX
+                                          "WARNING: Multiple PCI(E) cores found\n");
+                               break;
+                       }
+                       bus->pcicore.dev = dev;
+#endif /* CONFIG_SSB_DRIVER_PCICORE */
+                       break;
+               default:
+                       break;
+               }
+
+               dev_i++;
+       }
+       bus->nr_devices = dev_i;
+
+       err = 0;
+out:
+       return err;
+err_unmap:
+       ssb_iounmap(bus);
+       goto out;
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/drivers/ssb/ssb_private.h b/target/linux/generic-2.6/files-2.6.24/drivers/ssb/ssb_private.h
new file mode 100644 (file)
index 0000000..a789364
--- /dev/null
@@ -0,0 +1,136 @@
+#ifndef LINUX_SSB_PRIVATE_H_
+#define LINUX_SSB_PRIVATE_H_
+
+#include <linux/ssb/ssb.h>
+#include <linux/types.h>
+
+
+#define PFX    "ssb: "
+
+#ifdef CONFIG_SSB_SILENT
+# define ssb_printk(fmt, x...) do { /* nothing */ } while (0)
+#else
+# define ssb_printk            printk
+#endif /* CONFIG_SSB_SILENT */
+
+/* dprintk: Debugging printk; vanishes for non-debug compilation */
+#ifdef CONFIG_SSB_DEBUG
+# define ssb_dprintk(fmt, x...)        ssb_printk(fmt , ##x)
+#else
+# define ssb_dprintk(fmt, x...)        do { /* nothing */ } while (0)
+#endif
+
+#ifdef CONFIG_SSB_DEBUG
+# define SSB_WARN_ON(x)                WARN_ON(x)
+# define SSB_BUG_ON(x)         BUG_ON(x)
+#else
+static inline int __ssb_do_nothing(int x) { return x; }
+# define SSB_WARN_ON(x)                __ssb_do_nothing(unlikely(!!(x)))
+# define SSB_BUG_ON(x)         __ssb_do_nothing(unlikely(!!(x)))
+#endif
+
+
+/* pci.c */
+#ifdef CONFIG_SSB_PCIHOST
+extern int ssb_pci_switch_core(struct ssb_bus *bus,
+                              struct ssb_device *dev);
+extern int ssb_pci_switch_coreidx(struct ssb_bus *bus,
+                                 u8 coreidx);
+extern int ssb_pci_xtal(struct ssb_bus *bus, u32 what,
+                       int turn_on);
+extern int ssb_pci_get_invariants(struct ssb_bus *bus,
+                                 struct ssb_init_invariants *iv);
+extern void ssb_pci_exit(struct ssb_bus *bus);
+extern int ssb_pci_init(struct ssb_bus *bus);
+extern const struct ssb_bus_ops ssb_pci_ops;
+
+#else /* CONFIG_SSB_PCIHOST */
+
+static inline int ssb_pci_switch_core(struct ssb_bus *bus,
+                                     struct ssb_device *dev)
+{
+       return 0;
+}
+static inline int ssb_pci_switch_coreidx(struct ssb_bus *bus,
+                                        u8 coreidx)
+{
+       return 0;
+}
+static inline int ssb_pci_xtal(struct ssb_bus *bus, u32 what,
+                              int turn_on)
+{
+       return 0;
+}
+static inline void ssb_pci_exit(struct ssb_bus *bus)
+{
+}
+static inline int ssb_pci_init(struct ssb_bus *bus)
+{
+       return 0;
+}
+#endif /* CONFIG_SSB_PCIHOST */
+
+
+/* pcmcia.c */
+#ifdef CONFIG_SSB_PCMCIAHOST
+extern int ssb_pcmcia_switch_core(struct ssb_bus *bus,
+                                 struct ssb_device *dev);
+extern int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
+                                    u8 coreidx);
+extern int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
+                                    u8 seg);
+extern int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
+                                    struct ssb_init_invariants *iv);
+extern int ssb_pcmcia_init(struct ssb_bus *bus);
+extern const struct ssb_bus_ops ssb_pcmcia_ops;
+#else /* CONFIG_SSB_PCMCIAHOST */
+static inline int ssb_pcmcia_switch_core(struct ssb_bus *bus,
+                                        struct ssb_device *dev)
+{
+       return 0;
+}
+static inline int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
+                                           u8 coreidx)
+{
+       return 0;
+}
+static inline int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
+                                           u8 seg)
+{
+       return 0;
+}
+static inline int ssb_pcmcia_init(struct ssb_bus *bus)
+{
+       return 0;
+}
+#endif /* CONFIG_SSB_PCMCIAHOST */
+
+
+/* scan.c */
+extern const char *ssb_core_name(u16 coreid);
+extern int ssb_bus_scan(struct ssb_bus *bus,
+                       unsigned long baseaddr);
+extern void ssb_iounmap(struct ssb_bus *ssb);
+
+
+/* core.c */
+extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m);
+extern int ssb_devices_freeze(struct ssb_bus *bus);
+extern int ssb_devices_thaw(struct ssb_bus *bus);
+extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev);
+
+/* b43_pci_bridge.c */
+#ifdef CONFIG_SSB_PCIHOST
+extern int __init b43_pci_ssb_bridge_init(void);
+extern void __exit b43_pci_ssb_bridge_exit(void);
+#else /* CONFIG_SSB_PCIHOST */
+static inline int b43_pci_ssb_bridge_init(void)
+{
+       return 0;
+}
+static inline void b43_pci_ssb_bridge_exit(void)
+{
+}
+#endif /* CONFIG_SSB_PCIHOST */
+
+#endif /* LINUX_SSB_PRIVATE_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Kconfig b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Kconfig
new file mode 100644 (file)
index 0000000..7b6f836
--- /dev/null
@@ -0,0 +1,175 @@
+#
+# YAFFS file system configurations
+#
+
+config YAFFS_FS
+       tristate "YAFFS2 file system support"
+       default n
+       depends on MTD
+       select YAFFS_YAFFS1
+       select YAFFS_YAFFS2
+       help
+         YAFFS2, or Yet Another Flash Filing System, is a filing system
+         optimised for NAND Flash chips.
+
+         To compile the YAFFS2 file system support as a module, choose M
+         here: the module will be called yaffs2.
+
+         If unsure, say N.
+
+         Further information on YAFFS2 is available at
+         <http://www.aleph1.co.uk/yaffs/>.
+
+config YAFFS_YAFFS1
+       bool "512 byte / page devices"
+       depends on YAFFS_FS
+       default y
+       help
+         Enable YAFFS1 support -- yaffs for 512 byte / page devices
+
+         Not needed for 2K-page devices.
+
+         If unsure, say Y.
+
+config YAFFS_9BYTE_TAGS
+       bool "Use older-style on-NAND data format with pageStatus byte"
+       depends on YAFFS_YAFFS1
+       default n
+       help
+
+         Older-style on-NAND data format has a "pageStatus" byte to record
+         chunk/page state.  This byte is zero when the page is discarded.
+         Choose this option if you have existing on-NAND data using this
+         format that you need to continue to support.  New data written
+         also uses the older-style format.  Note: Use of this option
+         generally requires that MTD's oob layout be adjusted to use the
+         older-style format.  See notes on tags formats and MTD versions.
+
+         If unsure, say N.
+
+config YAFFS_DOES_ECC
+       bool "Lets Yaffs do its own ECC"
+       depends on YAFFS_FS && YAFFS_YAFFS1 && !YAFFS_9BYTE_TAGS
+       default n
+       help
+         This enables Yaffs to use its own ECC functions instead of using
+         the ones from the generic MTD-NAND driver.
+
+         If unsure, say N.
+
+config YAFFS_ECC_WRONG_ORDER
+       bool "Use the same ecc byte order as Steven Hill's nand_ecc.c"
+       depends on YAFFS_FS && YAFFS_DOES_ECC && !YAFFS_9BYTE_TAGS
+       default n
+       help
+         This makes yaffs_ecc.c use the same ecc byte order as Steven
+         Hill's nand_ecc.c. If not set, then you get the same ecc byte
+         order as SmartMedia.
+
+         If unsure, say N.
+
+config YAFFS_YAFFS2
+       bool "2048 byte (or larger) / page devices"
+       depends on YAFFS_FS
+       default y
+       help
+         Enable YAFFS2 support -- yaffs for >= 2K bytes per page devices
+
+         If unsure, say Y.
+
+config YAFFS_AUTO_YAFFS2
+       bool "Autoselect yaffs2 format"
+       depends on YAFFS_YAFFS2
+       default y
+       help
+         Without this, you need to explicitely use yaffs2 as the file
+         system type. With this, you can say "yaffs" and yaffs or yaffs2
+         will be used depending on the device page size (yaffs on
+         512-byte page devices, yaffs2 on 2K page devices).
+
+         If unsure, say Y.
+
+config YAFFS_DISABLE_LAZY_LOAD
+       bool "Disable lazy loading"
+       depends on YAFFS_YAFFS2
+       default n
+       help
+         "Lazy loading" defers loading file details until they are
+         required. This saves mount time, but makes the first look-up
+         a bit longer.
+
+         Lazy loading will only happen if enabled by this option being 'n'
+         and if the appropriate tags are available, else yaffs2 will
+         automatically fall back to immediate loading and do the right
+         thing.
+
+         Lazy laoding will be required by checkpointing.
+
+         Setting this to 'y' will disable lazy loading.
+
+         If unsure, say N.
+
+config YAFFS_CHECKPOINT_RESERVED_BLOCKS
+       int "Reserved blocks for checkpointing"
+       depends on YAFFS_YAFFS2
+       default 10
+       help
+          Give the number of Blocks to reserve for checkpointing.
+         Checkpointing saves the state at unmount so that mounting is
+         much faster as a scan of all the flash to regenerate this state
+         is not needed.  These Blocks are reserved per partition, so if
+         you have very small partitions the default (10) may be a mess
+         for you.  You can set this value to 0, but that does not mean
+         checkpointing is disabled at all. There only won't be any
+         specially reserved blocks for checkpointing, so if there is
+         enough free space on the filesystem, it will be used for
+         checkpointing.
+
+         If unsure, leave at default (10), but don't wonder if there are
+         always 2MB used on your large page device partition (10 x 2k
+         pagesize). When using small partitions or when being very small
+         on space, you probably want to set this to zero.
+
+config YAFFS_DISABLE_WIDE_TNODES
+       bool "Turn off wide tnodes"
+       depends on YAFFS_FS
+       default n
+       help
+         Wide tnodes are only used for NAND arrays >=32MB for 512-byte
+         page devices and >=128MB for 2k page devices. They use slightly
+         more RAM but are faster since they eliminate chunk group
+         searching.
+
+         Setting this to 'y' will force tnode width to 16 bits and save
+         memory but make large arrays slower.
+
+         If unsure, say N.
+
+config YAFFS_ALWAYS_CHECK_CHUNK_ERASED
+       bool "Force chunk erase check"
+       depends on YAFFS_FS
+       default n
+       help
+          Normally YAFFS only checks chunks before writing until an erased
+         chunk is found. This helps to detect any partially written
+         chunks that might have happened due to power loss.
+
+         Enabling this forces on the test that chunks are erased in flash
+         before writing to them. This takes more time but is potentially
+         a bit more secure.
+
+         Suggest setting Y during development and ironing out driver
+         issues etc. Suggest setting to N if you want faster writing.
+
+         If unsure, say Y.
+
+config YAFFS_SHORT_NAMES_IN_RAM
+       bool "Cache short names in RAM"
+       depends on YAFFS_FS
+       default y
+       help
+         If this config is set, then short names are stored with the
+         yaffs_Object.  This costs an extra 16 bytes of RAM per object,
+         but makes look-ups faster.
+
+         If unsure, say Y.
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Makefile b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/Makefile
new file mode 100644 (file)
index 0000000..73f4658
--- /dev/null
@@ -0,0 +1,11 @@
+#
+# Makefile for the linux YAFFS filesystem routines.
+#
+
+obj-$(CONFIG_YAFFS_FS) += yaffs.o
+
+yaffs-y := yaffs_ecc.o yaffs_fs.o yaffs_guts.o yaffs_checkptrw.o
+yaffs-y += yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
+yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o
+yaffs-y += yaffs_mtdif1.o yaffs_packedtags1.o
+yaffs-y += yaffs_mtdif.o yaffs_mtdif2.o
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/devextras.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/devextras.h
new file mode 100644 (file)
index 0000000..fcf2690
--- /dev/null
@@ -0,0 +1,264 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/*
+ * This file is just holds extra declarations used during development.
+ * Most of these are from kernel includes placed here so we can use them in
+ * applications.
+ *
+ */
+
+#ifndef __EXTRAS_H__
+#define __EXTRAS_H__
+
+#if defined WIN32
+#define __inline__ __inline
+#define new newHack
+#endif
+
+#if !(defined __KERNEL__) || (defined WIN32)
+
+/* User space defines */
+
+typedef unsigned char __u8;
+typedef unsigned short __u16;
+typedef unsigned __u32;
+
+/*
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+
+#define prefetch(x) 1
+
+struct list_head {
+       struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+       struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+       (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_add(struct list_head *new,
+                                 struct list_head *prev,
+                                 struct list_head *next)
+{
+       next->prev = new;
+       new->next = next;
+       new->prev = prev;
+       prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static __inline__ void list_add(struct list_head *new, struct list_head *head)
+{
+       __list_add(new, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static __inline__ void list_add_tail(struct list_head *new,
+                                    struct list_head *head)
+{
+       __list_add(new, head->prev, head);
+}
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static __inline__ void __list_del(struct list_head *prev,
+                                 struct list_head *next)
+{
+       next->prev = prev;
+       prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static __inline__ void list_del(struct list_head *entry)
+{
+       __list_del(entry->prev, entry->next);
+}
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static __inline__ void list_del_init(struct list_head *entry)
+{
+       __list_del(entry->prev, entry->next);
+       INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static __inline__ int list_empty(struct list_head *head)
+{
+       return head->next == head;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static __inline__ void list_splice(struct list_head *list,
+                                  struct list_head *head)
+{
+       struct list_head *first = list->next;
+
+       if (first != list) {
+               struct list_head *last = list->prev;
+               struct list_head *at = head->next;
+
+               first->prev = head;
+               head->next = first;
+
+               last->next = at;
+               at->prev = last;
+       }
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:       the &struct list_head pointer.
+ * @type:      the type of the struct this is embedded in.
+ * @member:    the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+       ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+
+/**
+ * list_for_each       -       iterate over a list
+ * @pos:       the &struct list_head to use as a loop counter.
+ * @head:      the head for your list.
+ */
+#define list_for_each(pos, head) \
+       for (pos = (head)->next, prefetch(pos->next); pos != (head); \
+               pos = pos->next, prefetch(pos->next))
+
+/**
+ * list_for_each_safe  -       iterate over a list safe against removal
+ *                              of list entry
+ * @pos:       the &struct list_head to use as a loop counter.
+ * @n:         another &struct list_head to use as temporary storage
+ * @head:      the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+       for (pos = (head)->next, n = pos->next; pos != (head); \
+               pos = n, n = pos->next)
+
+/*
+ * File types
+ */
+#define DT_UNKNOWN     0
+#define DT_FIFO                1
+#define DT_CHR         2
+#define DT_DIR         4
+#define DT_BLK         6
+#define DT_REG         8
+#define DT_LNK         10
+#define DT_SOCK                12
+#define DT_WHT         14
+
+#ifndef WIN32
+#include <sys/stat.h>
+#endif
+
+/*
+ * Attribute flags.  These should be or-ed together to figure out what
+ * has been changed!
+ */
+#define ATTR_MODE      1
+#define ATTR_UID       2
+#define ATTR_GID       4
+#define ATTR_SIZE      8
+#define ATTR_ATIME     16
+#define ATTR_MTIME     32
+#define ATTR_CTIME     64
+#define ATTR_ATIME_SET 128
+#define ATTR_MTIME_SET 256
+#define ATTR_FORCE     512     /* Not a change, but a change it */
+#define ATTR_ATTR_FLAG 1024
+
+struct iattr {
+       unsigned int ia_valid;
+       unsigned ia_mode;
+       unsigned ia_uid;
+       unsigned ia_gid;
+       unsigned ia_size;
+       unsigned ia_atime;
+       unsigned ia_mtime;
+       unsigned ia_ctime;
+       unsigned int ia_attr_flags;
+};
+
+#define KERN_DEBUG
+
+#else
+
+#ifndef WIN32
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+#include <linux/stat.h>
+#endif
+
+#endif
+
+#if defined WIN32
+#undef new
+#endif
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/moduleconfig.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/moduleconfig.h
new file mode 100644 (file)
index 0000000..016391c
--- /dev/null
@@ -0,0 +1,65 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Martin Fouts <Martin.Fouts@palmsource.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_CONFIG_H__
+#define __YAFFS_CONFIG_H__
+
+#ifdef YAFFS_OUT_OF_TREE
+
+/* DO NOT UNSET THESE THREE. YAFFS2 will not compile if you do. */
+#define CONFIG_YAFFS_FS
+#define CONFIG_YAFFS_YAFFS1
+#define CONFIG_YAFFS_YAFFS2
+
+/* These options are independent of each other.  Select those that matter. */
+
+/* Default: Not selected */
+/* Meaning: Yaffs does its own ECC, rather than using MTD ECC */
+//#define CONFIG_YAFFS_DOES_ECC
+
+/* Default: Not selected */
+/* Meaning: ECC byte order is 'wrong'.  Only meaningful if */
+/*          CONFIG_YAFFS_DOES_ECC is set */
+//#define CONFIG_YAFFS_ECC_WRONG_ORDER
+
+/* Default: Selected */
+/* Meaning: Disables testing whether chunks are erased before writing to them*/
+#define CONFIG_YAFFS_DISABLE_CHUNK_ERASED_CHECK
+
+/* Default: Selected */
+/* Meaning: Cache short names, taking more RAM, but faster look-ups */
+#define CONFIG_YAFFS_SHORT_NAMES_IN_RAM
+
+/* Default: 10 */
+/* Meaning: set the count of blocks to reserve for checkpointing */
+#define CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS 10
+
+/*
+Older-style on-NAND data format has a "pageStatus" byte to record
+chunk/page state.  This byte is zeroed when the page is discarded.
+Choose this option if you have existing on-NAND data in this format
+that you need to continue to support.  New data written also uses the
+older-style format.
+Note: Use of this option generally requires that MTD's oob layout be
+adjusted to use the older-style format.  See notes on tags formats and
+MTD versions.
+*/
+/* Default: Not selected */
+/* Meaning: Use older-style on-NAND data format with pageStatus byte */
+#define CONFIG_YAFFS_9BYTE_TAGS
+
+#endif /* YAFFS_OUT_OF_TREE */
+
+#endif /* __YAFFS_CONFIG_H__ */
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.c
new file mode 100644 (file)
index 0000000..933a33f
--- /dev/null
@@ -0,0 +1,404 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+const char *yaffs_checkptrw_c_version =
+    "$Id: yaffs_checkptrw.c,v 1.14 2007-05-15 20:07:40 charles Exp $";
+
+
+#include "yaffs_checkptrw.h"
+
+
+static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
+{
+
+       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
+
+       T(YAFFS_TRACE_CHECKPOINT,
+               (TSTR("checkpt blocks available = %d" TENDSTR),
+               blocksAvailable));
+
+
+       return (blocksAvailable <= 0) ? 0 : 1;
+}
+
+
+static int yaffs_CheckpointErase(yaffs_Device *dev)
+{
+
+       int i;
+
+
+       if(!dev->eraseBlockInNAND)
+               return 0;
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
+               dev->internalStartBlock,dev->internalEndBlock));
+
+       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
+               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
+               if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i));
+                       if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){
+                               bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
+                               dev->nErasedBlocks++;
+                               dev->nFreeChunks += dev->nChunksPerBlock;
+                       }
+                       else {
+                               dev->markNANDBlockBad(dev,i);
+                               bi->blockState = YAFFS_BLOCK_STATE_DEAD;
+                       }
+               }
+       }
+
+       dev->blocksInCheckpoint = 0;
+
+       return 1;
+}
+
+
+static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
+{
+       int  i;
+       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
+       T(YAFFS_TRACE_CHECKPOINT,
+               (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
+               dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
+
+       if(dev->checkpointNextBlock >= 0 &&
+          dev->checkpointNextBlock <= dev->internalEndBlock &&
+          blocksAvailable > 0){
+
+               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
+                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
+                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
+                               dev->checkpointNextBlock = i + 1;
+                               dev->checkpointCurrentBlock = i;
+                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i));
+                               return;
+                       }
+               }
+       }
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
+
+       dev->checkpointNextBlock = -1;
+       dev->checkpointCurrentBlock = -1;
+}
+
+static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
+{
+       int  i;
+       yaffs_ExtendedTags tags;
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
+               dev->blocksInCheckpoint, dev->checkpointNextBlock));
+
+       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
+               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
+                       int chunk = i * dev->nChunksPerBlock;
+                       int realignedChunk = chunk - dev->chunkOffset;
+
+                       dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
+                               i, tags.objectId,tags.sequenceNumber,tags.eccResult));
+
+                       if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
+                               /* Right kind of block */
+                               dev->checkpointNextBlock = tags.objectId;
+                               dev->checkpointCurrentBlock = i;
+                               dev->checkpointBlockList[dev->blocksInCheckpoint] = i;
+                               dev->blocksInCheckpoint++;
+                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i));
+                               return;
+                       }
+               }
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR)));
+
+       dev->checkpointNextBlock = -1;
+       dev->checkpointCurrentBlock = -1;
+}
+
+
+int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
+{
+
+       /* Got the functions we need? */
+       if (!dev->writeChunkWithTagsToNAND ||
+           !dev->readChunkWithTagsFromNAND ||
+           !dev->eraseBlockInNAND ||
+           !dev->markNANDBlockBad)
+               return 0;
+
+       if(forWriting && !yaffs_CheckpointSpaceOk(dev))
+               return 0;
+
+       if(!dev->checkpointBuffer)
+               dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
+       if(!dev->checkpointBuffer)
+               return 0;
+
+
+       dev->checkpointPageSequence = 0;
+
+       dev->checkpointOpenForWrite = forWriting;
+
+       dev->checkpointByteCount = 0;
+       dev->checkpointSum = 0;
+       dev->checkpointXor = 0;
+       dev->checkpointCurrentBlock = -1;
+       dev->checkpointCurrentChunk = -1;
+       dev->checkpointNextBlock = dev->internalStartBlock;
+
+       /* Erase all the blocks in the checkpoint area */
+       if(forWriting){
+               memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
+               dev->checkpointByteOffset = 0;
+               return yaffs_CheckpointErase(dev);
+
+
+       } else {
+               int i;
+               /* Set to a value that will kick off a read */
+               dev->checkpointByteOffset = dev->nDataBytesPerChunk;
+               /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
+                * going to be way more than we need */
+               dev->blocksInCheckpoint = 0;
+               dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2;
+               dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks);
+               for(i = 0; i < dev->checkpointMaxBlocks; i++)
+                       dev->checkpointBlockList[i] = -1;
+       }
+
+       return 1;
+}
+
+int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum)
+{
+       __u32 compositeSum;
+       compositeSum =  (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF);
+       *sum = compositeSum;
+       return 1;
+}
+
+static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
+{
+
+       int chunk;
+       int realignedChunk;
+
+       yaffs_ExtendedTags tags;
+
+       if(dev->checkpointCurrentBlock < 0){
+               yaffs_CheckpointFindNextErasedBlock(dev);
+               dev->checkpointCurrentChunk = 0;
+       }
+
+       if(dev->checkpointCurrentBlock < 0)
+               return 0;
+
+       tags.chunkDeleted = 0;
+       tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
+       tags.chunkId = dev->checkpointPageSequence + 1;
+       tags.sequenceNumber =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
+       tags.byteCount = dev->nDataBytesPerChunk;
+       if(dev->checkpointCurrentChunk == 0){
+               /* First chunk we write for the block? Set block state to
+                  checkpoint */
+               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock);
+               bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
+               dev->blocksInCheckpoint++;
+       }
+
+       chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
+
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
+               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
+
+       realignedChunk = chunk - dev->chunkOffset;
+
+       dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
+       dev->checkpointByteOffset = 0;
+       dev->checkpointPageSequence++;
+       dev->checkpointCurrentChunk++;
+       if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
+               dev->checkpointCurrentChunk = 0;
+               dev->checkpointCurrentBlock = -1;
+       }
+       memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
+
+       return 1;
+}
+
+
+int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
+{
+       int i=0;
+       int ok = 1;
+
+
+       __u8 * dataBytes = (__u8 *)data;
+
+
+
+       if(!dev->checkpointBuffer)
+               return 0;
+
+       if(!dev->checkpointOpenForWrite)
+               return -1;
+
+       while(i < nBytes && ok) {
+
+
+
+               dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
+               dev->checkpointSum += *dataBytes;
+               dev->checkpointXor ^= *dataBytes;
+
+               dev->checkpointByteOffset++;
+               i++;
+               dataBytes++;
+               dev->checkpointByteCount++;
+
+
+               if(dev->checkpointByteOffset < 0 ||
+                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
+                       ok = yaffs_CheckpointFlushBuffer(dev);
+
+       }
+
+       return  i;
+}
+
+int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
+{
+       int i=0;
+       int ok = 1;
+       yaffs_ExtendedTags tags;
+
+
+       int chunk;
+       int realignedChunk;
+
+       __u8 *dataBytes = (__u8 *)data;
+
+       if(!dev->checkpointBuffer)
+               return 0;
+
+       if(dev->checkpointOpenForWrite)
+               return -1;
+
+       while(i < nBytes && ok) {
+
+
+               if(dev->checkpointByteOffset < 0 ||
+                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
+
+                       if(dev->checkpointCurrentBlock < 0){
+                               yaffs_CheckpointFindNextCheckpointBlock(dev);
+                               dev->checkpointCurrentChunk = 0;
+                       }
+
+                       if(dev->checkpointCurrentBlock < 0)
+                               ok = 0;
+                       else {
+
+                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
+                                         dev->checkpointCurrentChunk;
+
+                               realignedChunk = chunk - dev->chunkOffset;
+
+                               /* read in the next chunk */
+                               /* printf("read checkpoint page %d\n",dev->checkpointPage); */
+                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
+                                                              dev->checkpointBuffer,
+                                                             &tags);
+
+                               if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
+                                  tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
+                                  ok = 0;
+
+                               dev->checkpointByteOffset = 0;
+                               dev->checkpointPageSequence++;
+                               dev->checkpointCurrentChunk++;
+
+                               if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
+                                       dev->checkpointCurrentBlock = -1;
+                       }
+               }
+
+               if(ok){
+                       *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
+                       dev->checkpointSum += *dataBytes;
+                       dev->checkpointXor ^= *dataBytes;
+                       dev->checkpointByteOffset++;
+                       i++;
+                       dataBytes++;
+                       dev->checkpointByteCount++;
+               }
+       }
+
+       return  i;
+}
+
+int yaffs_CheckpointClose(yaffs_Device *dev)
+{
+
+       if(dev->checkpointOpenForWrite){
+               if(dev->checkpointByteOffset != 0)
+                       yaffs_CheckpointFlushBuffer(dev);
+       } else {
+               int i;
+               for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){
+                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]);
+                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
+                               bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
+                       else {
+                               // Todo this looks odd...
+                       }
+               }
+               YFREE(dev->checkpointBlockList);
+               dev->checkpointBlockList = NULL;
+       }
+
+       dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
+       dev->nErasedBlocks -= dev->blocksInCheckpoint;
+
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
+                       dev->checkpointByteCount));
+
+       if(dev->checkpointBuffer){
+               /* free the buffer */
+               YFREE(dev->checkpointBuffer);
+               dev->checkpointBuffer = NULL;
+               return 1;
+       }
+       else
+               return 0;
+
+}
+
+int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
+{
+       /* Erase the first checksum block */
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR)));
+
+       if(!yaffs_CheckpointSpaceOk(dev))
+               return 0;
+
+       return yaffs_CheckpointErase(dev);
+}
+
+
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_checkptrw.h
new file mode 100644 (file)
index 0000000..d3ff174
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_CHECKPTRW_H__
+#define __YAFFS_CHECKPTRW_H__
+
+#include "yaffs_guts.h"
+
+int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting);
+
+int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes);
+
+int yaffs_CheckpointRead(yaffs_Device *dev,void *data, int nBytes);
+
+int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum);
+
+int yaffs_CheckpointClose(yaffs_Device *dev);
+
+int yaffs_CheckpointInvalidateStream(yaffs_Device *dev);
+
+
+#endif
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.c
new file mode 100644 (file)
index 0000000..e286039
--- /dev/null
@@ -0,0 +1,331 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This code implements the ECC algorithm used in SmartMedia.
+ *
+ * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
+ * The two unused bit are set to 1.
+ * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
+ * blocks are used on a 512-byte NAND page.
+ *
+ */
+
+/* Table generated by gen-ecc.c
+ * Using a table means we do not have to calculate p1..p4 and p1'..p4'
+ * for each byte of data. These are instead provided in a table in bits7..2.
+ * Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore
+ * this bytes influence on the line parity.
+ */
+
+const char *yaffs_ecc_c_version =
+    "$Id: yaffs_ecc.c,v 1.9 2007-02-14 01:09:06 wookey Exp $";
+
+#include "yportenv.h"
+
+#include "yaffs_ecc.h"
+
+static const unsigned char column_parity_table[] = {
+       0x00, 0x55, 0x59, 0x0c, 0x65, 0x30, 0x3c, 0x69,
+       0x69, 0x3c, 0x30, 0x65, 0x0c, 0x59, 0x55, 0x00,
+       0x95, 0xc0, 0xcc, 0x99, 0xf0, 0xa5, 0xa9, 0xfc,
+       0xfc, 0xa9, 0xa5, 0xf0, 0x99, 0xcc, 0xc0, 0x95,
+       0x99, 0xcc, 0xc0, 0x95, 0xfc, 0xa9, 0xa5, 0xf0,
+       0xf0, 0xa5, 0xa9, 0xfc, 0x95, 0xc0, 0xcc, 0x99,
+       0x0c, 0x59, 0x55, 0x00, 0x69, 0x3c, 0x30, 0x65,
+       0x65, 0x30, 0x3c, 0x69, 0x00, 0x55, 0x59, 0x0c,
+       0xa5, 0xf0, 0xfc, 0xa9, 0xc0, 0x95, 0x99, 0xcc,
+       0xcc, 0x99, 0x95, 0xc0, 0xa9, 0xfc, 0xf0, 0xa5,
+       0x30, 0x65, 0x69, 0x3c, 0x55, 0x00, 0x0c, 0x59,
+       0x59, 0x0c, 0x00, 0x55, 0x3c, 0x69, 0x65, 0x30,
+       0x3c, 0x69, 0x65, 0x30, 0x59, 0x0c, 0x00, 0x55,
+       0x55, 0x00, 0x0c, 0x59, 0x30, 0x65, 0x69, 0x3c,
+       0xa9, 0xfc, 0xf0, 0xa5, 0xcc, 0x99, 0x95, 0xc0,
+       0xc0, 0x95, 0x99, 0xcc, 0xa5, 0xf0, 0xfc, 0xa9,
+       0xa9, 0xfc, 0xf0, 0xa5, 0xcc, 0x99, 0x95, 0xc0,
+       0xc0, 0x95, 0x99, 0xcc, 0xa5, 0xf0, 0xfc, 0xa9,
+       0x3c, 0x69, 0x65, 0x30, 0x59, 0x0c, 0x00, 0x55,
+       0x55, 0x00, 0x0c, 0x59, 0x30, 0x65, 0x69, 0x3c,
+       0x30, 0x65, 0x69, 0x3c, 0x55, 0x00, 0x0c, 0x59,
+       0x59, 0x0c, 0x00, 0x55, 0x3c, 0x69, 0x65, 0x30,
+       0xa5, 0xf0, 0xfc, 0xa9, 0xc0, 0x95, 0x99, 0xcc,
+       0xcc, 0x99, 0x95, 0xc0, 0xa9, 0xfc, 0xf0, 0xa5,
+       0x0c, 0x59, 0x55, 0x00, 0x69, 0x3c, 0x30, 0x65,
+       0x65, 0x30, 0x3c, 0x69, 0x00, 0x55, 0x59, 0x0c,
+       0x99, 0xcc, 0xc0, 0x95, 0xfc, 0xa9, 0xa5, 0xf0,
+       0xf0, 0xa5, 0xa9, 0xfc, 0x95, 0xc0, 0xcc, 0x99,
+       0x95, 0xc0, 0xcc, 0x99, 0xf0, 0xa5, 0xa9, 0xfc,
+       0xfc, 0xa9, 0xa5, 0xf0, 0x99, 0xcc, 0xc0, 0x95,
+       0x00, 0x55, 0x59, 0x0c, 0x65, 0x30, 0x3c, 0x69,
+       0x69, 0x3c, 0x30, 0x65, 0x0c, 0x59, 0x55, 0x00,
+};
+
+/* Count the bits in an unsigned char or a U32 */
+
+static int yaffs_CountBits(unsigned char x)
+{
+       int r = 0;
+       while (x) {
+               if (x & 1)
+                       r++;
+               x >>= 1;
+       }
+       return r;
+}
+
+static int yaffs_CountBits32(unsigned x)
+{
+       int r = 0;
+       while (x) {
+               if (x & 1)
+                       r++;
+               x >>= 1;
+       }
+       return r;
+}
+
+/* Calculate the ECC for a 256-byte block of data */
+void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc)
+{
+       unsigned int i;
+
+       unsigned char col_parity = 0;
+       unsigned char line_parity = 0;
+       unsigned char line_parity_prime = 0;
+       unsigned char t;
+       unsigned char b;
+
+       for (i = 0; i < 256; i++) {
+               b = column_parity_table[*data++];
+               col_parity ^= b;
+
+               if (b & 0x01)   // odd number of bits in the byte
+               {
+                       line_parity ^= i;
+                       line_parity_prime ^= ~i;
+               }
+
+       }
+
+       ecc[2] = (~col_parity) | 0x03;
+
+       t = 0;
+       if (line_parity & 0x80)
+               t |= 0x80;
+       if (line_parity_prime & 0x80)
+               t |= 0x40;
+       if (line_parity & 0x40)
+               t |= 0x20;
+       if (line_parity_prime & 0x40)
+               t |= 0x10;
+       if (line_parity & 0x20)
+               t |= 0x08;
+       if (line_parity_prime & 0x20)
+               t |= 0x04;
+       if (line_parity & 0x10)
+               t |= 0x02;
+       if (line_parity_prime & 0x10)
+               t |= 0x01;
+       ecc[1] = ~t;
+
+       t = 0;
+       if (line_parity & 0x08)
+               t |= 0x80;
+       if (line_parity_prime & 0x08)
+               t |= 0x40;
+       if (line_parity & 0x04)
+               t |= 0x20;
+       if (line_parity_prime & 0x04)
+               t |= 0x10;
+       if (line_parity & 0x02)
+               t |= 0x08;
+       if (line_parity_prime & 0x02)
+               t |= 0x04;
+       if (line_parity & 0x01)
+               t |= 0x02;
+       if (line_parity_prime & 0x01)
+               t |= 0x01;
+       ecc[0] = ~t;
+
+#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
+       // Swap the bytes into the wrong order
+       t = ecc[0];
+       ecc[0] = ecc[1];
+       ecc[1] = t;
+#endif
+}
+
+
+/* Correct the ECC on a 256 byte block of data */
+
+int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
+                    const unsigned char *test_ecc)
+{
+       unsigned char d0, d1, d2;       /* deltas */
+
+       d0 = read_ecc[0] ^ test_ecc[0];
+       d1 = read_ecc[1] ^ test_ecc[1];
+       d2 = read_ecc[2] ^ test_ecc[2];
+
+       if ((d0 | d1 | d2) == 0)
+               return 0; /* no error */
+
+       if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 &&
+           ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 &&
+           ((d2 ^ (d2 >> 1)) & 0x54) == 0x54) {
+               /* Single bit (recoverable) error in data */
+
+               unsigned byte;
+               unsigned bit;
+
+#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
+               // swap the bytes to correct for the wrong order
+               unsigned char t;
+
+               t = d0;
+               d0 = d1;
+               d1 = t;
+#endif
+
+               bit = byte = 0;
+
+               if (d1 & 0x80)
+                       byte |= 0x80;
+               if (d1 & 0x20)
+                       byte |= 0x40;
+               if (d1 & 0x08)
+                       byte |= 0x20;
+               if (d1 & 0x02)
+                       byte |= 0x10;
+               if (d0 & 0x80)
+                       byte |= 0x08;
+               if (d0 & 0x20)
+                       byte |= 0x04;
+               if (d0 & 0x08)
+                       byte |= 0x02;
+               if (d0 & 0x02)
+                       byte |= 0x01;
+
+               if (d2 & 0x80)
+                       bit |= 0x04;
+               if (d2 & 0x20)
+                       bit |= 0x02;
+               if (d2 & 0x08)
+                       bit |= 0x01;
+
+               data[byte] ^= (1 << bit);
+
+               return 1; /* Corrected the error */
+       }
+
+       if ((yaffs_CountBits(d0) +
+            yaffs_CountBits(d1) +
+            yaffs_CountBits(d2)) ==  1) {
+               /* Reccoverable error in ecc */
+
+               read_ecc[0] = test_ecc[0];
+               read_ecc[1] = test_ecc[1];
+               read_ecc[2] = test_ecc[2];
+
+               return 1; /* Corrected the error */
+       }
+
+       /* Unrecoverable error */
+
+       return -1;
+
+}
+
+
+/*
+ * ECCxxxOther does ECC calcs on arbitrary n bytes of data
+ */
+void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
+                            yaffs_ECCOther * eccOther)
+{
+       unsigned int i;
+
+       unsigned char col_parity = 0;
+       unsigned line_parity = 0;
+       unsigned line_parity_prime = 0;
+       unsigned char b;
+
+       for (i = 0; i < nBytes; i++) {
+               b = column_parity_table[*data++];
+               col_parity ^= b;
+
+               if (b & 0x01)    {
+                       /* odd number of bits in the byte */
+                       line_parity ^= i;
+                       line_parity_prime ^= ~i;
+               }
+
+       }
+
+       eccOther->colParity = (col_parity >> 2) & 0x3f;
+       eccOther->lineParity = line_parity;
+       eccOther->lineParityPrime = line_parity_prime;
+}
+
+int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
+                         yaffs_ECCOther * read_ecc,
+                         const yaffs_ECCOther * test_ecc)
+{
+       unsigned char cDelta;   /* column parity delta */
+       unsigned lDelta;        /* line parity delta */
+       unsigned lDeltaPrime;   /* line parity delta */
+       unsigned bit;
+
+       cDelta = read_ecc->colParity ^ test_ecc->colParity;
+       lDelta = read_ecc->lineParity ^ test_ecc->lineParity;
+       lDeltaPrime = read_ecc->lineParityPrime ^ test_ecc->lineParityPrime;
+
+       if ((cDelta | lDelta | lDeltaPrime) == 0)
+               return 0; /* no error */
+
+       if (lDelta == ~lDeltaPrime &&
+           (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
+       {
+               /* Single bit (recoverable) error in data */
+
+               bit = 0;
+
+               if (cDelta & 0x20)
+                       bit |= 0x04;
+               if (cDelta & 0x08)
+                       bit |= 0x02;
+               if (cDelta & 0x02)
+                       bit |= 0x01;
+
+               if(lDelta >= nBytes)
+                       return -1;
+
+               data[lDelta] ^= (1 << bit);
+
+               return 1; /* corrected */
+       }
+
+       if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) +
+            yaffs_CountBits(cDelta)) == 1) {
+               /* Reccoverable error in ecc */
+
+               *read_ecc = *test_ecc;
+               return 1; /* corrected */
+       }
+
+       /* Unrecoverable error */
+
+       return -1;
+
+}
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_ecc.h
new file mode 100644 (file)
index 0000000..79bc3d1
--- /dev/null
@@ -0,0 +1,44 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+ /*
+  * This code implements the ECC algorithm used in SmartMedia.
+  *
+  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
+  * The two unused bit are set to 1.
+  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
+  * blocks are used on a 512-byte NAND page.
+  *
+  */
+
+#ifndef __YAFFS_ECC_H__
+#define __YAFFS_ECC_H__
+
+typedef struct {
+       unsigned char colParity;
+       unsigned lineParity;
+       unsigned lineParityPrime;
+} yaffs_ECCOther;
+
+void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc);
+int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
+                    const unsigned char *test_ecc);
+
+void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
+                            yaffs_ECCOther * ecc);
+int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
+                         yaffs_ECCOther * read_ecc,
+                         const yaffs_ECCOther * test_ecc);
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_fs.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_fs.c
new file mode 100644 (file)
index 0000000..67001b1
--- /dev/null
@@ -0,0 +1,2299 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ * Acknowledgements:
+ * Luc van OostenRyck for numerous patches.
+ * Nick Bane for numerous patches.
+ * Nick Bane for 2.5/2.6 integration.
+ * Andras Toth for mknod rdev issue.
+ * Michael Fischer for finding the problem with inode inconsistency.
+ * Some code bodily lifted from JFFS
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ *
+ * This is the file system front-end to YAFFS that hooks it up to
+ * the VFS.
+ *
+ * Special notes:
+ * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
+ *         this superblock
+ * >> 2.6: sb->s_fs_info  points to the yaffs_Device associated with this
+ *         superblock
+ * >> inode->u.generic_ip points to the associated yaffs_Object.
+ */
+
+const char *yaffs_fs_c_version =
+    "$Id: yaffs_fs.c,v 1.63 2007-09-19 20:35:40 imcd Exp $";
+extern const char *yaffs_guts_c_version;
+
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+#include <linux/config.h>
+#endif
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/fs.h>
+#include <linux/proc_fs.h>
+#include <linux/smp_lock.h>
+#include <linux/pagemap.h>
+#include <linux/mtd/mtd.h>
+#include <linux/interrupt.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+
+#include <linux/statfs.h>      /* Added NCB 15-8-2003 */
+#include <asm/statfs.h>
+#define UnlockPage(p) unlock_page(p)
+#define Page_Uptodate(page)    test_bit(PG_uptodate, &(page)->flags)
+
+/* FIXME: use sb->s_id instead ? */
+#define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf)
+
+#else
+
+#include <linux/locks.h>
+#define        BDEVNAME_SIZE           0
+#define        yaffs_devname(sb, buf)  kdevname(sb->s_dev)
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
+/* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */
+#define __user
+#endif
+
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+#define WRITE_SIZE_STR "writesize"
+#define WRITE_SIZE(mtd) (mtd)->writesize
+#else
+#define WRITE_SIZE_STR "oobblock"
+#define WRITE_SIZE(mtd) (mtd)->oobblock
+#endif
+
+#include <asm/uaccess.h>
+
+#include "yportenv.h"
+#include "yaffs_guts.h"
+
+#include <linux/mtd/mtd.h>
+#include "yaffs_mtdif.h"
+#include "yaffs_mtdif1.h"
+#include "yaffs_mtdif2.h"
+
+unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
+unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
+
+/* Module Parameters */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+module_param(yaffs_traceMask,uint,0644);
+module_param(yaffs_wr_attempts,uint,0644);
+#else
+MODULE_PARM(yaffs_traceMask,"i");
+MODULE_PARM(yaffs_wr_attempts,"i");
+#endif
+
+/*#define T(x) printk x */
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
+#define yaffs_InodeToObjectLV(iptr) (iptr)->i_private
+#else
+#define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip
+#endif
+
+#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr)))
+#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+#define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->s_fs_info)
+#else
+#define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->u.generic_sbp)
+#endif
+
+static void yaffs_put_super(struct super_block *sb);
+
+static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
+                               loff_t * pos);
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_file_flush(struct file *file, fl_owner_t id);
+#else
+static int yaffs_file_flush(struct file *file);
+#endif
+
+static int yaffs_sync_object(struct file *file, struct dentry *dentry,
+                            int datasync);
+
+static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
+                       struct nameidata *n);
+static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
+                                  struct nameidata *n);
+#else
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
+static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
+#endif
+static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
+                     struct dentry *dentry);
+static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
+static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
+                        const char *symname);
+static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+                      dev_t dev);
+#else
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+                      int dev);
+#endif
+static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
+                       struct inode *new_dir, struct dentry *new_dentry);
+static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_sync_fs(struct super_block *sb, int wait);
+static void yaffs_write_super(struct super_block *sb);
+#else
+static int yaffs_sync_fs(struct super_block *sb);
+static int yaffs_write_super(struct super_block *sb);
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf);
+#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
+#else
+static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
+#endif
+static void yaffs_read_inode(struct inode *inode);
+
+static void yaffs_put_inode(struct inode *inode);
+static void yaffs_delete_inode(struct inode *);
+static void yaffs_clear_inode(struct inode *);
+
+static int yaffs_readpage(struct file *file, struct page *page);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
+#else
+static int yaffs_writepage(struct page *page);
+#endif
+static int yaffs_prepare_write(struct file *f, struct page *pg,
+                              unsigned offset, unsigned to);
+static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
+                             unsigned to);
+
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
+#else
+static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
+#endif
+
+static struct address_space_operations yaffs_file_address_operations = {
+       .readpage = yaffs_readpage,
+       .writepage = yaffs_writepage,
+       .prepare_write = yaffs_prepare_write,
+       .commit_write = yaffs_commit_write,
+};
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
+static struct file_operations yaffs_file_operations = {
+       .read = do_sync_read,
+       .write = do_sync_write,
+       .aio_read = generic_file_aio_read,
+       .aio_write = generic_file_aio_write,
+       .mmap = generic_file_mmap,
+       .flush = yaffs_file_flush,
+       .fsync = yaffs_sync_object,
+       .splice_read = generic_file_splice_read,
+       .splice_write = generic_file_splice_write,
+};
+
+#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
+
+static struct file_operations yaffs_file_operations = {
+       .read = do_sync_read,
+       .write = do_sync_write,
+       .aio_read = generic_file_aio_read,
+       .aio_write = generic_file_aio_write,
+       .mmap = generic_file_mmap,
+       .flush = yaffs_file_flush,
+       .fsync = yaffs_sync_object,
+       .sendfile = generic_file_sendfile,
+};
+
+#else
+
+static struct file_operations yaffs_file_operations = {
+       .read = generic_file_read,
+       .write = generic_file_write,
+       .mmap = generic_file_mmap,
+       .flush = yaffs_file_flush,
+       .fsync = yaffs_sync_object,
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+       .sendfile = generic_file_sendfile,
+#endif
+};
+#endif
+
+static struct inode_operations yaffs_file_inode_operations = {
+       .setattr = yaffs_setattr,
+};
+
+static struct inode_operations yaffs_symlink_inode_operations = {
+       .readlink = yaffs_readlink,
+       .follow_link = yaffs_follow_link,
+       .setattr = yaffs_setattr,
+};
+
+static struct inode_operations yaffs_dir_inode_operations = {
+       .create = yaffs_create,
+       .lookup = yaffs_lookup,
+       .link = yaffs_link,
+       .unlink = yaffs_unlink,
+       .symlink = yaffs_symlink,
+       .mkdir = yaffs_mkdir,
+       .rmdir = yaffs_unlink,
+       .mknod = yaffs_mknod,
+       .rename = yaffs_rename,
+       .setattr = yaffs_setattr,
+};
+
+static struct file_operations yaffs_dir_operations = {
+       .read = generic_read_dir,
+       .readdir = yaffs_readdir,
+       .fsync = yaffs_sync_object,
+};
+
+static struct super_operations yaffs_super_ops = {
+       .statfs = yaffs_statfs,
+       .read_inode = yaffs_read_inode,
+       .put_inode = yaffs_put_inode,
+       .put_super = yaffs_put_super,
+       .delete_inode = yaffs_delete_inode,
+       .clear_inode = yaffs_clear_inode,
+       .sync_fs = yaffs_sync_fs,
+       .write_super = yaffs_write_super,
+};
+
+static void yaffs_GrossLock(yaffs_Device * dev)
+{
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
+
+       down(&dev->grossLock);
+}
+
+static void yaffs_GrossUnlock(yaffs_Device * dev)
+{
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
+       up(&dev->grossLock);
+
+}
+
+static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
+                         int buflen)
+{
+       unsigned char *alias;
+       int ret;
+
+       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
+
+       yaffs_GrossLock(dev);
+
+       alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
+
+       yaffs_GrossUnlock(dev);
+
+       if (!alias)
+               return -ENOMEM;
+
+       ret = vfs_readlink(dentry, buffer, buflen, alias);
+       kfree(alias);
+       return ret;
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
+#else
+static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
+#endif
+{
+       unsigned char *alias;
+       int ret;
+       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
+
+       yaffs_GrossLock(dev);
+
+       alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
+
+       yaffs_GrossUnlock(dev);
+
+       if (!alias)
+        {
+               ret = -ENOMEM;
+               goto out;
+        }
+
+       ret = vfs_follow_link(nd, alias);
+       kfree(alias);
+out:
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+       return ERR_PTR (ret);
+#else
+       return ret;
+#endif
+}
+
+struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
+                             yaffs_Object * obj);
+
+/*
+ * Lookup is used to find objects in the fs
+ */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+
+static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
+                                  struct nameidata *n)
+#else
+static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
+#endif
+{
+       yaffs_Object *obj;
+       struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
+
+       yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;
+
+       yaffs_GrossLock(dev);
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_lookup for %d:%s\n",
+          yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
+
+       obj =
+           yaffs_FindObjectByName(yaffs_InodeToObject(dir),
+                                  dentry->d_name.name);
+
+       obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
+
+       /* Can't hold gross lock when calling yaffs_get_inode() */
+       yaffs_GrossUnlock(dev);
+
+       if (obj) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
+
+               inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
+
+               if (inode) {
+                       T(YAFFS_TRACE_OS,
+                         (KERN_DEBUG "yaffs_loookup dentry \n"));
+/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
+ * d_add even if NULL inode */
+#if 0
+                       /*dget(dentry); // try to solve directory bug */
+                       d_add(dentry, inode);
+
+                       /* return dentry; */
+                       return NULL;
+#endif
+               }
+
+       } else {
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
+
+       }
+
+/* added NCB for 2.5/6 compatability - forces add even if inode is
+ * NULL which creates dentry hash */
+       d_add(dentry, inode);
+
+       return NULL;
+       /*      return (ERR_PTR(-EIO)); */
+
+}
+
+/* For now put inode is just for debugging
+ * Put inode is called when the inode **structure** is put.
+ */
+static void yaffs_put_inode(struct inode *inode)
+{
+       T(YAFFS_TRACE_OS,
+         ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
+          atomic_read(&inode->i_count)));
+
+}
+
+/* clear is called to tell the fs to release any per-inode data it holds */
+static void yaffs_clear_inode(struct inode *inode)
+{
+       yaffs_Object *obj;
+       yaffs_Device *dev;
+
+       obj = yaffs_InodeToObject(inode);
+
+       T(YAFFS_TRACE_OS,
+         ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));
+
+       if (obj) {
+               dev = obj->myDev;
+               yaffs_GrossLock(dev);
+
+               /* Clear the association between the inode and
+                * the yaffs_Object.
+                */
+               obj->myInode = NULL;
+               yaffs_InodeToObjectLV(inode) = NULL;
+
+               /* If the object freeing was deferred, then the real
+                * free happens now.
+                * This should fix the inode inconsistency problem.
+                */
+
+               yaffs_HandleDeferedFree(obj);
+
+               yaffs_GrossUnlock(dev);
+       }
+
+}
+
+/* delete is called when the link count is zero and the inode
+ * is put (ie. nobody wants to know about it anymore, time to
+ * delete the file).
+ * NB Must call clear_inode()
+ */
+static void yaffs_delete_inode(struct inode *inode)
+{
+       yaffs_Object *obj = yaffs_InodeToObject(inode);
+       yaffs_Device *dev;
+
+       T(YAFFS_TRACE_OS,
+         ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
+          atomic_read(&inode->i_count),
+          obj ? "object exists" : "null object"));
+
+       if (obj) {
+               dev = obj->myDev;
+               yaffs_GrossLock(dev);
+               yaffs_DeleteFile(obj);
+               yaffs_GrossUnlock(dev);
+       }
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
+        truncate_inode_pages (&inode->i_data, 0);
+#endif
+       clear_inode(inode);
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_file_flush(struct file *file, fl_owner_t id)
+#else
+static int yaffs_file_flush(struct file *file)
+#endif
+{
+       yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry);
+
+       yaffs_Device *dev = obj->myDev;
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
+          obj->dirty ? "dirty" : "clean"));
+
+       yaffs_GrossLock(dev);
+
+       yaffs_FlushFile(obj, 1);
+
+       yaffs_GrossUnlock(dev);
+
+       return 0;
+}
+
+static int yaffs_readpage_nolock(struct file *f, struct page *pg)
+{
+       /* Lifted from jffs2 */
+
+       yaffs_Object *obj;
+       unsigned char *pg_buf;
+       int ret;
+
+       yaffs_Device *dev;
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
+                          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
+                          (unsigned)PAGE_CACHE_SIZE));
+
+       obj = yaffs_DentryToObject(f->f_dentry);
+
+       dev = obj->myDev;
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+       BUG_ON(!PageLocked(pg));
+#else
+       if (!PageLocked(pg))
+               PAGE_BUG(pg);
+#endif
+
+       pg_buf = kmap(pg);
+       /* FIXME: Can kmap fail? */
+
+       yaffs_GrossLock(dev);
+
+       ret =
+           yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
+                                  PAGE_CACHE_SIZE);
+
+       yaffs_GrossUnlock(dev);
+
+       if (ret >= 0)
+               ret = 0;
+
+       if (ret) {
+               ClearPageUptodate(pg);
+               SetPageError(pg);
+       } else {
+               SetPageUptodate(pg);
+               ClearPageError(pg);
+       }
+
+       flush_dcache_page(pg);
+       kunmap(pg);
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
+       return ret;
+}
+
+static int yaffs_readpage_unlock(struct file *f, struct page *pg)
+{
+       int ret = yaffs_readpage_nolock(f, pg);
+       UnlockPage(pg);
+       return ret;
+}
+
+static int yaffs_readpage(struct file *f, struct page *pg)
+{
+       return yaffs_readpage_unlock(f, pg);
+}
+
+/* writepage inspired by/stolen from smbfs */
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
+#else
+static int yaffs_writepage(struct page *page)
+#endif
+{
+       struct address_space *mapping = page->mapping;
+       loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
+       struct inode *inode;
+       unsigned long end_index;
+       char *buffer;
+       yaffs_Object *obj;
+       int nWritten = 0;
+       unsigned nBytes;
+
+       if (!mapping)
+               BUG();
+       inode = mapping->host;
+       if (!inode)
+               BUG();
+
+       if (offset > inode->i_size) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG
+                  "yaffs_writepage at %08x, inode size = %08x!!!\n",
+                  (unsigned)(page->index << PAGE_CACHE_SHIFT),
+                  (unsigned)inode->i_size));
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "                -> don't care!!\n"));
+               unlock_page(page);
+               return 0;
+       }
+
+       end_index = inode->i_size >> PAGE_CACHE_SHIFT;
+
+       /* easy case */
+       if (page->index < end_index) {
+               nBytes = PAGE_CACHE_SIZE;
+       } else {
+               nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
+       }
+
+       get_page(page);
+
+       buffer = kmap(page);
+
+       obj = yaffs_InodeToObject(inode);
+       yaffs_GrossLock(obj->myDev);
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
+          (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
+          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
+
+       nWritten =
+           yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
+                                 nBytes, 0);
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
+          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
+
+       yaffs_GrossUnlock(obj->myDev);
+
+       kunmap(page);
+       SetPageUptodate(page);
+       UnlockPage(page);
+       put_page(page);
+
+       return (nWritten == nBytes) ? 0 : -ENOSPC;
+}
+
+static int yaffs_prepare_write(struct file *f, struct page *pg,
+                              unsigned offset, unsigned to)
+{
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
+       if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
+               return yaffs_readpage_nolock(f, pg);
+
+       return 0;
+
+}
+
+static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
+                             unsigned to)
+{
+
+       void *addr = page_address(pg) + offset;
+       loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
+       int nBytes = to - offset;
+       int nWritten;
+
+       unsigned spos = pos;
+       unsigned saddr = (unsigned)addr;
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
+          spos, nBytes));
+
+       nWritten = yaffs_file_write(f, addr, nBytes, &pos);
+
+       if (nWritten != nBytes) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG
+                  "yaffs_commit_write not same size nWritten %d  nBytes %d\n",
+                  nWritten, nBytes));
+               SetPageError(pg);
+               ClearPageUptodate(pg);
+       } else {
+               SetPageUptodate(pg);
+       }
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_commit_write returning %d\n",
+          nWritten == nBytes ? 0 : nWritten));
+
+       return nWritten == nBytes ? 0 : nWritten;
+
+}
+
+static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
+{
+       if (inode && obj) {
+
+
+               /* Check mode against the variant type and attempt to repair if broken. */
+               __u32 mode = obj->yst_mode;
+               switch( obj->variantType ){
+               case YAFFS_OBJECT_TYPE_FILE :
+                       if( ! S_ISREG(mode) ){
+                               obj->yst_mode &= ~S_IFMT;
+                               obj->yst_mode |= S_IFREG;
+                       }
+
+                       break;
+               case YAFFS_OBJECT_TYPE_SYMLINK :
+                       if( ! S_ISLNK(mode) ){
+                               obj->yst_mode &= ~S_IFMT;
+                               obj->yst_mode |= S_IFLNK;
+                       }
+
+                       break;
+               case YAFFS_OBJECT_TYPE_DIRECTORY :
+                       if( ! S_ISDIR(mode) ){
+                               obj->yst_mode &= ~S_IFMT;
+                               obj->yst_mode |= S_IFDIR;
+                       }
+
+                       break;
+               case YAFFS_OBJECT_TYPE_UNKNOWN :
+               case YAFFS_OBJECT_TYPE_HARDLINK :
+               case YAFFS_OBJECT_TYPE_SPECIAL :
+               default:
+                       /* TODO? */
+                       break;
+               }
+
+               inode->i_ino = obj->objectId;
+               inode->i_mode = obj->yst_mode;
+               inode->i_uid = obj->yst_uid;
+               inode->i_gid = obj->yst_gid;
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+               inode->i_blksize = inode->i_sb->s_blocksize;
+#endif
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+
+               inode->i_rdev = old_decode_dev(obj->yst_rdev);
+               inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
+               inode->i_atime.tv_nsec = 0;
+               inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
+               inode->i_mtime.tv_nsec = 0;
+               inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
+               inode->i_ctime.tv_nsec = 0;
+#else
+               inode->i_rdev = obj->yst_rdev;
+               inode->i_atime = obj->yst_atime;
+               inode->i_mtime = obj->yst_mtime;
+               inode->i_ctime = obj->yst_ctime;
+#endif
+               inode->i_size = yaffs_GetObjectFileLength(obj);
+               inode->i_blocks = (inode->i_size + 511) >> 9;
+
+               inode->i_nlink = yaffs_GetObjectLinkCount(obj);
+
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG
+                  "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
+                  inode->i_mode, inode->i_uid, inode->i_gid,
+                  (int)inode->i_size, atomic_read(&inode->i_count)));
+
+               switch (obj->yst_mode & S_IFMT) {
+               default:        /* fifo, device or socket */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+                       init_special_inode(inode, obj->yst_mode,
+                                          old_decode_dev(obj->yst_rdev));
+#else
+                       init_special_inode(inode, obj->yst_mode,
+                                          (dev_t) (obj->yst_rdev));
+#endif
+                       break;
+               case S_IFREG:   /* file */
+                       inode->i_op = &yaffs_file_inode_operations;
+                       inode->i_fop = &yaffs_file_operations;
+                       inode->i_mapping->a_ops =
+                           &yaffs_file_address_operations;
+                       break;
+               case S_IFDIR:   /* directory */
+                       inode->i_op = &yaffs_dir_inode_operations;
+                       inode->i_fop = &yaffs_dir_operations;
+                       break;
+               case S_IFLNK:   /* symlink */
+                       inode->i_op = &yaffs_symlink_inode_operations;
+                       break;
+               }
+
+               yaffs_InodeToObjectLV(inode) = obj;
+
+               obj->myInode = inode;
+
+       } else {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
+       }
+
+}
+
+struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
+                             yaffs_Object * obj)
+{
+       struct inode *inode;
+
+       if (!sb) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
+               return NULL;
+
+       }
+
+       if (!obj) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
+               return NULL;
+
+       }
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
+
+       inode = iget(sb, obj->objectId);
+
+       /* NB Side effect: iget calls back to yaffs_read_inode(). */
+       /* iget also increments the inode's i_count */
+       /* NB You can't be holding grossLock or deadlock will happen! */
+
+       return inode;
+}
+
+static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
+                               loff_t * pos)
+{
+       yaffs_Object *obj;
+       int nWritten, ipos;
+       struct inode *inode;
+       yaffs_Device *dev;
+
+       obj = yaffs_DentryToObject(f->f_dentry);
+
+       dev = obj->myDev;
+
+       yaffs_GrossLock(dev);
+
+       inode = f->f_dentry->d_inode;
+
+       if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
+               ipos = inode->i_size;
+       } else {
+               ipos = *pos;
+       }
+
+       if (!obj) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
+       } else {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG
+                  "yaffs_file_write about to write writing %d bytes"
+                  "to object %d at %d\n",
+                  n, obj->objectId, ipos));
+       }
+
+       nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
+          n, nWritten, ipos));
+       if (nWritten > 0) {
+               ipos += nWritten;
+               *pos = ipos;
+               if (ipos > inode->i_size) {
+                       inode->i_size = ipos;
+                       inode->i_blocks = (ipos + 511) >> 9;
+
+                       T(YAFFS_TRACE_OS,
+                         (KERN_DEBUG
+                          "yaffs_file_write size updated to %d bytes, "
+                          "%d blocks\n",
+                          ipos, (int)(inode->i_blocks)));
+               }
+
+       }
+       yaffs_GrossUnlock(dev);
+       return nWritten == 0 ? -ENOSPC : nWritten;
+}
+
+static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
+{
+       yaffs_Object *obj;
+       yaffs_Device *dev;
+       struct inode *inode = f->f_dentry->d_inode;
+       unsigned long offset, curoffs;
+       struct list_head *i;
+       yaffs_Object *l;
+
+       char name[YAFFS_MAX_NAME_LENGTH + 1];
+
+       obj = yaffs_DentryToObject(f->f_dentry);
+       dev = obj->myDev;
+
+       yaffs_GrossLock(dev);
+
+       offset = f->f_pos;
+
+       T(YAFFS_TRACE_OS, ("yaffs_readdir: starting at %d\n", (int)offset));
+
+       if (offset == 0) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
+                  (int)inode->i_ino));
+               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
+                   < 0) {
+                       goto out;
+               }
+               offset++;
+               f->f_pos++;
+       }
+       if (offset == 1) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
+                  (int)f->f_dentry->d_parent->d_inode->i_ino));
+               if (filldir
+                   (dirent, "..", 2, offset,
+                    f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
+                       goto out;
+               }
+               offset++;
+               f->f_pos++;
+       }
+
+       curoffs = 1;
+
+       /* If the directory has changed since the open or last call to
+          readdir, rewind to after the 2 canned entries. */
+
+       if (f->f_version != inode->i_version) {
+               offset = 2;
+               f->f_pos = offset;
+               f->f_version = inode->i_version;
+       }
+
+       list_for_each(i, &obj->variant.directoryVariant.children) {
+               curoffs++;
+               if (curoffs >= offset) {
+                       l = list_entry(i, yaffs_Object, siblings);
+
+                       yaffs_GetObjectName(l, name,
+                                           YAFFS_MAX_NAME_LENGTH + 1);
+                       T(YAFFS_TRACE_OS,
+                         (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
+                          yaffs_GetObjectInode(l)));
+
+                       if (filldir(dirent,
+                                   name,
+                                   strlen(name),
+                                   offset,
+                                   yaffs_GetObjectInode(l),
+                                   yaffs_GetObjectType(l))
+                           < 0) {
+                               goto up_and_out;
+                       }
+
+                       offset++;
+                       f->f_pos++;
+               }
+       }
+
+      up_and_out:
+      out:
+
+       yaffs_GrossUnlock(dev);
+
+       return 0;
+}
+
+/*
+ * File creation. Allocate an inode, and we're done..
+ */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+                      dev_t rdev)
+#else
+static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
+                      int rdev)
+#endif
+{
+       struct inode *inode;
+
+       yaffs_Object *obj = NULL;
+       yaffs_Device *dev;
+
+       yaffs_Object *parent = yaffs_InodeToObject(dir);
+
+       int error = -ENOSPC;
+       uid_t uid = current->fsuid;
+       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+
+       if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
+               mode |= S_ISGID;
+
+       if (parent) {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
+                  parent->objectId, parent->variantType));
+       } else {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
+               return -EPERM;
+       }
+
+       T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
+                          "mode %x dev %x\n",
+                          dentry->d_name.name, mode, rdev));
+
+       dev = parent->myDev;
+
+       yaffs_GrossLock(dev);
+
+       switch (mode & S_IFMT) {
+       default:
+               /* Special (socket, fifo, device...) */
+               T(YAFFS_TRACE_OS, (KERN_DEBUG
+                                  "yaffs_mknod: making special\n"));
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+               obj =
+                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
+                                      gid, old_encode_dev(rdev));
+#else
+               obj =
+                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
+                                      gid, rdev);
+#endif
+               break;
+       case S_IFREG:           /* file          */
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
+               obj =
+                   yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
+                                   gid);
+               break;
+       case S_IFDIR:           /* directory */
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_mknod: making directory\n"));
+               obj =
+                   yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
+                                        uid, gid);
+               break;
+       case S_IFLNK:           /* symlink */
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
+               obj = NULL;     /* Do we ever get here? */
+               break;
+       }
+
+       /* Can not call yaffs_get_inode() with gross lock held */
+       yaffs_GrossUnlock(dev);
+
+       if (obj) {
+               inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
+               d_instantiate(dentry, inode);
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
+                  obj->objectId, atomic_read(&inode->i_count)));
+               error = 0;
+       } else {
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_mknod failed making object\n"));
+               error = -ENOMEM;
+       }
+
+       return error;
+}
+
+static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+{
+       int retVal;
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
+       retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
+#if 0
+       /* attempt to fix dir bug - didn't work */
+       if (!retVal) {
+               dget(dentry);
+       }
+#endif
+       return retVal;
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
+                       struct nameidata *n)
+#else
+static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
+#endif
+{
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
+       return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
+}
+
+static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
+{
+       int retVal;
+
+       yaffs_Device *dev;
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
+          dentry->d_name.name));
+
+       dev = yaffs_InodeToObject(dir)->myDev;
+
+       yaffs_GrossLock(dev);
+
+       retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name);
+
+       if (retVal == YAFFS_OK) {
+               dentry->d_inode->i_nlink--;
+               dir->i_version++;
+               yaffs_GrossUnlock(dev);
+               mark_inode_dirty(dentry->d_inode);
+               return 0;
+       }
+       yaffs_GrossUnlock(dev);
+       return -ENOTEMPTY;
+}
+
+/*
+ * Create a link...
+ */
+static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
+                     struct dentry *dentry)
+{
+       struct inode *inode = old_dentry->d_inode;
+       yaffs_Object *obj = NULL;
+       yaffs_Object *link = NULL;
+       yaffs_Device *dev;
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
+
+       obj = yaffs_InodeToObject(inode);
+       dev = obj->myDev;
+
+       yaffs_GrossLock(dev);
+
+       if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
+       {
+               link =
+                   yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
+                              obj);
+       }
+
+       if (link) {
+               old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
+               d_instantiate(dentry, old_dentry->d_inode);
+               atomic_inc(&old_dentry->d_inode->i_count);
+               T(YAFFS_TRACE_OS,
+                 (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
+                  old_dentry->d_inode->i_nlink,
+                  atomic_read(&old_dentry->d_inode->i_count)));
+
+       }
+
+       yaffs_GrossUnlock(dev);
+
+       if (link) {
+
+               return 0;
+       }
+
+       return -EPERM;
+}
+
+static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
+                        const char *symname)
+{
+       yaffs_Object *obj;
+       yaffs_Device *dev;
+       uid_t uid = current->fsuid;
+       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
+
+       dev = yaffs_InodeToObject(dir)->myDev;
+       yaffs_GrossLock(dev);
+       obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
+                                S_IFLNK | S_IRWXUGO, uid, gid, symname);
+       yaffs_GrossUnlock(dev);
+
+       if (obj) {
+
+               struct inode *inode;
+
+               inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
+               d_instantiate(dentry, inode);
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
+               return 0;
+       } else {
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
+
+       }
+
+       return -ENOMEM;
+}
+
+static int yaffs_sync_object(struct file *file, struct dentry *dentry,
+                            int datasync)
+{
+
+       yaffs_Object *obj;
+       yaffs_Device *dev;
+
+       obj = yaffs_DentryToObject(dentry);
+
+       dev = obj->myDev;
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
+       yaffs_GrossLock(dev);
+       yaffs_FlushFile(obj, 1);
+       yaffs_GrossUnlock(dev);
+       return 0;
+}
+
+/*
+ * The VFS layer already does all the dentry stuff for rename.
+ *
+ * NB: POSIX says you can rename an object over an old object of the same name
+ */
+static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
+                       struct inode *new_dir, struct dentry *new_dentry)
+{
+       yaffs_Device *dev;
+       int retVal = YAFFS_FAIL;
+       yaffs_Object *target;
+
+        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
+       dev = yaffs_InodeToObject(old_dir)->myDev;
+
+       yaffs_GrossLock(dev);
+
+       /* Check if the target is an existing directory that is not empty. */
+       target =
+           yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
+                                  new_dentry->d_name.name);
+
+
+
+       if (target &&
+           target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
+           !list_empty(&target->variant.directoryVariant.children)) {
+
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
+
+               retVal = YAFFS_FAIL;
+       } else {
+
+               /* Now does unlinking internally using shadowing mechanism */
+               T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
+
+               retVal =
+                   yaffs_RenameObject(yaffs_InodeToObject(old_dir),
+                                      old_dentry->d_name.name,
+                                      yaffs_InodeToObject(new_dir),
+                                      new_dentry->d_name.name);
+
+       }
+       yaffs_GrossUnlock(dev);
+
+       if (retVal == YAFFS_OK) {
+               if(target) {
+                       new_dentry->d_inode->i_nlink--;
+                       mark_inode_dirty(new_dentry->d_inode);
+               }
+
+               return 0;
+       } else {
+               return -ENOTEMPTY;
+       }
+
+}
+
+static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
+{
+       struct inode *inode = dentry->d_inode;
+       int error;
+       yaffs_Device *dev;
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_setattr of object %d\n",
+          yaffs_InodeToObject(inode)->objectId));
+
+       if ((error = inode_change_ok(inode, attr)) == 0) {
+
+               dev = yaffs_InodeToObject(inode)->myDev;
+               yaffs_GrossLock(dev);
+               if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
+                   YAFFS_OK) {
+                       error = 0;
+               } else {
+                       error = -EPERM;
+               }
+               yaffs_GrossUnlock(dev);
+               if (!error)
+                       error = inode_setattr(inode, attr);
+       }
+       return error;
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
+       struct super_block *sb = dentry->d_sb;
+#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
+{
+       yaffs_Device *dev = yaffs_SuperToDevice(sb);
+#else
+static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
+{
+       yaffs_Device *dev = yaffs_SuperToDevice(sb);
+#endif
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
+
+       yaffs_GrossLock(dev);
+
+       buf->f_type = YAFFS_MAGIC;
+       buf->f_bsize = sb->s_blocksize;
+       buf->f_namelen = 255;
+       if (sb->s_blocksize > dev->nDataBytesPerChunk) {
+
+               buf->f_blocks =
+                   (dev->endBlock - dev->startBlock +
+                    1) * dev->nChunksPerBlock / (sb->s_blocksize /
+                                                 dev->nDataBytesPerChunk);
+               buf->f_bfree =
+                   yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
+                                                       dev->nDataBytesPerChunk);
+       } else {
+
+               buf->f_blocks =
+                   (dev->endBlock - dev->startBlock +
+                    1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
+                                                 sb->s_blocksize);
+               buf->f_bfree =
+                   yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
+                                                       sb->s_blocksize);
+       }
+       buf->f_files = 0;
+       buf->f_ffree = 0;
+       buf->f_bavail = buf->f_bfree;
+
+       yaffs_GrossUnlock(dev);
+       return 0;
+}
+
+
+/**
+static int yaffs_do_sync_fs(struct super_block *sb)
+{
+
+       yaffs_Device *dev = yaffs_SuperToDevice(sb);
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n"));
+
+       if(sb->s_dirt) {
+               yaffs_GrossLock(dev);
+
+               if(dev)
+                       yaffs_CheckpointSave(dev);
+
+               yaffs_GrossUnlock(dev);
+
+               sb->s_dirt = 0;
+       }
+       return 0;
+}
+**/
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static void yaffs_write_super(struct super_block *sb)
+#else
+static int yaffs_write_super(struct super_block *sb)
+#endif
+{
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
+       return 0; /* yaffs_do_sync_fs(sb);*/
+#endif
+}
+
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_sync_fs(struct super_block *sb, int wait)
+#else
+static int yaffs_sync_fs(struct super_block *sb)
+#endif
+{
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
+
+       return 0; /* yaffs_do_sync_fs(sb);*/
+
+}
+
+
+static void yaffs_read_inode(struct inode *inode)
+{
+       /* NB This is called as a side effect of other functions, but
+        * we had to release the lock to prevent deadlocks, so
+        * need to lock again.
+        */
+
+       yaffs_Object *obj;
+       yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
+
+       T(YAFFS_TRACE_OS,
+         (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
+
+       yaffs_GrossLock(dev);
+
+       obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
+
+       yaffs_FillInodeFromObject(inode, obj);
+
+       yaffs_GrossUnlock(dev);
+}
+
+static LIST_HEAD(yaffs_dev_list);
+
+#if 0 // not used
+static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
+{
+       yaffs_Device    *dev = yaffs_SuperToDevice(sb);
+
+       if( *flags & MS_RDONLY ) {
+               struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
+
+               T(YAFFS_TRACE_OS,
+                       (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
+
+               yaffs_GrossLock(dev);
+
+               yaffs_FlushEntireDeviceCache(dev);
+
+               yaffs_CheckpointSave(dev);
+
+               if (mtd->sync)
+                       mtd->sync(mtd);
+
+               yaffs_GrossUnlock(dev);
+       }
+       else {
+               T(YAFFS_TRACE_OS,
+                       (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
+       }
+
+       return 0;
+}
+#endif
+
+static void yaffs_put_super(struct super_block *sb)
+{
+       yaffs_Device *dev = yaffs_SuperToDevice(sb);
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
+
+       yaffs_GrossLock(dev);
+
+       yaffs_FlushEntireDeviceCache(dev);
+
+       yaffs_CheckpointSave(dev);
+
+       if (dev->putSuperFunc) {
+               dev->putSuperFunc(sb);
+       }
+
+       yaffs_Deinitialise(dev);
+
+       yaffs_GrossUnlock(dev);
+
+       /* we assume this is protected by lock_kernel() in mount/umount */
+       list_del(&dev->devList);
+
+       if(dev->spareBuffer){
+               YFREE(dev->spareBuffer);
+               dev->spareBuffer = NULL;
+       }
+
+       kfree(dev);
+}
+
+
+static void yaffs_MTDPutSuper(struct super_block *sb)
+{
+
+       struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
+
+       if (mtd->sync) {
+               mtd->sync(mtd);
+       }
+
+       put_mtd_device(mtd);
+}
+
+
+static void yaffs_MarkSuperBlockDirty(void *vsb)
+{
+       struct super_block *sb = (struct super_block *)vsb;
+
+       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
+//     if(sb)
+//             sb->s_dirt = 1;
+}
+
+typedef struct {
+       int inband_tags;
+       int skip_checkpoint_read;
+       int skip_checkpoint_write;
+       int no_cache;
+} yaffs_options;
+
+#define MAX_OPT_LEN 20
+static int yaffs_parse_options(yaffs_options *options, const char *options_str)
+{
+       char cur_opt[MAX_OPT_LEN+1];
+       int p;
+       int error = 0;
+
+       /* Parse through the options which is a comma seperated list */
+
+       while(options_str && *options_str && !error){
+               memset(cur_opt,0,MAX_OPT_LEN+1);
+               p = 0;
+
+               while(*options_str && *options_str != ','){
+                       if(p < MAX_OPT_LEN){
+                               cur_opt[p] = *options_str;
+                               p++;
+                       }
+                       options_str++;
+               }
+
+               if(!strcmp(cur_opt,"inband-tags"))
+                       options->inband_tags = 1;
+               else if(!strcmp(cur_opt,"no-cache"))
+                       options->no_cache = 1;
+               else if(!strcmp(cur_opt,"no-checkpoint-read"))
+                       options->skip_checkpoint_read = 1;
+               else if(!strcmp(cur_opt,"no-checkpoint-write"))
+                       options->skip_checkpoint_write = 1;
+               else if(!strcmp(cur_opt,"no-checkpoint")){
+                       options->skip_checkpoint_read = 1;
+                       options->skip_checkpoint_write = 1;
+               } else {
+                       printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
+                       error = 1;
+               }
+
+       }
+
+       return error;
+}
+
+static struct super_block *yaffs_internal_read_super(int yaffsVersion,
+                                                    struct super_block *sb,
+                                                    void *data, int silent)
+{
+       int nBlocks;
+       struct inode *inode = NULL;
+       struct dentry *root;
+       yaffs_Device *dev = 0;
+       char devname_buf[BDEVNAME_SIZE + 1];
+       struct mtd_info *mtd;
+       int err;
+       char *data_str = (char *)data;
+
+       yaffs_options options;
+
+       sb->s_magic = YAFFS_MAGIC;
+       sb->s_op = &yaffs_super_ops;
+
+       if (!sb)
+               printk(KERN_INFO "yaffs: sb is NULL\n");
+       else if (!sb->s_dev)
+               printk(KERN_INFO "yaffs: sb->s_dev is NULL\n");
+       else if (!yaffs_devname(sb, devname_buf))
+               printk(KERN_INFO "yaffs: devname is NULL\n");
+       else
+               printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
+                      sb->s_dev,
+                      yaffs_devname(sb, devname_buf));
+
+       if(!data_str)
+               data_str = "";
+
+       printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
+
+       memset(&options,0,sizeof(options));
+
+       if(yaffs_parse_options(&options,data_str)){
+               /* Option parsing failed */
+               return NULL;
+       }
+
+
+       sb->s_blocksize = PAGE_CACHE_SIZE;
+       sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+       T(YAFFS_TRACE_OS, ("yaffs_read_super: Using yaffs%d\n", yaffsVersion));
+       T(YAFFS_TRACE_OS,
+         ("yaffs_read_super: block size %d\n", (int)(sb->s_blocksize)));
+
+#ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
+       T(YAFFS_TRACE_OS,
+         ("yaffs: Write verification disabled. All guarantees "
+          "null and void\n"));
+#endif
+
+       T(YAFFS_TRACE_ALWAYS, ("yaffs: Attempting MTD mount on %u.%u, "
+                              "\"%s\"\n",
+                              MAJOR(sb->s_dev), MINOR(sb->s_dev),
+                              yaffs_devname(sb, devname_buf)));
+
+       /* Check it's an mtd device..... */
+       if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
+               return NULL;    /* This isn't an mtd device */
+       }
+       /* Get the device */
+       mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
+       if (!mtd) {
+               T(YAFFS_TRACE_ALWAYS,
+                 ("yaffs: MTD device #%u doesn't appear to exist\n",
+                  MINOR(sb->s_dev)));
+               return NULL;
+       }
+       /* Check it's NAND */
+       if (mtd->type != MTD_NANDFLASH) {
+               T(YAFFS_TRACE_ALWAYS,
+                 ("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
+               return NULL;
+       }
+
+       T(YAFFS_TRACE_OS, (" erase %p\n", mtd->erase));
+       T(YAFFS_TRACE_OS, (" read %p\n", mtd->read));
+       T(YAFFS_TRACE_OS, (" write %p\n", mtd->write));
+       T(YAFFS_TRACE_OS, (" readoob %p\n", mtd->read_oob));
+       T(YAFFS_TRACE_OS, (" writeoob %p\n", mtd->write_oob));
+       T(YAFFS_TRACE_OS, (" block_isbad %p\n", mtd->block_isbad));
+       T(YAFFS_TRACE_OS, (" block_markbad %p\n", mtd->block_markbad));
+       T(YAFFS_TRACE_OS, (" %s %d\n", WRITE_SIZE_STR, WRITE_SIZE(mtd)));
+       T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
+       T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
+       T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
+
+#ifdef CONFIG_YAFFS_AUTO_YAFFS2
+
+       if (yaffsVersion == 1 &&
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+           mtd->writesize >= 2048) {
+#else
+           mtd->oobblock >= 2048) {
+#endif
+           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
+           yaffsVersion = 2;
+       }
+
+       /* Added NCB 26/5/2006 for completeness */
+       if (yaffsVersion == 2 &&
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+           mtd->writesize == 512) {
+#else
+           mtd->oobblock == 512) {
+#endif
+           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
+           yaffsVersion = 1;
+       }
+
+#endif
+
+       if (yaffsVersion == 2) {
+               /* Check for version 2 style functions */
+               if (!mtd->erase ||
+                   !mtd->block_isbad ||
+                   !mtd->block_markbad ||
+                   !mtd->read ||
+                   !mtd->write ||
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+                   !mtd->read_oob || !mtd->write_oob) {
+#else
+                   !mtd->write_ecc ||
+                   !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
+#endif
+                       T(YAFFS_TRACE_ALWAYS,
+                         ("yaffs: MTD device does not support required "
+                          "functions\n"));;
+                       return NULL;
+               }
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+               if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
+#else
+               if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
+#endif
+                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
+                       T(YAFFS_TRACE_ALWAYS,
+                         ("yaffs: MTD device does not have the "
+                          "right page sizes\n"));
+                       return NULL;
+               }
+       } else {
+               /* Check for V1 style functions */
+               if (!mtd->erase ||
+                   !mtd->read ||
+                   !mtd->write ||
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+                   !mtd->read_oob || !mtd->write_oob) {
+#else
+                   !mtd->write_ecc ||
+                   !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
+#endif
+                       T(YAFFS_TRACE_ALWAYS,
+                         ("yaffs: MTD device does not support required "
+                          "functions\n"));;
+                       return NULL;
+               }
+
+               if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||
+                   mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
+                       T(YAFFS_TRACE_ALWAYS,
+                         ("yaffs: MTD device does not support have the "
+                          "right page sizes\n"));
+                       return NULL;
+               }
+       }
+
+       /* OK, so if we got here, we have an MTD that's NAND and looks
+        * like it has the right capabilities
+        * Set the yaffs_Device up for mtd
+        */
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+       sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
+#else
+       sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
+#endif
+       if (!dev) {
+               /* Deep shit could not allocate device structure */
+               T(YAFFS_TRACE_ALWAYS,
+                 ("yaffs_read_super: Failed trying to allocate "
+                  "yaffs_Device. \n"));
+               return NULL;
+       }
+
+       memset(dev, 0, sizeof(yaffs_Device));
+       dev->genericDevice = mtd;
+       dev->name = mtd->name;
+
+       /* Set up the memory size parameters.... */
+
+       nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
+       dev->startBlock = 0;
+       dev->endBlock = nBlocks - 1;
+       dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
+       dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
+       dev->nReservedBlocks = 5;
+       dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
+
+       /* ... and the functions. */
+       if (yaffsVersion == 2) {
+               dev->writeChunkWithTagsToNAND =
+                   nandmtd2_WriteChunkWithTagsToNAND;
+               dev->readChunkWithTagsFromNAND =
+                   nandmtd2_ReadChunkWithTagsFromNAND;
+               dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
+               dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
+               dev->spareBuffer = YMALLOC(mtd->oobsize);
+               dev->isYaffs2 = 1;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+               dev->nDataBytesPerChunk = mtd->writesize;
+               dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
+#else
+               dev->nDataBytesPerChunk = mtd->oobblock;
+               dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
+#endif
+               nBlocks = mtd->size / mtd->erasesize;
+
+               dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS;
+               dev->startBlock = 0;
+               dev->endBlock = nBlocks - 1;
+       } else {
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+               /* use the MTD interface in yaffs_mtdif1.c */
+               dev->writeChunkWithTagsToNAND =
+                       nandmtd1_WriteChunkWithTagsToNAND;
+               dev->readChunkWithTagsFromNAND =
+                       nandmtd1_ReadChunkWithTagsFromNAND;
+               dev->markNANDBlockBad = nandmtd1_MarkNANDBlockBad;
+               dev->queryNANDBlock = nandmtd1_QueryNANDBlock;
+#else
+               dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
+               dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
+#endif
+               dev->isYaffs2 = 0;
+       }
+       /* ... and common functions */
+       dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
+       dev->initialiseNAND = nandmtd_InitialiseNAND;
+
+       dev->putSuperFunc = yaffs_MTDPutSuper;
+
+       dev->superBlock = (void *)sb;
+       dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
+
+
+#ifndef CONFIG_YAFFS_DOES_ECC
+       dev->useNANDECC = 1;
+#endif
+
+#ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES
+       dev->wideTnodesDisabled = 1;
+#endif
+
+       dev->skipCheckpointRead = options.skip_checkpoint_read;
+       dev->skipCheckpointWrite = options.skip_checkpoint_write;
+
+       /* we assume this is protected by lock_kernel() in mount/umount */
+       list_add_tail(&dev->devList, &yaffs_dev_list);
+
+       init_MUTEX(&dev->grossLock);
+
+       yaffs_GrossLock(dev);
+
+       err = yaffs_GutsInitialise(dev);
+
+       T(YAFFS_TRACE_OS,
+         ("yaffs_read_super: guts initialised %s\n",
+          (err == YAFFS_OK) ? "OK" : "FAILED"));
+
+       /* Release lock before yaffs_get_inode() */
+       yaffs_GrossUnlock(dev);
+
+       /* Create root inode */
+       if (err == YAFFS_OK)
+               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,
+                                       yaffs_Root(dev));
+
+       if (!inode)
+               return NULL;
+
+       inode->i_op = &yaffs_dir_inode_operations;
+       inode->i_fop = &yaffs_dir_operations;
+
+       T(YAFFS_TRACE_OS, ("yaffs_read_super: got root inode\n"));
+
+       root = d_alloc_root(inode);
+
+       T(YAFFS_TRACE_OS, ("yaffs_read_super: d_alloc_root done\n"));
+
+       if (!root) {
+               iput(inode);
+               return NULL;
+       }
+       sb->s_root = root;
+
+       T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
+       return sb;
+}
+
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
+                                        int silent)
+{
+       return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs_read_super(struct file_system_type *fs,
+                           int flags, const char *dev_name,
+                           void *data, struct vfsmount *mnt)
+{
+
+       return get_sb_bdev(fs, flags, dev_name, data,
+                          yaffs_internal_read_super_mtd, mnt);
+}
+#else
+static struct super_block *yaffs_read_super(struct file_system_type *fs,
+                                           int flags, const char *dev_name,
+                                           void *data)
+{
+
+       return get_sb_bdev(fs, flags, dev_name, data,
+                          yaffs_internal_read_super_mtd);
+}
+#endif
+
+static struct file_system_type yaffs_fs_type = {
+       .owner = THIS_MODULE,
+       .name = "yaffs",
+       .get_sb = yaffs_read_super,
+       .kill_sb = kill_block_super,
+       .fs_flags = FS_REQUIRES_DEV,
+};
+#else
+static struct super_block *yaffs_read_super(struct super_block *sb, void *data,
+                                           int silent)
+{
+       return yaffs_internal_read_super(1, sb, data, silent);
+}
+
+static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super,
+                     FS_REQUIRES_DEV);
+#endif
+
+
+#ifdef CONFIG_YAFFS_YAFFS2
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
+                                         int silent)
+{
+       return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
+}
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static int yaffs2_read_super(struct file_system_type *fs,
+                       int flags, const char *dev_name, void *data,
+                       struct vfsmount *mnt)
+{
+       return get_sb_bdev(fs, flags, dev_name, data,
+                       yaffs2_internal_read_super_mtd, mnt);
+}
+#else
+static struct super_block *yaffs2_read_super(struct file_system_type *fs,
+                                            int flags, const char *dev_name,
+                                            void *data)
+{
+
+       return get_sb_bdev(fs, flags, dev_name, data,
+                          yaffs2_internal_read_super_mtd);
+}
+#endif
+
+static struct file_system_type yaffs2_fs_type = {
+       .owner = THIS_MODULE,
+       .name = "yaffs2",
+       .get_sb = yaffs2_read_super,
+       .kill_sb = kill_block_super,
+       .fs_flags = FS_REQUIRES_DEV,
+};
+#else
+static struct super_block *yaffs2_read_super(struct super_block *sb,
+                                            void *data, int silent)
+{
+       return yaffs_internal_read_super(2, sb, data, silent);
+}
+
+static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
+                     FS_REQUIRES_DEV);
+#endif
+
+#endif                         /* CONFIG_YAFFS_YAFFS2 */
+
+static struct proc_dir_entry *my_proc_entry;
+
+static char *yaffs_dump_dev(char *buf, yaffs_Device * dev)
+{
+       buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
+       buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
+       buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
+       buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
+       buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
+       buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
+       buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
+       buf += sprintf(buf, "nCheckptResBlocks.. %d\n", dev->nCheckpointReservedBlocks);
+       buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
+       buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
+       buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
+       buf += sprintf(buf, "nObjectsCreated.... %d\n", dev->nObjectsCreated);
+       buf += sprintf(buf, "nFreeObjects....... %d\n", dev->nFreeObjects);
+       buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks);
+       buf += sprintf(buf, "nPageWrites........ %d\n", dev->nPageWrites);
+       buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
+       buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
+       buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
+       buf +=
+           sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
+       buf +=
+           sprintf(buf, "passiveGCs......... %d\n",
+                   dev->passiveGarbageCollections);
+       buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
+       buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
+       buf += sprintf(buf, "nRetireBlocks...... %d\n", dev->nRetiredBlocks);
+       buf += sprintf(buf, "eccFixed........... %d\n", dev->eccFixed);
+       buf += sprintf(buf, "eccUnfixed......... %d\n", dev->eccUnfixed);
+       buf += sprintf(buf, "tagsEccFixed....... %d\n", dev->tagsEccFixed);
+       buf += sprintf(buf, "tagsEccUnfixed..... %d\n", dev->tagsEccUnfixed);
+       buf += sprintf(buf, "cacheHits.......... %d\n", dev->cacheHits);
+       buf += sprintf(buf, "nDeletedFiles...... %d\n", dev->nDeletedFiles);
+       buf += sprintf(buf, "nUnlinkedFiles..... %d\n", dev->nUnlinkedFiles);
+       buf +=
+           sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
+       buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
+       buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
+
+       return buf;
+}
+
+static int yaffs_proc_read(char *page,
+                          char **start,
+                          off_t offset, int count, int *eof, void *data)
+{
+       struct list_head *item;
+       char *buf = page;
+       int step = offset;
+       int n = 0;
+
+       /* Get proc_file_read() to step 'offset' by one on each sucessive call.
+        * We use 'offset' (*ppos) to indicate where we are in devList.
+        * This also assumes the user has posted a read buffer large
+        * enough to hold the complete output; but that's life in /proc.
+        */
+
+       *(int *)start = 1;
+
+       /* Print header first */
+       if (step == 0) {
+               buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__
+                              "\n%s\n%s\n", yaffs_fs_c_version,
+                              yaffs_guts_c_version);
+       }
+
+       /* hold lock_kernel while traversing yaffs_dev_list */
+       lock_kernel();
+
+       /* Locate and print the Nth entry.  Order N-squared but N is small. */
+       list_for_each(item, &yaffs_dev_list) {
+               yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
+               if (n < step) {
+                       n++;
+                       continue;
+               }
+               buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->name);
+               buf = yaffs_dump_dev(buf, dev);
+               break;
+       }
+       unlock_kernel();
+
+       return buf - page < count ? buf - page : count;
+}
+
+/**
+ * Set the verbosity of the warnings and error messages.
+ *
+ * Note that the names can only be a..z or _ with the current code.
+ */
+
+static struct {
+       char *mask_name;
+       unsigned mask_bitfield;
+} mask_flags[] = {
+       {"allocate", YAFFS_TRACE_ALLOCATE},
+       {"always", YAFFS_TRACE_ALWAYS},
+       {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
+       {"buffers", YAFFS_TRACE_BUFFERS},
+       {"bug", YAFFS_TRACE_BUG},
+       {"checkpt", YAFFS_TRACE_CHECKPOINT},
+       {"deletion", YAFFS_TRACE_DELETION},
+       {"erase", YAFFS_TRACE_ERASE},
+       {"error", YAFFS_TRACE_ERROR},
+       {"gc_detail", YAFFS_TRACE_GC_DETAIL},
+       {"gc", YAFFS_TRACE_GC},
+       {"mtd", YAFFS_TRACE_MTD},
+       {"nandaccess", YAFFS_TRACE_NANDACCESS},
+       {"os", YAFFS_TRACE_OS},
+       {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
+       {"scan", YAFFS_TRACE_SCAN},
+       {"tracing", YAFFS_TRACE_TRACING},
+
+       {"verify", YAFFS_TRACE_VERIFY},
+       {"verify_nand", YAFFS_TRACE_VERIFY_NAND},
+       {"verify_full", YAFFS_TRACE_VERIFY_FULL},
+       {"verify_all", YAFFS_TRACE_VERIFY_ALL},
+
+       {"write", YAFFS_TRACE_WRITE},
+       {"all", 0xffffffff},
+       {"none", 0},
+       {NULL, 0},
+};
+
+#define MAX_MASK_NAME_LENGTH 40
+static int yaffs_proc_write(struct file *file, const char *buf,
+                                        unsigned long count, void *data)
+{
+       unsigned rg = 0, mask_bitfield;
+       char *end;
+       char *mask_name;
+       const char *x;
+       char substring[MAX_MASK_NAME_LENGTH+1];
+       int i;
+       int done = 0;
+       int add, len = 0;
+       int pos = 0;
+
+       rg = yaffs_traceMask;
+
+       while (!done && (pos < count)) {
+               done = 1;
+               while ((pos < count) && isspace(buf[pos])) {
+                       pos++;
+               }
+
+               switch (buf[pos]) {
+               case '+':
+               case '-':
+               case '=':
+                       add = buf[pos];
+                       pos++;
+                       break;
+
+               default:
+                       add = ' ';
+                       break;
+               }
+               mask_name = NULL;
+
+               mask_bitfield = simple_strtoul(buf + pos, &end, 0);
+               if (end > buf + pos) {
+                       mask_name = "numeral";
+                       len = end - (buf + pos);
+                       pos += len;
+                       done = 0;
+               } else {
+                       for(x = buf + pos, i = 0;
+                           (*x == '_' || (*x >='a' && *x <= 'z')) &&
+                           i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
+                           substring[i] = *x;
+                       substring[i] = '\0';
+
+                       for (i = 0; mask_flags[i].mask_name != NULL; i++) {
+                               if(strcmp(substring,mask_flags[i].mask_name) == 0){
+                                       mask_name = mask_flags[i].mask_name;
+                                       mask_bitfield = mask_flags[i].mask_bitfield;
+                                       done = 0;
+                                       break;
+                               }
+                       }
+               }
+
+               if (mask_name != NULL) {
+                       done = 0;
+                       switch(add) {
+                       case '-':
+                               rg &= ~mask_bitfield;
+                               break;
+                       case '+':
+                               rg |= mask_bitfield;
+                               break;
+                       case '=':
+                               rg = mask_bitfield;
+                               break;
+                       default:
+                               rg |= mask_bitfield;
+                               break;
+                       }
+               }
+       }
+
+       yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
+
+       printk("new trace = 0x%08X\n",yaffs_traceMask);
+
+       if (rg & YAFFS_TRACE_ALWAYS) {
+               for (i = 0; mask_flags[i].mask_name != NULL; i++) {
+                       char flag;
+                       flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
+                       printk("%c%s\n", flag, mask_flags[i].mask_name);
+               }
+       }
+
+       return count;
+}
+
+/* Stuff to handle installation of file systems */
+struct file_system_to_install {
+       struct file_system_type *fst;
+       int installed;
+};
+
+static struct file_system_to_install fs_to_install[] = {
+//#ifdef CONFIG_YAFFS_YAFFS1
+       {&yaffs_fs_type, 0},
+//#endif
+//#ifdef CONFIG_YAFFS_YAFFS2
+       {&yaffs2_fs_type, 0},
+//#endif
+       {NULL, 0}
+};
+
+static int __init init_yaffs_fs(void)
+{
+       int error = 0;
+       struct file_system_to_install *fsinst;
+
+       T(YAFFS_TRACE_ALWAYS,
+         ("yaffs " __DATE__ " " __TIME__ " Installing. \n"));
+
+       /* Install the proc_fs entry */
+       my_proc_entry = create_proc_entry("yaffs",
+                                              S_IRUGO | S_IFREG,
+                                              &proc_root);
+
+       if (my_proc_entry) {
+               my_proc_entry->write_proc = yaffs_proc_write;
+               my_proc_entry->read_proc = yaffs_proc_read;
+               my_proc_entry->data = NULL;
+       } else {
+               return -ENOMEM;
+       }
+
+       /* Now add the file system entries */
+
+       fsinst = fs_to_install;
+
+       while (fsinst->fst && !error) {
+               error = register_filesystem(fsinst->fst);
+               if (!error) {
+                       fsinst->installed = 1;
+               }
+               fsinst++;
+       }
+
+       /* Any errors? uninstall  */
+       if (error) {
+               fsinst = fs_to_install;
+
+               while (fsinst->fst) {
+                       if (fsinst->installed) {
+                               unregister_filesystem(fsinst->fst);
+                               fsinst->installed = 0;
+                       }
+                       fsinst++;
+               }
+       }
+
+       return error;
+}
+
+static void __exit exit_yaffs_fs(void)
+{
+
+       struct file_system_to_install *fsinst;
+
+       T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
+                              " removing. \n"));
+
+       remove_proc_entry("yaffs", &proc_root);
+
+       fsinst = fs_to_install;
+
+       while (fsinst->fst) {
+               if (fsinst->installed) {
+                       unregister_filesystem(fsinst->fst);
+                       fsinst->installed = 0;
+               }
+               fsinst++;
+       }
+
+}
+
+module_init(init_yaffs_fs)
+module_exit(exit_yaffs_fs)
+
+MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
+MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006");
+MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.c
new file mode 100644 (file)
index 0000000..2ab8146
--- /dev/null
@@ -0,0 +1,7469 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+const char *yaffs_guts_c_version =
+    "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
+
+#include "yportenv.h"
+
+#include "yaffsinterface.h"
+#include "yaffs_guts.h"
+#include "yaffs_tagsvalidity.h"
+
+#include "yaffs_tagscompat.h"
+#ifndef  CONFIG_YAFFS_USE_OWN_SORT
+#include "yaffs_qsort.h"
+#endif
+#include "yaffs_nand.h"
+
+#include "yaffs_checkptrw.h"
+
+#include "yaffs_nand.h"
+#include "yaffs_packedtags2.h"
+
+
+#ifdef CONFIG_YAFFS_WINCE
+void yfsd_LockYAFFS(BOOL fsLockOnly);
+void yfsd_UnlockYAFFS(BOOL fsLockOnly);
+#endif
+
+#define YAFFS_PASSIVE_GC_CHUNKS 2
+
+#include "yaffs_ecc.h"
+
+
+/* Robustification (if it ever comes about...) */
+static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND);
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk);
+static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
+                                    const __u8 * data,
+                                    const yaffs_ExtendedTags * tags);
+static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
+                                   const yaffs_ExtendedTags * tags);
+
+/* Other local prototypes */
+static int yaffs_UnlinkObject( yaffs_Object *obj);
+static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj);
+
+static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList);
+
+static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device * dev,
+                                            const __u8 * buffer,
+                                            yaffs_ExtendedTags * tags,
+                                            int useReserve);
+static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
+                                 int chunkInNAND, int inScan);
+
+static yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
+                                          yaffs_ObjectType type);
+static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
+                                      yaffs_Object * obj);
+static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name,
+                                   int force, int isShrink, int shadows);
+static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj);
+static int yaffs_CheckStructures(void);
+static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
+                             int chunkOffset, int *limit);
+static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
+
+static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
+
+static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
+static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
+                                   int lineNo);
+
+static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
+                                 int chunkInNAND);
+
+static int yaffs_UnlinkWorker(yaffs_Object * obj);
+static void yaffs_DestroyObject(yaffs_Object * obj);
+
+static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
+                          int chunkInObject);
+
+loff_t yaffs_GetFileSize(yaffs_Object * obj);
+
+static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr);
+
+static void yaffs_VerifyFreeChunks(yaffs_Device * dev);
+
+static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in);
+
+#ifdef YAFFS_PARANOID
+static int yaffs_CheckFileSanity(yaffs_Object * in);
+#else
+#define yaffs_CheckFileSanity(in)
+#endif
+
+static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in);
+static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId);
+
+static void yaffs_InvalidateCheckpoint(yaffs_Device *dev);
+
+static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
+                                yaffs_ExtendedTags * tags);
+
+static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
+static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
+                                         yaffs_FileStructure * fStruct,
+                                         __u32 chunkId);
+
+
+/* Function to calculate chunk and offset */
+
+static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
+{
+       if(dev->chunkShift){
+               /* Easy-peasy power of 2 case */
+               *chunk  = (__u32)(addr >> dev->chunkShift);
+               *offset = (__u32)(addr & dev->chunkMask);
+       }
+       else if(dev->crumbsPerChunk)
+       {
+               /* Case where we're using "crumbs" */
+               *offset = (__u32)(addr & dev->crumbMask);
+               addr >>= dev->crumbShift;
+               *chunk = ((__u32)addr)/dev->crumbsPerChunk;
+               *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
+       }
+       else
+               YBUG();
+}
+
+/* Function to return the number of shifts for a power of 2 greater than or equal
+ * to the given number
+ * Note we don't try to cater for all possible numbers and this does not have to
+ * be hellishly efficient.
+ */
+
+static __u32 ShiftsGE(__u32 x)
+{
+       int extraBits;
+       int nShifts;
+
+       nShifts = extraBits = 0;
+
+       while(x>1){
+               if(x & 1) extraBits++;
+               x>>=1;
+               nShifts++;
+       }
+
+       if(extraBits)
+               nShifts++;
+
+       return nShifts;
+}
+
+/* Function to return the number of shifts to get a 1 in bit 0
+ */
+
+static __u32 ShiftDiv(__u32 x)
+{
+       int nShifts;
+
+       nShifts =  0;
+
+       if(!x) return 0;
+
+       while( !(x&1)){
+               x>>=1;
+               nShifts++;
+       }
+
+       return nShifts;
+}
+
+
+
+/*
+ * Temporary buffer manipulations.
+ */
+
+static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
+{
+       int i;
+       __u8 *buf = (__u8 *)1;
+
+       memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
+
+       for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
+               dev->tempBuffer[i].line = 0;    /* not in use */
+               dev->tempBuffer[i].buffer = buf =
+                   YMALLOC_DMA(dev->nDataBytesPerChunk);
+       }
+
+       return buf ? YAFFS_OK : YAFFS_FAIL;
+
+}
+
+static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
+{
+       int i, j;
+       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+               if (dev->tempBuffer[i].line == 0) {
+                       dev->tempBuffer[i].line = lineNo;
+                       if ((i + 1) > dev->maxTemp) {
+                               dev->maxTemp = i + 1;
+                               for (j = 0; j <= i; j++)
+                                       dev->tempBuffer[j].maxLine =
+                                           dev->tempBuffer[j].line;
+                       }
+
+                       return dev->tempBuffer[i].buffer;
+               }
+       }
+
+       T(YAFFS_TRACE_BUFFERS,
+         (TSTR("Out of temp buffers at line %d, other held by lines:"),
+          lineNo));
+       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+               T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line));
+       }
+       T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
+
+       /*
+        * If we got here then we have to allocate an unmanaged one
+        * This is not good.
+        */
+
+       dev->unmanagedTempAllocations++;
+       return YMALLOC(dev->nDataBytesPerChunk);
+
+}
+
+static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
+                                   int lineNo)
+{
+       int i;
+       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+               if (dev->tempBuffer[i].buffer == buffer) {
+                       dev->tempBuffer[i].line = 0;
+                       return;
+               }
+       }
+
+       if (buffer) {
+               /* assume it is an unmanaged one. */
+               T(YAFFS_TRACE_BUFFERS,
+                 (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
+                  lineNo));
+               YFREE(buffer);
+               dev->unmanagedTempDeallocations++;
+       }
+
+}
+
+/*
+ * Determine if we have a managed buffer.
+ */
+int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
+{
+       int i;
+       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+               if (dev->tempBuffer[i].buffer == buffer)
+                       return 1;
+
+       }
+
+    for (i = 0; i < dev->nShortOpCaches; i++) {
+        if( dev->srCache[i].data == buffer )
+            return 1;
+
+    }
+
+    if (buffer == dev->checkpointBuffer)
+      return 1;
+
+    T(YAFFS_TRACE_ALWAYS,
+         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
+    return 0;
+}
+
+
+
+/*
+ * Chunk bitmap manipulations
+ */
+
+static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device * dev, int blk)
+{
+       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
+                  blk));
+               YBUG();
+       }
+       return dev->chunkBits +
+           (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
+}
+
+static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk)
+{
+       if(blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
+          chunk < 0 || chunk >= dev->nChunksPerBlock) {
+          T(YAFFS_TRACE_ERROR,
+           (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),blk,chunk));
+           YBUG();
+       }
+}
+
+static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device * dev, int blk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+
+       memset(blkBits, 0, dev->chunkBitmapStride);
+}
+
+static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+
+       yaffs_VerifyChunkBitId(dev,blk,chunk);
+
+       blkBits[chunk / 8] &= ~(1 << (chunk & 7));
+}
+
+static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+
+       yaffs_VerifyChunkBitId(dev,blk,chunk);
+
+       blkBits[chunk / 8] |= (1 << (chunk & 7));
+}
+
+static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device * dev, int blk, int chunk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+       yaffs_VerifyChunkBitId(dev,blk,chunk);
+
+       return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
+}
+
+static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device * dev, int blk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+       int i;
+       for (i = 0; i < dev->chunkBitmapStride; i++) {
+               if (*blkBits)
+                       return 1;
+               blkBits++;
+       }
+       return 0;
+}
+
+static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
+{
+       __u8 *blkBits = yaffs_BlockBits(dev, blk);
+       int i;
+       int n = 0;
+       for (i = 0; i < dev->chunkBitmapStride; i++) {
+               __u8 x = *blkBits;
+               while(x){
+                       if(x & 1)
+                               n++;
+                       x >>=1;
+               }
+
+               blkBits++;
+       }
+       return n;
+}
+
+/*
+ * Verification code
+ */
+
+static int yaffs_SkipVerification(yaffs_Device *dev)
+{
+       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
+}
+
+static int yaffs_SkipFullVerification(yaffs_Device *dev)
+{
+       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
+}
+
+static int yaffs_SkipNANDVerification(yaffs_Device *dev)
+{
+       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
+}
+
+static const char * blockStateName[] = {
+"Unknown",
+"Needs scanning",
+"Scanning",
+"Empty",
+"Allocating",
+"Full",
+"Dirty",
+"Checkpoint",
+"Collecting",
+"Dead"
+};
+
+static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
+{
+       int actuallyUsed;
+       int inUse;
+
+       if(yaffs_SkipVerification(dev))
+               return;
+
+       /* Report illegal runtime states */
+       if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
+               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
+
+       switch(bi->blockState){
+        case YAFFS_BLOCK_STATE_UNKNOWN:
+        case YAFFS_BLOCK_STATE_SCANNING:
+        case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
+               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
+               n,blockStateName[bi->blockState]));
+       }
+
+       /* Check pages in use and soft deletions are legal */
+
+       actuallyUsed = bi->pagesInUse - bi->softDeletions;
+
+       if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
+          bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
+          actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
+               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
+               n,bi->pagesInUse,bi->softDeletions));
+
+
+       /* Check chunk bitmap legal */
+       inUse = yaffs_CountChunkBits(dev,n);
+       if(inUse != bi->pagesInUse)
+               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
+                       n,bi->pagesInUse,inUse));
+
+       /* Check that the sequence number is valid.
+        * Ten million is legal, but is very unlikely
+        */
+       if(dev->isYaffs2 &&
+          (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
+          (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
+               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
+               n,bi->sequenceNumber));
+
+}
+
+static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
+{
+       yaffs_VerifyBlock(dev,bi,n);
+
+       /* After collection the block should be in the erased state */
+       /* TODO: This will need to change if we do partial gc */
+
+       if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
+               T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
+                       n,bi->blockState));
+       }
+}
+
+static void yaffs_VerifyBlocks(yaffs_Device *dev)
+{
+       int i;
+       int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
+       int nIllegalBlockStates = 0;
+
+
+       if(yaffs_SkipVerification(dev))
+               return;
+
+       memset(nBlocksPerState,0,sizeof(nBlocksPerState));
+
+
+       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
+               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
+               yaffs_VerifyBlock(dev,bi,i);
+
+               if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
+                       nBlocksPerState[bi->blockState]++;
+               else
+                       nIllegalBlockStates++;
+
+       }
+
+       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
+       T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
+
+       T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
+       if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
+               T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
+
+       for(i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
+               T(YAFFS_TRACE_VERIFY,
+                 (TSTR("%s %d blocks"TENDSTR),
+                 blockStateName[i],nBlocksPerState[i]));
+
+       if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
+                dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
+
+       if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
+                dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
+
+       if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
+                nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING]));
+
+       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
+
+}
+
+/*
+ * Verify the object header. oh must be valid, but obj and tags may be NULL in which
+ * case those tests will not be performed.
+ */
+static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
+{
+       if(yaffs_SkipVerification(obj->myDev))
+               return;
+
+       if(!(tags && obj && oh)){
+               T(YAFFS_TRACE_VERIFY,
+                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
+                               (__u32)tags,(__u32)obj,(__u32)oh));
+               return;
+       }
+
+       if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
+          oh->type > YAFFS_OBJECT_TYPE_MAX)
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
+                tags->objectId, oh->type));
+
+       if(tags->objectId != obj->objectId)
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
+                tags->objectId, obj->objectId));
+
+
+       /*
+        * Check that the object's parent ids match if parentCheck requested.
+        *
+        * Tests do not apply to the root object.
+        */
+
+       if(parentCheck && tags->objectId > 1 && !obj->parent)
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
+                tags->objectId, oh->parentObjectId));
+
+
+       if(parentCheck && obj->parent &&
+          oh->parentObjectId != obj->parent->objectId &&
+          (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
+           obj->parent->objectId != YAFFS_OBJECTID_DELETED))
+               T(YAFFS_TRACE_VERIFY,
+                (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
+                tags->objectId, oh->parentObjectId, obj->parent->objectId));
+
+
+       if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
+               T(YAFFS_TRACE_VERIFY,
+               (TSTR("Obj %d header name is NULL"TENDSTR),
+                obj->objectId));
+
+       if(tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
+               T(YAFFS_TRACE_VERIFY,
+               (TSTR("Obj %d header name is 0xFF"TENDSTR),
+                obj->objectId));
+}
+
+
+
+static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
+                                       __u32 level, int chunkOffset)
+{
+       int i;
+       yaffs_Device *dev = obj->myDev;
+       int ok = 1;
+       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       if (tn) {
+               if (level > 0) {
+
+                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
+                               if (tn->internal[i]) {
+                                       ok = yaffs_VerifyTnodeWorker(obj,
+                                                       tn->internal[i],
+                                                       level - 1,
+                                                       (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
+                               }
+                       }
+               } else if (level == 0) {
+                       int i;
+                       yaffs_ExtendedTags tags;
+                       __u32 objectId = obj->objectId;
+
+                       chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
+
+                       for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
+                               __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
+
+                               if(theChunk > 0){
+                                       /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
+                                       yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
+                                       if(tags.objectId != objectId || tags.chunkId != chunkOffset){
+                                               T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
+                                                       objectId, chunkOffset, theChunk,
+                                                       tags.objectId, tags.chunkId));
+                                       }
+                               }
+                               chunkOffset++;
+                       }
+               }
+       }
+
+       return ok;
+
+}
+
+
+static void yaffs_VerifyFile(yaffs_Object *obj)
+{
+       int requiredTallness;
+       int actualTallness;
+       __u32 lastChunk;
+       __u32 x;
+       __u32 i;
+       int ok;
+       yaffs_Device *dev;
+       yaffs_ExtendedTags tags;
+       yaffs_Tnode *tn;
+       __u32 objectId;
+
+       if(obj && yaffs_SkipVerification(obj->myDev))
+               return;
+
+       dev = obj->myDev;
+       objectId = obj->objectId;
+
+       /* Check file size is consistent with tnode depth */
+       lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
+       x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
+       requiredTallness = 0;
+       while (x> 0) {
+               x >>= YAFFS_TNODES_INTERNAL_BITS;
+               requiredTallness++;
+       }
+
+       actualTallness = obj->variant.fileVariant.topLevel;
+
+       if(requiredTallness > actualTallness )
+               T(YAFFS_TRACE_VERIFY,
+               (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
+                obj->objectId,actualTallness, requiredTallness));
+
+
+       /* Check that the chunks in the tnode tree are all correct.
+        * We do this by scanning through the tnode tree and
+        * checking the tags for every chunk match.
+        */
+
+       if(yaffs_SkipNANDVerification(dev))
+               return;
+
+       for(i = 1; i <= lastChunk; i++){
+               tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
+
+               if (tn) {
+                       __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
+                       if(theChunk > 0){
+                               /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */
+                               yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
+                               if(tags.objectId != objectId || tags.chunkId != i){
+                                       T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
+                                               objectId, i, theChunk,
+                                               tags.objectId, tags.chunkId));
+                               }
+                       }
+               }
+
+       }
+
+}
+
+static void yaffs_VerifyDirectory(yaffs_Object *obj)
+{
+       if(obj && yaffs_SkipVerification(obj->myDev))
+               return;
+
+}
+
+static void yaffs_VerifyHardLink(yaffs_Object *obj)
+{
+       if(obj && yaffs_SkipVerification(obj->myDev))
+               return;
+
+       /* Verify sane equivalent object */
+}
+
+static void yaffs_VerifySymlink(yaffs_Object *obj)
+{
+       if(obj && yaffs_SkipVerification(obj->myDev))
+               return;
+
+       /* Verify symlink string */
+}
+
+static void yaffs_VerifySpecial(yaffs_Object *obj)
+{
+       if(obj && yaffs_SkipVerification(obj->myDev))
+               return;
+}
+
+static void yaffs_VerifyObject(yaffs_Object *obj)
+{
+       yaffs_Device *dev;
+
+       __u32 chunkMin;
+       __u32 chunkMax;
+
+       __u32 chunkIdOk;
+       __u32 chunkIsLive;
+
+       if(!obj)
+               return;
+
+       dev = obj->myDev;
+
+       if(yaffs_SkipVerification(dev))
+               return;
+
+       /* Check sane object header chunk */
+
+       chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
+       chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
+
+       chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
+       chunkIsLive = chunkIdOk &&
+                       yaffs_CheckChunkBit(dev,
+                                           obj->chunkId / dev->nChunksPerBlock,
+                                           obj->chunkId % dev->nChunksPerBlock);
+       if(!obj->fake &&
+           (!chunkIdOk || !chunkIsLive)) {
+          T(YAFFS_TRACE_VERIFY,
+          (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
+          obj->objectId,obj->chunkId,
+          chunkIdOk ? "" : ",out of range",
+          chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
+       }
+
+       if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
+               yaffs_ExtendedTags tags;
+               yaffs_ObjectHeader *oh;
+               __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
+
+               oh = (yaffs_ObjectHeader *)buffer;
+
+               yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
+
+               yaffs_VerifyObjectHeader(obj,oh,&tags,1);
+
+               yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
+       }
+
+       /* Verify it has a parent */
+       if(obj && !obj->fake &&
+          (!obj->parent || obj->parent->myDev != dev)){
+          T(YAFFS_TRACE_VERIFY,
+          (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
+          obj->objectId,obj->parent));
+       }
+
+       /* Verify parent is a directory */
+       if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
+          T(YAFFS_TRACE_VERIFY,
+          (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
+          obj->objectId,obj->parent->variantType));
+       }
+
+       switch(obj->variantType){
+       case YAFFS_OBJECT_TYPE_FILE:
+               yaffs_VerifyFile(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+               yaffs_VerifySymlink(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_DIRECTORY:
+               yaffs_VerifyDirectory(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_HARDLINK:
+               yaffs_VerifyHardLink(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_SPECIAL:
+               yaffs_VerifySpecial(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_UNKNOWN:
+       default:
+               T(YAFFS_TRACE_VERIFY,
+               (TSTR("Obj %d has illegaltype %d"TENDSTR),
+               obj->objectId,obj->variantType));
+               break;
+       }
+
+
+}
+
+static void yaffs_VerifyObjects(yaffs_Device *dev)
+{
+       yaffs_Object *obj;
+       int i;
+       struct list_head *lh;
+
+       if(yaffs_SkipVerification(dev))
+               return;
+
+       /* Iterate through the objects in each hash entry */
+
+        for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
+               list_for_each(lh, &dev->objectBucket[i].list) {
+                       if (lh) {
+                               obj = list_entry(lh, yaffs_Object, hashLink);
+                               yaffs_VerifyObject(obj);
+                       }
+               }
+        }
+
+}
+
+
+/*
+ *  Simple hash function. Needs to have a reasonable spread
+ */
+
+static Y_INLINE int yaffs_HashFunction(int n)
+{
+       n = abs(n);
+       return (n % YAFFS_NOBJECT_BUCKETS);
+}
+
+/*
+ * Access functions to useful fake objects
+ */
+
+yaffs_Object *yaffs_Root(yaffs_Device * dev)
+{
+       return dev->rootDir;
+}
+
+yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
+{
+       return dev->lostNFoundDir;
+}
+
+
+/*
+ *  Erased NAND checking functions
+ */
+
+int yaffs_CheckFF(__u8 * buffer, int nBytes)
+{
+       /* Horrible, slow implementation */
+       while (nBytes--) {
+               if (*buffer != 0xFF)
+                       return 0;
+               buffer++;
+       }
+       return 1;
+}
+
+static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
+                                 int chunkInNAND)
+{
+
+       int retval = YAFFS_OK;
+       __u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
+       yaffs_ExtendedTags tags;
+       int result;
+
+       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
+
+       if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
+               retval = YAFFS_FAIL;
+
+
+       if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
+               T(YAFFS_TRACE_NANDACCESS,
+                 (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND));
+               retval = YAFFS_FAIL;
+       }
+
+       yaffs_ReleaseTempBuffer(dev, data, __LINE__);
+
+       return retval;
+
+}
+
+
+static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
+                                            const __u8 * data,
+                                            yaffs_ExtendedTags * tags,
+                                            int useReserve)
+{
+       int attempts = 0;
+       int writeOk = 0;
+       int chunk;
+
+       yaffs_InvalidateCheckpoint(dev);
+
+       do {
+               yaffs_BlockInfo *bi = 0;
+               int erasedOk = 0;
+
+               chunk = yaffs_AllocateChunk(dev, useReserve, &bi);
+               if (chunk < 0) {
+                       /* no space */
+                       break;
+               }
+
+               /* First check this chunk is erased, if it needs
+                * checking.  The checking policy (unless forced
+                * always on) is as follows:
+                *
+                * Check the first page we try to write in a block.
+                * If the check passes then we don't need to check any
+                * more.        If the check fails, we check again...
+                * If the block has been erased, we don't need to check.
+                *
+                * However, if the block has been prioritised for gc,
+                * then we think there might be something odd about
+                * this block and stop using it.
+                *
+                * Rationale: We should only ever see chunks that have
+                * not been erased if there was a partially written
+                * chunk due to power loss.  This checking policy should
+                * catch that case with very few checks and thus save a
+                * lot of checks that are most likely not needed.
+                */
+               if (bi->gcPrioritise) {
+                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
+                       /* try another chunk */
+                       continue;
+               }
+
+               /* let's give it a try */
+               attempts++;
+
+#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
+               bi->skipErasedCheck = 0;
+#endif
+               if (!bi->skipErasedCheck) {
+                       erasedOk = yaffs_CheckChunkErased(dev, chunk);
+                       if (erasedOk != YAFFS_OK) {
+                               T(YAFFS_TRACE_ERROR,
+                               (TSTR ("**>> yaffs chunk %d was not erased"
+                               TENDSTR), chunk));
+
+                               /* try another chunk */
+                               continue;
+                       }
+                       bi->skipErasedCheck = 1;
+               }
+
+               writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk,
+                               data, tags);
+               if (writeOk != YAFFS_OK) {
+                       yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
+                       /* try another chunk */
+                       continue;
+               }
+
+               /* Copy the data into the robustification buffer */
+               yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
+
+       } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
+
+       if (attempts > 1) {
+               T(YAFFS_TRACE_ERROR,
+                       (TSTR("**>> yaffs write required %d attempts" TENDSTR),
+                       attempts));
+
+               dev->nRetriedWrites += (attempts - 1);
+       }
+
+       return chunk;
+}
+
+/*
+ * Block retiring for handling a broken block.
+ */
+
+static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
+{
+       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
+
+       yaffs_InvalidateCheckpoint(dev);
+
+       yaffs_MarkBlockBad(dev, blockInNAND);
+
+       bi->blockState = YAFFS_BLOCK_STATE_DEAD;
+       bi->gcPrioritise = 0;
+       bi->needsRetiring = 0;
+
+       dev->nRetiredBlocks++;
+}
+
+/*
+ * Functions for robustisizing TODO
+ *
+ */
+
+static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
+                                    const __u8 * data,
+                                    const yaffs_ExtendedTags * tags)
+{
+}
+
+static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
+                                   const yaffs_ExtendedTags * tags)
+{
+}
+
+void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
+{
+       if(!bi->gcPrioritise){
+               bi->gcPrioritise = 1;
+               dev->hasPendingPrioritisedGCs = 1;
+               bi->chunkErrorStrikes ++;
+
+               if(bi->chunkErrorStrikes > 3){
+                       bi->needsRetiring = 1; /* Too many stikes, so retire this */
+                       T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
+
+               }
+
+       }
+}
+
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk)
+{
+
+       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
+       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
+
+       yaffs_HandleChunkError(dev,bi);
+
+
+       if(erasedOk ) {
+               /* Was an actual write failure, so mark the block for retirement  */
+               bi->needsRetiring = 1;
+               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                 (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
+
+
+       }
+
+       /* Delete the chunk */
+       yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
+}
+
+
+/*---------------- Name handling functions ------------*/
+
+static __u16 yaffs_CalcNameSum(const YCHAR * name)
+{
+       __u16 sum = 0;
+       __u16 i = 1;
+
+       YUCHAR *bname = (YUCHAR *) name;
+       if (bname) {
+               while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
+
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+                       sum += yaffs_toupper(*bname) * i;
+#else
+                       sum += (*bname) * i;
+#endif
+                       i++;
+                       bname++;
+               }
+       }
+       return sum;
+}
+
+static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
+{
+#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
+       if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) {
+               yaffs_strcpy(obj->shortName, name);
+       } else {
+               obj->shortName[0] = _Y('\0');
+       }
+#endif
+       obj->sum = yaffs_CalcNameSum(name);
+}
+
+/*-------------------- TNODES -------------------
+
+ * List of spare tnodes
+ * The list is hooked together using the first pointer
+ * in the tnode.
+ */
+
+/* yaffs_CreateTnodes creates a bunch more tnodes and
+ * adds them to the tnode free list.
+ * Don't use this function directly
+ */
+
+static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
+{
+       int i;
+       int tnodeSize;
+       yaffs_Tnode *newTnodes;
+       __u8 *mem;
+       yaffs_Tnode *curr;
+       yaffs_Tnode *next;
+       yaffs_TnodeList *tnl;
+
+       if (nTnodes < 1)
+               return YAFFS_OK;
+
+       /* Calculate the tnode size in bytes for variable width tnode support.
+        * Must be a multiple of 32-bits  */
+       tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       /* make these things */
+
+       newTnodes = YMALLOC(nTnodes * tnodeSize);
+       mem = (__u8 *)newTnodes;
+
+       if (!newTnodes) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       /* Hook them into the free list */
+#if 0
+       for (i = 0; i < nTnodes - 1; i++) {
+               newTnodes[i].internal[0] = &newTnodes[i + 1];
+#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
+               newTnodes[i].internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
+#endif
+       }
+
+       newTnodes[nTnodes - 1].internal[0] = dev->freeTnodes;
+#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
+       newTnodes[nTnodes - 1].internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
+#endif
+       dev->freeTnodes = newTnodes;
+#else
+       /* New hookup for wide tnodes */
+       for(i = 0; i < nTnodes -1; i++) {
+               curr = (yaffs_Tnode *) &mem[i * tnodeSize];
+               next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
+               curr->internal[0] = next;
+       }
+
+       curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
+       curr->internal[0] = dev->freeTnodes;
+       dev->freeTnodes = (yaffs_Tnode *)mem;
+
+#endif
+
+
+       dev->nFreeTnodes += nTnodes;
+       dev->nTnodesCreated += nTnodes;
+
+       /* Now add this bunch of tnodes to a list for freeing up.
+        * NB If we can't add this to the management list it isn't fatal
+        * but it just means we can't free this bunch of tnodes later.
+        */
+
+       tnl = YMALLOC(sizeof(yaffs_TnodeList));
+       if (!tnl) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR
+                  ("yaffs: Could not add tnodes to management list" TENDSTR)));
+                  return YAFFS_FAIL;
+
+       } else {
+               tnl->tnodes = newTnodes;
+               tnl->next = dev->allocatedTnodeList;
+               dev->allocatedTnodeList = tnl;
+       }
+
+       T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
+
+       return YAFFS_OK;
+}
+
+/* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */
+
+static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
+{
+       yaffs_Tnode *tn = NULL;
+
+       /* If there are none left make more */
+       if (!dev->freeTnodes) {
+               yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES);
+       }
+
+       if (dev->freeTnodes) {
+               tn = dev->freeTnodes;
+#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
+               if (tn->internal[YAFFS_NTNODES_INTERNAL] != (void *)1) {
+                       /* Hoosterman, this thing looks like it isn't in the list */
+                       T(YAFFS_TRACE_ALWAYS,
+                         (TSTR("yaffs: Tnode list bug 1" TENDSTR)));
+               }
+#endif
+               dev->freeTnodes = dev->freeTnodes->internal[0];
+               dev->nFreeTnodes--;
+       }
+
+       return tn;
+}
+
+static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
+{
+       yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
+
+       if(tn)
+               memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+
+       return tn;
+}
+
+/* FreeTnode frees up a tnode and puts it back on the free list */
+static void yaffs_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn)
+{
+       if (tn) {
+#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
+               if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) {
+                       /* Hoosterman, this thing looks like it is already in the list */
+                       T(YAFFS_TRACE_ALWAYS,
+                         (TSTR("yaffs: Tnode list bug 2" TENDSTR)));
+               }
+               tn->internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
+#endif
+               tn->internal[0] = dev->freeTnodes;
+               dev->freeTnodes = tn;
+               dev->nFreeTnodes++;
+       }
+}
+
+static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
+{
+       /* Free the list of allocated tnodes */
+       yaffs_TnodeList *tmp;
+
+       while (dev->allocatedTnodeList) {
+               tmp = dev->allocatedTnodeList->next;
+
+               YFREE(dev->allocatedTnodeList->tnodes);
+               YFREE(dev->allocatedTnodeList);
+               dev->allocatedTnodeList = tmp;
+
+       }
+
+       dev->freeTnodes = NULL;
+       dev->nFreeTnodes = 0;
+}
+
+static void yaffs_InitialiseTnodes(yaffs_Device * dev)
+{
+       dev->allocatedTnodeList = NULL;
+       dev->freeTnodes = NULL;
+       dev->nFreeTnodes = 0;
+       dev->nTnodesCreated = 0;
+
+}
+
+
+void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsigned val)
+{
+  __u32 *map = (__u32 *)tn;
+  __u32 bitInMap;
+  __u32 bitInWord;
+  __u32 wordInMap;
+  __u32 mask;
+
+  pos &= YAFFS_TNODES_LEVEL0_MASK;
+  val >>= dev->chunkGroupBits;
+
+  bitInMap = pos * dev->tnodeWidth;
+  wordInMap = bitInMap /32;
+  bitInWord = bitInMap & (32 -1);
+
+  mask = dev->tnodeMask << bitInWord;
+
+  map[wordInMap] &= ~mask;
+  map[wordInMap] |= (mask & (val << bitInWord));
+
+  if(dev->tnodeWidth > (32-bitInWord)) {
+    bitInWord = (32 - bitInWord);
+    wordInMap++;;
+    mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
+    map[wordInMap] &= ~mask;
+    map[wordInMap] |= (mask & (val >> bitInWord));
+  }
+}
+
+static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos)
+{
+  __u32 *map = (__u32 *)tn;
+  __u32 bitInMap;
+  __u32 bitInWord;
+  __u32 wordInMap;
+  __u32 val;
+
+  pos &= YAFFS_TNODES_LEVEL0_MASK;
+
+  bitInMap = pos * dev->tnodeWidth;
+  wordInMap = bitInMap /32;
+  bitInWord = bitInMap & (32 -1);
+
+  val = map[wordInMap] >> bitInWord;
+
+  if(dev->tnodeWidth > (32-bitInWord)) {
+    bitInWord = (32 - bitInWord);
+    wordInMap++;;
+    val |= (map[wordInMap] << bitInWord);
+  }
+
+  val &= dev->tnodeMask;
+  val <<= dev->chunkGroupBits;
+
+  return val;
+}
+
+/* ------------------- End of individual tnode manipulation -----------------*/
+
+/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------
+ * The look up tree is represented by the top tnode and the number of topLevel
+ * in the tree. 0 means only the level 0 tnode is in the tree.
+ */
+
+/* FindLevel0Tnode finds the level 0 tnode, if one exists. */
+static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
+                                         yaffs_FileStructure * fStruct,
+                                         __u32 chunkId)
+{
+
+       yaffs_Tnode *tn = fStruct->top;
+       __u32 i;
+       int requiredTallness;
+       int level = fStruct->topLevel;
+
+       /* Check sane level and chunk Id */
+       if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) {
+               return NULL;
+       }
+
+       if (chunkId > YAFFS_MAX_CHUNK_ID) {
+               return NULL;
+       }
+
+       /* First check we're tall enough (ie enough topLevel) */
+
+       i = chunkId >> YAFFS_TNODES_LEVEL0_BITS;
+       requiredTallness = 0;
+       while (i) {
+               i >>= YAFFS_TNODES_INTERNAL_BITS;
+               requiredTallness++;
+       }
+
+       if (requiredTallness > fStruct->topLevel) {
+               /* Not tall enough, so we can't find it, return NULL. */
+               return NULL;
+       }
+
+       /* Traverse down to level 0 */
+       while (level > 0 && tn) {
+               tn = tn->
+                   internal[(chunkId >>
+                              ( YAFFS_TNODES_LEVEL0_BITS +
+                                (level - 1) *
+                                YAFFS_TNODES_INTERNAL_BITS)
+                             ) &
+                            YAFFS_TNODES_INTERNAL_MASK];
+               level--;
+
+       }
+
+       return tn;
+}
+
+/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree.
+ * This happens in two steps:
+ *  1. If the tree isn't tall enough, then make it taller.
+ *  2. Scan down the tree towards the level 0 tnode adding tnodes if required.
+ *
+ * Used when modifying the tree.
+ *
+ *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
+ *  be plugged into the ttree.
+ */
+
+static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
+                                              yaffs_FileStructure * fStruct,
+                                              __u32 chunkId,
+                                              yaffs_Tnode *passedTn)
+{
+
+       int requiredTallness;
+       int i;
+       int l;
+       yaffs_Tnode *tn;
+
+       __u32 x;
+
+
+       /* Check sane level and page Id */
+       if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) {
+               return NULL;
+       }
+
+       if (chunkId > YAFFS_MAX_CHUNK_ID) {
+               return NULL;
+       }
+
+       /* First check we're tall enough (ie enough topLevel) */
+
+       x = chunkId >> YAFFS_TNODES_LEVEL0_BITS;
+       requiredTallness = 0;
+       while (x) {
+               x >>= YAFFS_TNODES_INTERNAL_BITS;
+               requiredTallness++;
+       }
+
+
+       if (requiredTallness > fStruct->topLevel) {
+               /* Not tall enough,gotta make the tree taller */
+               for (i = fStruct->topLevel; i < requiredTallness; i++) {
+
+                       tn = yaffs_GetTnode(dev);
+
+                       if (tn) {
+                               tn->internal[0] = fStruct->top;
+                               fStruct->top = tn;
+                       } else {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR("yaffs: no more tnodes" TENDSTR)));
+                       }
+               }
+
+               fStruct->topLevel = requiredTallness;
+       }
+
+       /* Traverse down to level 0, adding anything we need */
+
+       l = fStruct->topLevel;
+       tn = fStruct->top;
+
+       if(l > 0) {
+               while (l > 0 && tn) {
+                       x = (chunkId >>
+                            ( YAFFS_TNODES_LEVEL0_BITS +
+                             (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) &
+                           YAFFS_TNODES_INTERNAL_MASK;
+
+
+                       if((l>1) && !tn->internal[x]){
+                               /* Add missing non-level-zero tnode */
+                               tn->internal[x] = yaffs_GetTnode(dev);
+
+                       } else if(l == 1) {
+                               /* Looking from level 1 at level 0 */
+                               if (passedTn) {
+                                       /* If we already have one, then release it.*/
+                                       if(tn->internal[x])
+                                               yaffs_FreeTnode(dev,tn->internal[x]);
+                                       tn->internal[x] = passedTn;
+
+                               } else if(!tn->internal[x]) {
+                                       /* Don't have one, none passed in */
+                                       tn->internal[x] = yaffs_GetTnode(dev);
+                               }
+                       }
+
+                       tn = tn->internal[x];
+                       l--;
+               }
+       } else {
+               /* top is level 0 */
+               if(passedTn) {
+                       memcpy(tn,passedTn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+                       yaffs_FreeTnode(dev,passedTn);
+               }
+       }
+
+       return tn;
+}
+
+static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
+                                 yaffs_ExtendedTags * tags, int objectId,
+                                 int chunkInInode)
+{
+       int j;
+
+       for (j = 0; theChunk && j < dev->chunkGroupSize; j++) {
+               if (yaffs_CheckChunkBit
+                   (dev, theChunk / dev->nChunksPerBlock,
+                    theChunk % dev->nChunksPerBlock)) {
+                       yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL,
+                                                       tags);
+                       if (yaffs_TagsMatch(tags, objectId, chunkInInode)) {
+                               /* found it; */
+                               return theChunk;
+
+                       }
+               }
+               theChunk++;
+       }
+       return -1;
+}
+
+
+/* DeleteWorker scans backwards through the tnode tree and deletes all the
+ * chunks and tnodes in the file
+ * Returns 1 if the tree was deleted.
+ * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
+ */
+
+static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
+                             int chunkOffset, int *limit)
+{
+       int i;
+       int chunkInInode;
+       int theChunk;
+       yaffs_ExtendedTags tags;
+       int foundChunk;
+       yaffs_Device *dev = in->myDev;
+
+       int allDone = 1;
+
+       if (tn) {
+               if (level > 0) {
+
+                       for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
+                            i--) {
+                               if (tn->internal[i]) {
+                                       if (limit && (*limit) < 0) {
+                                               allDone = 0;
+                                       } else {
+                                               allDone =
+                                                   yaffs_DeleteWorker(in,
+                                                                      tn->
+                                                                      internal
+                                                                      [i],
+                                                                      level -
+                                                                      1,
+                                                                      (chunkOffset
+                                                                       <<
+                                                                       YAFFS_TNODES_INTERNAL_BITS)
+                                                                      + i,
+                                                                      limit);
+                                       }
+                                       if (allDone) {
+                                               yaffs_FreeTnode(dev,
+                                                               tn->
+                                                               internal[i]);
+                                               tn->internal[i] = NULL;
+                                       }
+                               }
+
+                       }
+                       return (allDone) ? 1 : 0;
+               } else if (level == 0) {
+                       int hitLimit = 0;
+
+                       for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit;
+                            i--) {
+                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
+                               if (theChunk) {
+
+                                       chunkInInode =
+                                           (chunkOffset <<
+                                            YAFFS_TNODES_LEVEL0_BITS) + i;
+
+                                       foundChunk =
+                                           yaffs_FindChunkInGroup(dev,
+                                                                  theChunk,
+                                                                  &tags,
+                                                                  in->objectId,
+                                                                  chunkInInode);
+
+                                       if (foundChunk > 0) {
+                                               yaffs_DeleteChunk(dev,
+                                                                 foundChunk, 1,
+                                                                 __LINE__);
+                                               in->nDataChunks--;
+                                               if (limit) {
+                                                       *limit = *limit - 1;
+                                                       if (*limit <= 0) {
+                                                               hitLimit = 1;
+                                                       }
+                                               }
+
+                                       }
+
+                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
+                               }
+
+                       }
+                       return (i < 0) ? 1 : 0;
+
+               }
+
+       }
+
+       return 1;
+
+}
+
+static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
+{
+
+       yaffs_BlockInfo *theBlock;
+
+       T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
+
+       theBlock = yaffs_GetBlockInfo(dev, chunk / dev->nChunksPerBlock);
+       if (theBlock) {
+               theBlock->softDeletions++;
+               dev->nFreeChunks++;
+       }
+}
+
+/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file.
+ * All soft deleting does is increment the block's softdelete count and pulls the chunk out
+ * of the tnode.
+ * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
+ */
+
+static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
+                                 __u32 level, int chunkOffset)
+{
+       int i;
+       int theChunk;
+       int allDone = 1;
+       yaffs_Device *dev = in->myDev;
+
+       if (tn) {
+               if (level > 0) {
+
+                       for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
+                            i--) {
+                               if (tn->internal[i]) {
+                                       allDone =
+                                           yaffs_SoftDeleteWorker(in,
+                                                                  tn->
+                                                                  internal[i],
+                                                                  level - 1,
+                                                                  (chunkOffset
+                                                                   <<
+                                                                   YAFFS_TNODES_INTERNAL_BITS)
+                                                                  + i);
+                                       if (allDone) {
+                                               yaffs_FreeTnode(dev,
+                                                               tn->
+                                                               internal[i]);
+                                               tn->internal[i] = NULL;
+                                       } else {
+                                               /* Hoosterman... how could this happen? */
+                                       }
+                               }
+                       }
+                       return (allDone) ? 1 : 0;
+               } else if (level == 0) {
+
+                       for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) {
+                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
+                               if (theChunk) {
+                                       /* Note this does not find the real chunk, only the chunk group.
+                                        * We make an assumption that a chunk group is not larger than
+                                        * a block.
+                                        */
+                                       yaffs_SoftDeleteChunk(dev, theChunk);
+                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
+                               }
+
+                       }
+                       return 1;
+
+               }
+
+       }
+
+       return 1;
+
+}
+
+static void yaffs_SoftDeleteFile(yaffs_Object * obj)
+{
+       if (obj->deleted &&
+           obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) {
+               if (obj->nDataChunks <= 0) {
+                       /* Empty file with no duplicate object headers, just delete it immediately */
+                       yaffs_FreeTnode(obj->myDev,
+                                       obj->variant.fileVariant.top);
+                       obj->variant.fileVariant.top = NULL;
+                       T(YAFFS_TRACE_TRACING,
+                         (TSTR("yaffs: Deleting empty file %d" TENDSTR),
+                          obj->objectId));
+                       yaffs_DoGenericObjectDeletion(obj);
+               } else {
+                       yaffs_SoftDeleteWorker(obj,
+                                              obj->variant.fileVariant.top,
+                                              obj->variant.fileVariant.
+                                              topLevel, 0);
+                       obj->softDeleted = 1;
+               }
+       }
+}
+
+/* Pruning removes any part of the file structure tree that is beyond the
+ * bounds of the file (ie that does not point to chunks).
+ *
+ * A file should only get pruned when its size is reduced.
+ *
+ * Before pruning, the chunks must be pulled from the tree and the
+ * level 0 tnode entries must be zeroed out.
+ * Could also use this for file deletion, but that's probably better handled
+ * by a special case.
+ */
+
+static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device * dev, yaffs_Tnode * tn,
+                                     __u32 level, int del0)
+{
+       int i;
+       int hasData;
+
+       if (tn) {
+               hasData = 0;
+
+               for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) {
+                       if (tn->internal[i] && level > 0) {
+                               tn->internal[i] =
+                                   yaffs_PruneWorker(dev, tn->internal[i],
+                                                     level - 1,
+                                                     (i == 0) ? del0 : 1);
+                       }
+
+                       if (tn->internal[i]) {
+                               hasData++;
+                       }
+               }
+
+               if (hasData == 0 && del0) {
+                       /* Free and return NULL */
+
+                       yaffs_FreeTnode(dev, tn);
+                       tn = NULL;
+               }
+
+       }
+
+       return tn;
+
+}
+
+static int yaffs_PruneFileStructure(yaffs_Device * dev,
+                                   yaffs_FileStructure * fStruct)
+{
+       int i;
+       int hasData;
+       int done = 0;
+       yaffs_Tnode *tn;
+
+       if (fStruct->topLevel > 0) {
+               fStruct->top =
+                   yaffs_PruneWorker(dev, fStruct->top, fStruct->topLevel, 0);
+
+               /* Now we have a tree with all the non-zero branches NULL but the height
+                * is the same as it was.
+                * Let's see if we can trim internal tnodes to shorten the tree.
+                * We can do this if only the 0th element in the tnode is in use
+                * (ie all the non-zero are NULL)
+                */
+
+               while (fStruct->topLevel && !done) {
+                       tn = fStruct->top;
+
+                       hasData = 0;
+                       for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) {
+                               if (tn->internal[i]) {
+                                       hasData++;
+                               }
+                       }
+
+                       if (!hasData) {
+                               fStruct->top = tn->internal[0];
+                               fStruct->topLevel--;
+                               yaffs_FreeTnode(dev, tn);
+                       } else {
+                               done = 1;
+                       }
+               }
+       }
+
+       return YAFFS_OK;
+}
+
+/*-------------------- End of File Structure functions.-------------------*/
+
+/* yaffs_CreateFreeObjects creates a bunch more objects and
+ * adds them to the object free list.
+ */
+static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
+{
+       int i;
+       yaffs_Object *newObjects;
+       yaffs_ObjectList *list;
+
+       if (nObjects < 1)
+               return YAFFS_OK;
+
+       /* make these things */
+       newObjects = YMALLOC(nObjects * sizeof(yaffs_Object));
+       list = YMALLOC(sizeof(yaffs_ObjectList));
+
+       if (!newObjects || !list) {
+               if(newObjects)
+                       YFREE(newObjects);
+               if(list)
+                       YFREE(list);
+               T(YAFFS_TRACE_ALLOCATE,
+                 (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       /* Hook them into the free list */
+       for (i = 0; i < nObjects - 1; i++) {
+               newObjects[i].siblings.next =
+                   (struct list_head *)(&newObjects[i + 1]);
+       }
+
+       newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
+       dev->freeObjects = newObjects;
+       dev->nFreeObjects += nObjects;
+       dev->nObjectsCreated += nObjects;
+
+       /* Now add this bunch of Objects to a list for freeing up. */
+
+       list->objects = newObjects;
+       list->next = dev->allocatedObjectList;
+       dev->allocatedObjectList = list;
+
+       return YAFFS_OK;
+}
+
+
+/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
+static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
+{
+       yaffs_Object *tn = NULL;
+
+       /* If there are none left make more */
+       if (!dev->freeObjects) {
+               yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS);
+       }
+
+       if (dev->freeObjects) {
+               tn = dev->freeObjects;
+               dev->freeObjects =
+                   (yaffs_Object *) (dev->freeObjects->siblings.next);
+               dev->nFreeObjects--;
+
+               /* Now sweeten it up... */
+
+               memset(tn, 0, sizeof(yaffs_Object));
+               tn->myDev = dev;
+               tn->chunkId = -1;
+               tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
+               INIT_LIST_HEAD(&(tn->hardLinks));
+               INIT_LIST_HEAD(&(tn->hashLink));
+               INIT_LIST_HEAD(&tn->siblings);
+
+               /* Add it to the lost and found directory.
+                * NB Can't put root or lostNFound in lostNFound so
+                * check if lostNFound exists first
+                */
+               if (dev->lostNFoundDir) {
+                       yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn);
+               }
+       }
+
+       return tn;
+}
+
+static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device * dev, int number,
+                                              __u32 mode)
+{
+
+       yaffs_Object *obj =
+           yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
+       if (obj) {
+               obj->fake = 1;          /* it is fake so it has no NAND presence... */
+               obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */
+               obj->unlinkAllowed = 0; /* ... or unlink it */
+               obj->deleted = 0;
+               obj->unlinked = 0;
+               obj->yst_mode = mode;
+               obj->myDev = dev;
+               obj->chunkId = 0;       /* Not a valid chunk. */
+       }
+
+       return obj;
+
+}
+
+static void yaffs_UnhashObject(yaffs_Object * tn)
+{
+       int bucket;
+       yaffs_Device *dev = tn->myDev;
+
+       /* If it is still linked into the bucket list, free from the list */
+       if (!list_empty(&tn->hashLink)) {
+               list_del_init(&tn->hashLink);
+               bucket = yaffs_HashFunction(tn->objectId);
+               dev->objectBucket[bucket].count--;
+       }
+
+}
+
+/*  FreeObject frees up a Object and puts it back on the free list */
+static void yaffs_FreeObject(yaffs_Object * tn)
+{
+
+       yaffs_Device *dev = tn->myDev;
+
+#ifdef  __KERNEL__
+       if (tn->myInode) {
+               /* We're still hooked up to a cached inode.
+                * Don't delete now, but mark for later deletion
+                */
+               tn->deferedFree = 1;
+               return;
+       }
+#endif
+
+       yaffs_UnhashObject(tn);
+
+       /* Link into the free list. */
+       tn->siblings.next = (struct list_head *)(dev->freeObjects);
+       dev->freeObjects = tn;
+       dev->nFreeObjects++;
+}
+
+#ifdef __KERNEL__
+
+void yaffs_HandleDeferedFree(yaffs_Object * obj)
+{
+       if (obj->deferedFree) {
+               yaffs_FreeObject(obj);
+       }
+}
+
+#endif
+
+static void yaffs_DeinitialiseObjects(yaffs_Device * dev)
+{
+       /* Free the list of allocated Objects */
+
+       yaffs_ObjectList *tmp;
+
+       while (dev->allocatedObjectList) {
+               tmp = dev->allocatedObjectList->next;
+               YFREE(dev->allocatedObjectList->objects);
+               YFREE(dev->allocatedObjectList);
+
+               dev->allocatedObjectList = tmp;
+       }
+
+       dev->freeObjects = NULL;
+       dev->nFreeObjects = 0;
+}
+
+static void yaffs_InitialiseObjects(yaffs_Device * dev)
+{
+       int i;
+
+       dev->allocatedObjectList = NULL;
+       dev->freeObjects = NULL;
+       dev->nFreeObjects = 0;
+
+       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
+               INIT_LIST_HEAD(&dev->objectBucket[i].list);
+               dev->objectBucket[i].count = 0;
+       }
+
+}
+
+static int yaffs_FindNiceObjectBucket(yaffs_Device * dev)
+{
+       static int x = 0;
+       int i;
+       int l = 999;
+       int lowest = 999999;
+
+       /* First let's see if we can find one that's empty. */
+
+       for (i = 0; i < 10 && lowest > 0; i++) {
+               x++;
+               x %= YAFFS_NOBJECT_BUCKETS;
+               if (dev->objectBucket[x].count < lowest) {
+                       lowest = dev->objectBucket[x].count;
+                       l = x;
+               }
+
+       }
+
+       /* If we didn't find an empty list, then try
+        * looking a bit further for a short one
+        */
+
+       for (i = 0; i < 10 && lowest > 3; i++) {
+               x++;
+               x %= YAFFS_NOBJECT_BUCKETS;
+               if (dev->objectBucket[x].count < lowest) {
+                       lowest = dev->objectBucket[x].count;
+                       l = x;
+               }
+
+       }
+
+       return l;
+}
+
+static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
+{
+       int bucket = yaffs_FindNiceObjectBucket(dev);
+
+       /* Now find an object value that has not already been taken
+        * by scanning the list.
+        */
+
+       int found = 0;
+       struct list_head *i;
+
+       __u32 n = (__u32) bucket;
+
+       /* yaffs_CheckObjectHashSanity();  */
+
+       while (!found) {
+               found = 1;
+               n += YAFFS_NOBJECT_BUCKETS;
+               if (1 || dev->objectBucket[bucket].count > 0) {
+                       list_for_each(i, &dev->objectBucket[bucket].list) {
+                               /* If there is already one in the list */
+                               if (i
+                                   && list_entry(i, yaffs_Object,
+                                                 hashLink)->objectId == n) {
+                                       found = 0;
+                               }
+                       }
+               }
+       }
+
+
+       return n;
+}
+
+static void yaffs_HashObject(yaffs_Object * in)
+{
+       int bucket = yaffs_HashFunction(in->objectId);
+       yaffs_Device *dev = in->myDev;
+
+       list_add(&in->hashLink, &dev->objectBucket[bucket].list);
+       dev->objectBucket[bucket].count++;
+
+}
+
+yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
+{
+       int bucket = yaffs_HashFunction(number);
+       struct list_head *i;
+       yaffs_Object *in;
+
+       list_for_each(i, &dev->objectBucket[bucket].list) {
+               /* Look if it is in the list */
+               if (i) {
+                       in = list_entry(i, yaffs_Object, hashLink);
+                       if (in->objectId == number) {
+#ifdef __KERNEL__
+                               /* Don't tell the VFS about this one if it is defered free */
+                               if (in->deferedFree)
+                                       return NULL;
+#endif
+
+                               return in;
+                       }
+               }
+       }
+
+       return NULL;
+}
+
+yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
+                                   yaffs_ObjectType type)
+{
+
+       yaffs_Object *theObject;
+       yaffs_Tnode *tn;
+
+       if (number < 0) {
+               number = yaffs_CreateNewObjectNumber(dev);
+       }
+
+       theObject = yaffs_AllocateEmptyObject(dev);
+       if(!theObject)
+               return NULL;
+
+       if(type == YAFFS_OBJECT_TYPE_FILE){
+               tn = yaffs_GetTnode(dev);
+               if(!tn){
+                       yaffs_FreeObject(theObject);
+                       return NULL;
+               }
+       }
+
+
+
+       if (theObject) {
+               theObject->fake = 0;
+               theObject->renameAllowed = 1;
+               theObject->unlinkAllowed = 1;
+               theObject->objectId = number;
+               yaffs_HashObject(theObject);
+               theObject->variantType = type;
+#ifdef CONFIG_YAFFS_WINCE
+               yfsd_WinFileTimeNow(theObject->win_atime);
+               theObject->win_ctime[0] = theObject->win_mtime[0] =
+                   theObject->win_atime[0];
+               theObject->win_ctime[1] = theObject->win_mtime[1] =
+                   theObject->win_atime[1];
+
+#else
+
+               theObject->yst_atime = theObject->yst_mtime =
+                   theObject->yst_ctime = Y_CURRENT_TIME;
+#endif
+               switch (type) {
+               case YAFFS_OBJECT_TYPE_FILE:
+                       theObject->variant.fileVariant.fileSize = 0;
+                       theObject->variant.fileVariant.scannedFileSize = 0;
+                       theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */
+                       theObject->variant.fileVariant.topLevel = 0;
+                       theObject->variant.fileVariant.top = tn;
+                       break;
+               case YAFFS_OBJECT_TYPE_DIRECTORY:
+                       INIT_LIST_HEAD(&theObject->variant.directoryVariant.
+                                      children);
+                       break;
+               case YAFFS_OBJECT_TYPE_SYMLINK:
+               case YAFFS_OBJECT_TYPE_HARDLINK:
+               case YAFFS_OBJECT_TYPE_SPECIAL:
+                       /* No action required */
+                       break;
+               case YAFFS_OBJECT_TYPE_UNKNOWN:
+                       /* todo this should not happen */
+                       break;
+               }
+       }
+
+       return theObject;
+}
+
+static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
+                                                     int number,
+                                                     yaffs_ObjectType type)
+{
+       yaffs_Object *theObject = NULL;
+
+       if (number > 0) {
+               theObject = yaffs_FindObjectByNumber(dev, number);
+       }
+
+       if (!theObject) {
+               theObject = yaffs_CreateNewObject(dev, number, type);
+       }
+
+       return theObject;
+
+}
+
+
+static YCHAR *yaffs_CloneString(const YCHAR * str)
+{
+       YCHAR *newStr = NULL;
+
+       if (str && *str) {
+               newStr = YMALLOC((yaffs_strlen(str) + 1) * sizeof(YCHAR));
+               if(newStr)
+                       yaffs_strcpy(newStr, str);
+       }
+
+       return newStr;
+
+}
+
+/*
+ * Mknod (create) a new object.
+ * equivalentObject only has meaning for a hard link;
+ * aliasString only has meaning for a sumlink.
+ * rdev only has meaning for devices (a subset of special objects)
+ */
+
+static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
+                                      yaffs_Object * parent,
+                                      const YCHAR * name,
+                                      __u32 mode,
+                                      __u32 uid,
+                                      __u32 gid,
+                                      yaffs_Object * equivalentObject,
+                                      const YCHAR * aliasString, __u32 rdev)
+{
+       yaffs_Object *in;
+       YCHAR *str;
+
+       yaffs_Device *dev = parent->myDev;
+
+       /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
+       if (yaffs_FindObjectByName(parent, name)) {
+               return NULL;
+       }
+
+       in = yaffs_CreateNewObject(dev, -1, type);
+
+       if(type == YAFFS_OBJECT_TYPE_SYMLINK){
+               str = yaffs_CloneString(aliasString);
+               if(!str){
+                       yaffs_FreeObject(in);
+                       return NULL;
+               }
+       }
+
+
+
+       if (in) {
+               in->chunkId = -1;
+               in->valid = 1;
+               in->variantType = type;
+
+               in->yst_mode = mode;
+
+#ifdef CONFIG_YAFFS_WINCE
+               yfsd_WinFileTimeNow(in->win_atime);
+               in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
+               in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
+
+#else
+               in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME;
+
+               in->yst_rdev = rdev;
+               in->yst_uid = uid;
+               in->yst_gid = gid;
+#endif
+               in->nDataChunks = 0;
+
+               yaffs_SetObjectName(in, name);
+               in->dirty = 1;
+
+               yaffs_AddObjectToDirectory(parent, in);
+
+               in->myDev = parent->myDev;
+
+               switch (type) {
+               case YAFFS_OBJECT_TYPE_SYMLINK:
+                       in->variant.symLinkVariant.alias = str;
+                       break;
+               case YAFFS_OBJECT_TYPE_HARDLINK:
+                       in->variant.hardLinkVariant.equivalentObject =
+                           equivalentObject;
+                       in->variant.hardLinkVariant.equivalentObjectId =
+                           equivalentObject->objectId;
+                       list_add(&in->hardLinks, &equivalentObject->hardLinks);
+                       break;
+               case YAFFS_OBJECT_TYPE_FILE:
+               case YAFFS_OBJECT_TYPE_DIRECTORY:
+               case YAFFS_OBJECT_TYPE_SPECIAL:
+               case YAFFS_OBJECT_TYPE_UNKNOWN:
+                       /* do nothing */
+                       break;
+               }
+
+               if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
+                       /* Could not create the object header, fail the creation */
+                       yaffs_DestroyObject(in);
+                       in = NULL;
+               }
+
+       }
+
+       return in;
+}
+
+yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
+                             __u32 mode, __u32 uid, __u32 gid)
+{
+       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
+                                uid, gid, NULL, NULL, 0);
+}
+
+yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
+                                  __u32 mode, __u32 uid, __u32 gid)
+{
+       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
+                                mode, uid, gid, NULL, NULL, 0);
+}
+
+yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
+                                __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
+{
+       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
+                                uid, gid, NULL, NULL, rdev);
+}
+
+yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
+                                __u32 mode, __u32 uid, __u32 gid,
+                                const YCHAR * alias)
+{
+       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
+                                uid, gid, NULL, alias, 0);
+}
+
+/* yaffs_Link returns the object id of the equivalent object.*/
+yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
+                        yaffs_Object * equivalentObject)
+{
+       /* Get the real object in case we were fed a hard link as an equivalent object */
+       equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
+
+       if (yaffs_MknodObject
+           (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0,
+            equivalentObject, NULL, 0)) {
+               return equivalentObject;
+       } else {
+               return NULL;
+       }
+
+}
+
+static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
+                                 const YCHAR * newName, int force, int shadows)
+{
+       int unlinkOp;
+       int deleteOp;
+
+       yaffs_Object *existingTarget;
+
+       if (newDir == NULL) {
+               newDir = obj->parent;   /* use the old directory */
+       }
+
+       if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragendy: yaffs_ChangeObjectName: newDir is not a directory"
+                   TENDSTR)));
+               YBUG();
+       }
+
+       /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
+       if (obj->myDev->isYaffs2) {
+               unlinkOp = (newDir == obj->myDev->unlinkedDir);
+       } else {
+               unlinkOp = (newDir == obj->myDev->unlinkedDir
+                           && obj->variantType == YAFFS_OBJECT_TYPE_FILE);
+       }
+
+       deleteOp = (newDir == obj->myDev->deletedDir);
+
+       existingTarget = yaffs_FindObjectByName(newDir, newName);
+
+       /* If the object is a file going into the unlinked directory,
+        *   then it is OK to just stuff it in since duplicate names are allowed.
+        *   else only proceed if the new name does not exist and if we're putting
+        *   it into a directory.
+        */
+       if ((unlinkOp ||
+            deleteOp ||
+            force ||
+            (shadows > 0) ||
+            !existingTarget) &&
+           newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) {
+               yaffs_SetObjectName(obj, newName);
+               obj->dirty = 1;
+
+               yaffs_AddObjectToDirectory(newDir, obj);
+
+               if (unlinkOp)
+                       obj->unlinked = 1;
+
+               /* If it is a deletion then we mark it as a shrink for gc purposes. */
+               if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows)>= 0)
+                       return YAFFS_OK;
+       }
+
+       return YAFFS_FAIL;
+}
+
+int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
+                      yaffs_Object * newDir, const YCHAR * newName)
+{
+       yaffs_Object *obj;
+       yaffs_Object *existingTarget;
+       int force = 0;
+
+#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
+       /* Special case for case insemsitive systems (eg. WinCE).
+        * While look-up is case insensitive, the name isn't.
+        * Therefore we might want to change x.txt to X.txt
+       */
+       if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) {
+               force = 1;
+       }
+#endif
+
+       obj = yaffs_FindObjectByName(oldDir, oldName);
+       /* Check new name to long. */
+       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
+           yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
+         /* ENAMETOOLONG */
+         return YAFFS_FAIL;
+       else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
+                yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
+         /* ENAMETOOLONG */
+         return YAFFS_FAIL;
+
+       if (obj && obj->renameAllowed) {
+
+               /* Now do the handling for an existing target, if there is one */
+
+               existingTarget = yaffs_FindObjectByName(newDir, newName);
+               if (existingTarget &&
+                   existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
+                   !list_empty(&existingTarget->variant.directoryVariant.children)) {
+                       /* There is a target that is a non-empty directory, so we fail */
+                       return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
+               } else if (existingTarget && existingTarget != obj) {
+                       /* Nuke the target first, using shadowing,
+                        * but only if it isn't the same object
+                        */
+                       yaffs_ChangeObjectName(obj, newDir, newName, force,
+                                              existingTarget->objectId);
+                       yaffs_UnlinkObject(existingTarget);
+               }
+
+               return yaffs_ChangeObjectName(obj, newDir, newName, 1, 0);
+       }
+       return YAFFS_FAIL;
+}
+
+/*------------------------- Block Management and Page Allocation ----------------*/
+
+static int yaffs_InitialiseBlocks(yaffs_Device * dev)
+{
+       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
+
+       dev->blockInfo = NULL;
+       dev->chunkBits = NULL;
+
+       dev->allocationBlock = -1;      /* force it to get a new one */
+
+       /* If the first allocation strategy fails, thry the alternate one */
+       dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo));
+       if(!dev->blockInfo){
+               dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo));
+               dev->blockInfoAlt = 1;
+       }
+       else
+               dev->blockInfoAlt = 0;
+
+       if(dev->blockInfo){
+
+               /* Set up dynamic blockinfo stuff. */
+               dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
+               dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
+               if(!dev->chunkBits){
+                       dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks);
+                       dev->chunkBitsAlt = 1;
+               }
+               else
+                       dev->chunkBitsAlt = 0;
+       }
+
+       if (dev->blockInfo && dev->chunkBits) {
+               memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
+               memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
+               return YAFFS_OK;
+       }
+
+       return YAFFS_FAIL;
+
+}
+
+static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
+{
+       if(dev->blockInfoAlt && dev->blockInfo)
+               YFREE_ALT(dev->blockInfo);
+       else if(dev->blockInfo)
+               YFREE(dev->blockInfo);
+
+       dev->blockInfoAlt = 0;
+
+       dev->blockInfo = NULL;
+
+       if(dev->chunkBitsAlt && dev->chunkBits)
+               YFREE_ALT(dev->chunkBits);
+       else if(dev->chunkBits)
+               YFREE(dev->chunkBits);
+       dev->chunkBitsAlt = 0;
+       dev->chunkBits = NULL;
+}
+
+static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device * dev,
+                                           yaffs_BlockInfo * bi)
+{
+       int i;
+       __u32 seq;
+       yaffs_BlockInfo *b;
+
+       if (!dev->isYaffs2)
+               return 1;       /* disqualification only applies to yaffs2. */
+
+       if (!bi->hasShrinkHeader)
+               return 1;       /* can gc */
+
+       /* Find the oldest dirty sequence number if we don't know it and save it
+        * so we don't have to keep recomputing it.
+        */
+       if (!dev->oldestDirtySequence) {
+               seq = dev->sequenceNumber;
+
+               for (i = dev->internalStartBlock; i <= dev->internalEndBlock;
+                    i++) {
+                       b = yaffs_GetBlockInfo(dev, i);
+                       if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
+                           (b->pagesInUse - b->softDeletions) <
+                           dev->nChunksPerBlock && b->sequenceNumber < seq) {
+                               seq = b->sequenceNumber;
+                       }
+               }
+               dev->oldestDirtySequence = seq;
+       }
+
+       /* Can't do gc of this block if there are any blocks older than this one that have
+        * discarded pages.
+        */
+       return (bi->sequenceNumber <= dev->oldestDirtySequence);
+
+}
+
+/* FindDiretiestBlock is used to select the dirtiest block (or close enough)
+ * for garbage collection.
+ */
+
+static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
+                                              int aggressive)
+{
+
+       int b = dev->currentDirtyChecker;
+
+       int i;
+       int iterations;
+       int dirtiest = -1;
+       int pagesInUse = 0;
+       int prioritised=0;
+       yaffs_BlockInfo *bi;
+       int pendingPrioritisedExist = 0;
+
+       /* First let's see if we need to grab a prioritised block */
+       if(dev->hasPendingPrioritisedGCs){
+               for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
+
+                       bi = yaffs_GetBlockInfo(dev, i);
+                       //yaffs_VerifyBlock(dev,bi,i);
+
+                       if(bi->gcPrioritise) {
+                               pendingPrioritisedExist = 1;
+                               if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+                                  yaffs_BlockNotDisqualifiedFromGC(dev, bi)){
+                                       pagesInUse = (bi->pagesInUse - bi->softDeletions);
+                                       dirtiest = i;
+                                       prioritised = 1;
+                                       aggressive = 1; /* Fool the non-aggressive skip logiv below */
+                               }
+                       }
+               }
+
+               if(!pendingPrioritisedExist) /* None found, so we can clear this */
+                       dev->hasPendingPrioritisedGCs = 0;
+       }
+
+       /* If we're doing aggressive GC then we are happy to take a less-dirty block, and
+        * search harder.
+        * else (we're doing a leasurely gc), then we only bother to do this if the
+        * block has only a few pages in use.
+        */
+
+       dev->nonAggressiveSkip--;
+
+       if (!aggressive && (dev->nonAggressiveSkip > 0)) {
+               return -1;
+       }
+
+       if(!prioritised)
+               pagesInUse =
+                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
+
+       if (aggressive) {
+               iterations =
+                   dev->internalEndBlock - dev->internalStartBlock + 1;
+       } else {
+               iterations =
+                   dev->internalEndBlock - dev->internalStartBlock + 1;
+               iterations = iterations / 16;
+               if (iterations > 200) {
+                       iterations = 200;
+               }
+       }
+
+       for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
+               b++;
+               if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
+                       b = dev->internalStartBlock;
+               }
+
+               if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
+                       T(YAFFS_TRACE_ERROR,
+                         (TSTR("**>> Block %d is not valid" TENDSTR), b));
+                       YBUG();
+               }
+
+               bi = yaffs_GetBlockInfo(dev, b);
+
+#if 0
+               if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
+                       dirtiest = b;
+                       pagesInUse = 0;
+               }
+               else
+#endif
+
+               if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
+                      (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
+                       yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
+                       dirtiest = b;
+                       pagesInUse = (bi->pagesInUse - bi->softDeletions);
+               }
+       }
+
+       dev->currentDirtyChecker = b;
+
+       if (dirtiest > 0) {
+               T(YAFFS_TRACE_GC,
+                 (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
+                  dev->nChunksPerBlock - pagesInUse,prioritised));
+       }
+
+       dev->oldestDirtySequence = 0;
+
+       if (dirtiest > 0) {
+               dev->nonAggressiveSkip = 4;
+       }
+
+       return dirtiest;
+}
+
+static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
+{
+       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo);
+
+       int erasedOk = 0;
+
+       /* If the block is still healthy erase it and mark as clean.
+        * If the block has had a data failure, then retire it.
+        */
+
+       T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
+               (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
+               blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
+
+       bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
+
+       if (!bi->needsRetiring) {
+               yaffs_InvalidateCheckpoint(dev);
+               erasedOk = yaffs_EraseBlockInNAND(dev, blockNo);
+               if (!erasedOk) {
+                       dev->nErasureFailures++;
+                       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                         (TSTR("**>> Erasure failed %d" TENDSTR), blockNo));
+               }
+       }
+
+       if (erasedOk &&
+           ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
+               int i;
+               for (i = 0; i < dev->nChunksPerBlock; i++) {
+                       if (!yaffs_CheckChunkErased
+                           (dev, blockNo * dev->nChunksPerBlock + i)) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  (">>Block %d erasure supposedly OK, but chunk %d not erased"
+                                   TENDSTR), blockNo, i));
+                       }
+               }
+       }
+
+       if (erasedOk) {
+               /* Clean it up... */
+               bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
+               dev->nErasedBlocks++;
+               bi->pagesInUse = 0;
+               bi->softDeletions = 0;
+               bi->hasShrinkHeader = 0;
+               bi->skipErasedCheck = 1;  /* This is clean, so no need to check */
+               bi->gcPrioritise = 0;
+               yaffs_ClearChunkBits(dev, blockNo);
+
+               T(YAFFS_TRACE_ERASE,
+                 (TSTR("Erased block %d" TENDSTR), blockNo));
+       } else {
+               dev->nFreeChunks -= dev->nChunksPerBlock;       /* We lost a block of free space */
+
+               yaffs_RetireBlock(dev, blockNo);
+               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+                 (TSTR("**>> Block %d retired" TENDSTR), blockNo));
+       }
+}
+
+static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
+{
+       int i;
+
+       yaffs_BlockInfo *bi;
+
+       if (dev->nErasedBlocks < 1) {
+               /* Hoosterman we've got a problem.
+                * Can't get space to gc
+                */
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR)));
+
+               return -1;
+       }
+
+       /* Find an empty block. */
+
+       for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
+               dev->allocationBlockFinder++;
+               if (dev->allocationBlockFinder < dev->internalStartBlock
+                   || dev->allocationBlockFinder > dev->internalEndBlock) {
+                       dev->allocationBlockFinder = dev->internalStartBlock;
+               }
+
+               bi = yaffs_GetBlockInfo(dev, dev->allocationBlockFinder);
+
+               if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) {
+                       bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING;
+                       dev->sequenceNumber++;
+                       bi->sequenceNumber = dev->sequenceNumber;
+                       dev->nErasedBlocks--;
+                       T(YAFFS_TRACE_ALLOCATE,
+                         (TSTR("Allocated block %d, seq  %d, %d left" TENDSTR),
+                          dev->allocationBlockFinder, dev->sequenceNumber,
+                          dev->nErasedBlocks));
+                       return dev->allocationBlockFinder;
+               }
+       }
+
+       T(YAFFS_TRACE_ALWAYS,
+         (TSTR
+          ("yaffs tragedy: no more eraased blocks, but there should have been %d"
+           TENDSTR), dev->nErasedBlocks));
+
+       return -1;
+}
+
+
+// Check if there's space to allocate...
+// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
+static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
+{
+       int reservedChunks;
+       int reservedBlocks = dev->nReservedBlocks;
+       int checkpointBlocks;
+
+       checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
+       if(checkpointBlocks < 0)
+               checkpointBlocks = 0;
+
+       reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
+
+       return (dev->nFreeChunks > reservedChunks);
+}
+
+static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr)
+{
+       int retVal;
+       yaffs_BlockInfo *bi;
+
+       if (dev->allocationBlock < 0) {
+               /* Get next block to allocate off */
+               dev->allocationBlock = yaffs_FindBlockForAllocation(dev);
+               dev->allocationPage = 0;
+       }
+
+       if (!useReserve && !yaffs_CheckSpaceForAllocation(dev)) {
+               /* Not enough space to allocate unless we're allowed to use the reserve. */
+               return -1;
+       }
+
+       if (dev->nErasedBlocks < dev->nReservedBlocks
+           && dev->allocationPage == 0) {
+               T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
+       }
+
+       /* Next page please.... */
+       if (dev->allocationBlock >= 0) {
+               bi = yaffs_GetBlockInfo(dev, dev->allocationBlock);
+
+               retVal = (dev->allocationBlock * dev->nChunksPerBlock) +
+                   dev->allocationPage;
+               bi->pagesInUse++;
+               yaffs_SetChunkBit(dev, dev->allocationBlock,
+                                 dev->allocationPage);
+
+               dev->allocationPage++;
+
+               dev->nFreeChunks--;
+
+               /* If the block is full set the state to full */
+               if (dev->allocationPage >= dev->nChunksPerBlock) {
+                       bi->blockState = YAFFS_BLOCK_STATE_FULL;
+                       dev->allocationBlock = -1;
+               }
+
+               if(blockUsedPtr)
+                       *blockUsedPtr = bi;
+
+               return retVal;
+       }
+
+       T(YAFFS_TRACE_ERROR,
+         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
+
+       return -1;
+}
+
+static int yaffs_GetErasedChunks(yaffs_Device * dev)
+{
+       int n;
+
+       n = dev->nErasedBlocks * dev->nChunksPerBlock;
+
+       if (dev->allocationBlock > 0) {
+               n += (dev->nChunksPerBlock - dev->allocationPage);
+       }
+
+       return n;
+
+}
+
+static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
+{
+       int oldChunk;
+       int newChunk;
+       int chunkInBlock;
+       int markNAND;
+       int retVal = YAFFS_OK;
+       int cleanups = 0;
+       int i;
+       int isCheckpointBlock;
+       int matchingChunk;
+
+       int chunksBefore = yaffs_GetErasedChunks(dev);
+       int chunksAfter;
+
+       yaffs_ExtendedTags tags;
+
+       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, block);
+
+       yaffs_Object *object;
+
+       isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
+
+       bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
+
+       T(YAFFS_TRACE_TRACING,
+         (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
+          bi->pagesInUse, bi->hasShrinkHeader));
+
+       /*yaffs_VerifyFreeChunks(dev); */
+
+       bi->hasShrinkHeader = 0;        /* clear the flag so that the block can erase */
+
+       /* Take off the number of soft deleted entries because
+        * they're going to get really deleted during GC.
+        */
+       dev->nFreeChunks -= bi->softDeletions;
+
+       dev->isDoingGC = 1;
+
+       if (isCheckpointBlock ||
+           !yaffs_StillSomeChunkBits(dev, block)) {
+               T(YAFFS_TRACE_TRACING,
+                 (TSTR
+                  ("Collecting block %d that has no chunks in use" TENDSTR),
+                  block));
+               yaffs_BlockBecameDirty(dev, block);
+       } else {
+
+               __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
+
+               yaffs_VerifyBlock(dev,bi,block);
+
+               for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
+                    chunkInBlock < dev->nChunksPerBlock
+                    && yaffs_StillSomeChunkBits(dev, block);
+                    chunkInBlock++, oldChunk++) {
+                       if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) {
+
+                               /* This page is in use and might need to be copied off */
+
+                               markNAND = 1;
+
+                               yaffs_InitialiseTags(&tags);
+
+                               yaffs_ReadChunkWithTagsFromNAND(dev, oldChunk,
+                                                               buffer, &tags);
+
+                               object =
+                                   yaffs_FindObjectByNumber(dev,
+                                                            tags.objectId);
+
+                               T(YAFFS_TRACE_GC_DETAIL,
+                                 (TSTR
+                                  ("Collecting page %d, %d %d %d " TENDSTR),
+                                  chunkInBlock, tags.objectId, tags.chunkId,
+                                  tags.byteCount));
+
+                               if(object && !yaffs_SkipVerification(dev)){
+                                       if(tags.chunkId == 0)
+                                               matchingChunk = object->chunkId;
+                                       else if(object->softDeleted)
+                                               matchingChunk = oldChunk; /* Defeat the test */
+                                       else
+                                               matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
+
+                                       if(oldChunk != matchingChunk)
+                                               T(YAFFS_TRACE_ERROR,
+                                                 (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
+                                                 oldChunk,matchingChunk,tags.objectId, tags.chunkId));
+
+                               }
+
+                               if (!object) {
+                                       T(YAFFS_TRACE_ERROR,
+                                         (TSTR
+                                          ("page %d in gc has no object: %d %d %d "
+                                           TENDSTR), oldChunk,
+                                           tags.objectId, tags.chunkId, tags.byteCount));
+                               }
+
+                               if (object && object->deleted
+                                   && tags.chunkId != 0) {
+                                       /* Data chunk in a deleted file, throw it away
+                                        * It's a soft deleted data chunk,
+                                        * No need to copy this, just forget about it and
+                                        * fix up the object.
+                                        */
+
+                                       object->nDataChunks--;
+
+                                       if (object->nDataChunks <= 0) {
+                                               /* remeber to clean up the object */
+                                               dev->gcCleanupList[cleanups] =
+                                                   tags.objectId;
+                                               cleanups++;
+                                       }
+                                       markNAND = 0;
+                               } else if (0
+                                          /* Todo object && object->deleted && object->nDataChunks == 0 */
+                                          ) {
+                                       /* Deleted object header with no data chunks.
+                                        * Can be discarded and the file deleted.
+                                        */
+                                       object->chunkId = 0;
+                                       yaffs_FreeTnode(object->myDev,
+                                                       object->variant.
+                                                       fileVariant.top);
+                                       object->variant.fileVariant.top = NULL;
+                                       yaffs_DoGenericObjectDeletion(object);
+
+                               } else if (object) {
+                                       /* It's either a data chunk in a live file or
+                                        * an ObjectHeader, so we're interested in it.
+                                        * NB Need to keep the ObjectHeaders of deleted files
+                                        * until the whole file has been deleted off
+                                        */
+                                       tags.serialNumber++;
+
+                                       dev->nGCCopies++;
+
+                                       if (tags.chunkId == 0) {
+                                               /* It is an object Id,
+                                                * We need to nuke the shrinkheader flags first
+                                                * We no longer want the shrinkHeader flag since its work is done
+                                                * and if it is left in place it will mess up scanning.
+                                                * Also, clear out any shadowing stuff
+                                                */
+
+                                               yaffs_ObjectHeader *oh;
+                                               oh = (yaffs_ObjectHeader *)buffer;
+                                               oh->isShrink = 0;
+                                               oh->shadowsObject = -1;
+                                               tags.extraShadows = 0;
+                                               tags.extraIsShrinkHeader = 0;
+
+                                               yaffs_VerifyObjectHeader(object,oh,&tags,1);
+                                       }
+
+                                       newChunk =
+                                           yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
+
+                                       if (newChunk < 0) {
+                                               retVal = YAFFS_FAIL;
+                                       } else {
+
+                                               /* Ok, now fix up the Tnodes etc. */
+
+                                               if (tags.chunkId == 0) {
+                                                       /* It's a header */
+                                                       object->chunkId =  newChunk;
+                                                       object->serial =   tags.serialNumber;
+                                               } else {
+                                                       /* It's a data chunk */
+                                                       yaffs_PutChunkIntoFile
+                                                           (object,
+                                                            tags.chunkId,
+                                                            newChunk, 0);
+                                               }
+                                       }
+                               }
+
+                               yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
+
+                       }
+               }
+
+               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
+
+
+               /* Do any required cleanups */
+               for (i = 0; i < cleanups; i++) {
+                       /* Time to delete the file too */
+                       object =
+                           yaffs_FindObjectByNumber(dev,
+                                                    dev->gcCleanupList[i]);
+                       if (object) {
+                               yaffs_FreeTnode(dev,
+                                               object->variant.fileVariant.
+                                               top);
+                               object->variant.fileVariant.top = NULL;
+                               T(YAFFS_TRACE_GC,
+                                 (TSTR
+                                  ("yaffs: About to finally delete object %d"
+                                   TENDSTR), object->objectId));
+                               yaffs_DoGenericObjectDeletion(object);
+                               object->myDev->nDeletedFiles--;
+                       }
+
+               }
+
+       }
+
+       yaffs_VerifyCollectedBlock(dev,bi,block);
+
+       if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
+               T(YAFFS_TRACE_GC,
+                 (TSTR
+                  ("gc did not increase free chunks before %d after %d"
+                   TENDSTR), chunksBefore, chunksAfter));
+       }
+
+       dev->isDoingGC = 0;
+
+       return YAFFS_OK;
+}
+
+/* New garbage collector
+ * If we're very low on erased blocks then we do aggressive garbage collection
+ * otherwise we do "leasurely" garbage collection.
+ * Aggressive gc looks further (whole array) and will accept less dirty blocks.
+ * Passive gc only inspects smaller areas and will only accept more dirty blocks.
+ *
+ * The idea is to help clear out space in a more spread-out manner.
+ * Dunno if it really does anything useful.
+ */
+static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
+{
+       int block;
+       int aggressive;
+       int gcOk = YAFFS_OK;
+       int maxTries = 0;
+
+       int checkpointBlockAdjust;
+
+       if (dev->isDoingGC) {
+               /* Bail out so we don't get recursive gc */
+               return YAFFS_OK;
+       }
+
+       /* This loop should pass the first time.
+        * We'll only see looping here if the erase of the collected block fails.
+        */
+
+       do {
+               maxTries++;
+
+               checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
+               if(checkpointBlockAdjust < 0)
+                       checkpointBlockAdjust = 0;
+
+               if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) {
+                       /* We need a block soon...*/
+                       aggressive = 1;
+               } else {
+                       /* We're in no hurry */
+                       aggressive = 0;
+               }
+
+               block = yaffs_FindBlockForGarbageCollection(dev, aggressive);
+
+               if (block > 0) {
+                       dev->garbageCollections++;
+                       if (!aggressive) {
+                               dev->passiveGarbageCollections++;
+                       }
+
+                       T(YAFFS_TRACE_GC,
+                         (TSTR
+                          ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
+                          dev->nErasedBlocks, aggressive));
+
+                       gcOk = yaffs_GarbageCollectBlock(dev, block);
+               }
+
+               if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) {
+                       T(YAFFS_TRACE_GC,
+                         (TSTR
+                          ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
+                           TENDSTR), dev->nErasedBlocks, maxTries, block));
+               }
+       } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0)
+                && (maxTries < 2));
+
+       return aggressive ? gcOk : YAFFS_OK;
+}
+
+/*-------------------------  TAGS --------------------------------*/
+
+static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
+                          int chunkInObject)
+{
+       return (tags->chunkId == chunkInObject &&
+               tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0;
+
+}
+
+
+/*-------------------- Data file manipulation -----------------*/
+
+static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
+                                yaffs_ExtendedTags * tags)
+{
+       /*Get the Tnode, then get the level 0 offset chunk offset */
+       yaffs_Tnode *tn;
+       int theChunk = -1;
+       yaffs_ExtendedTags localTags;
+       int retVal = -1;
+
+       yaffs_Device *dev = in->myDev;
+
+       if (!tags) {
+               /* Passed a NULL, so use our own tags space */
+               tags = &localTags;
+       }
+
+       tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
+
+       if (tn) {
+               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
+
+               retVal =
+                   yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
+                                          chunkInInode);
+       }
+       return retVal;
+}
+
+static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode,
+                                         yaffs_ExtendedTags * tags)
+{
+       /* Get the Tnode, then get the level 0 offset chunk offset */
+       yaffs_Tnode *tn;
+       int theChunk = -1;
+       yaffs_ExtendedTags localTags;
+
+       yaffs_Device *dev = in->myDev;
+       int retVal = -1;
+
+       if (!tags) {
+               /* Passed a NULL, so use our own tags space */
+               tags = &localTags;
+       }
+
+       tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
+
+       if (tn) {
+
+               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
+
+               retVal =
+                   yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
+                                          chunkInInode);
+
+               /* Delete the entry in the filestructure (if found) */
+               if (retVal != -1) {
+                       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,0);
+               }
+       } else {
+               /*T(("No level 0 found for %d\n", chunkInInode)); */
+       }
+
+       if (retVal == -1) {
+               /* T(("Could not find %d to delete\n",chunkInInode)); */
+       }
+       return retVal;
+}
+
+#ifdef YAFFS_PARANOID
+
+static int yaffs_CheckFileSanity(yaffs_Object * in)
+{
+       int chunk;
+       int nChunks;
+       int fSize;
+       int failed = 0;
+       int objId;
+       yaffs_Tnode *tn;
+       yaffs_Tags localTags;
+       yaffs_Tags *tags = &localTags;
+       int theChunk;
+       int chunkDeleted;
+
+       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
+               /* T(("Object not a file\n")); */
+               return YAFFS_FAIL;
+       }
+
+       objId = in->objectId;
+       fSize = in->variant.fileVariant.fileSize;
+       nChunks =
+           (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
+
+       for (chunk = 1; chunk <= nChunks; chunk++) {
+               tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant,
+                                          chunk);
+
+               if (tn) {
+
+                       theChunk = yaffs_GetChunkGroupBase(dev,tn,chunk);
+
+                       if (yaffs_CheckChunkBits
+                           (dev, theChunk / dev->nChunksPerBlock,
+                            theChunk % dev->nChunksPerBlock)) {
+
+                               yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk,
+                                                           tags,
+                                                           &chunkDeleted);
+                               if (yaffs_TagsMatch
+                                   (tags, in->objectId, chunk, chunkDeleted)) {
+                                       /* found it; */
+
+                               }
+                       } else {
+
+                               failed = 1;
+                       }
+
+               } else {
+                       /* T(("No level 0 found for %d\n", chunk)); */
+               }
+       }
+
+       return failed ? YAFFS_FAIL : YAFFS_OK;
+}
+
+#endif
+
+static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
+                                 int chunkInNAND, int inScan)
+{
+       /* NB inScan is zero unless scanning.
+        * For forward scanning, inScan is > 0;
+        * for backward scanning inScan is < 0
+        */
+
+       yaffs_Tnode *tn;
+       yaffs_Device *dev = in->myDev;
+       int existingChunk;
+       yaffs_ExtendedTags existingTags;
+       yaffs_ExtendedTags newTags;
+       unsigned existingSerial, newSerial;
+
+       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
+               /* Just ignore an attempt at putting a chunk into a non-file during scanning
+                * If it is not during Scanning then something went wrong!
+                */
+               if (!inScan) {
+                       T(YAFFS_TRACE_ERROR,
+                         (TSTR
+                          ("yaffs tragedy:attempt to put data chunk into a non-file"
+                           TENDSTR)));
+                       YBUG();
+               }
+
+               yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
+               return YAFFS_OK;
+       }
+
+       tn = yaffs_AddOrFindLevel0Tnode(dev,
+                                       &in->variant.fileVariant,
+                                       chunkInInode,
+                                       NULL);
+       if (!tn) {
+               return YAFFS_FAIL;
+       }
+
+       existingChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
+
+       if (inScan != 0) {
+               /* If we're scanning then we need to test for duplicates
+                * NB This does not need to be efficient since it should only ever
+                * happen when the power fails during a write, then only one
+                * chunk should ever be affected.
+                *
+                * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO
+                * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
+                */
+
+               if (existingChunk != 0) {
+                       /* NB Right now existing chunk will not be real chunkId if the device >= 32MB
+                        *    thus we have to do a FindChunkInFile to get the real chunk id.
+                        *
+                        * We have a duplicate now we need to decide which one to use:
+                        *
+                        * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
+                        * Forward scanning YAFFS2: The new one is what we use, dump the old one.
+                        * YAFFS1: Get both sets of tags and compare serial numbers.
+                        */
+
+                       if (inScan > 0) {
+                               /* Only do this for forward scanning */
+                               yaffs_ReadChunkWithTagsFromNAND(dev,
+                                                               chunkInNAND,
+                                                               NULL, &newTags);
+
+                               /* Do a proper find */
+                               existingChunk =
+                                   yaffs_FindChunkInFile(in, chunkInInode,
+                                                         &existingTags);
+                       }
+
+                       if (existingChunk <= 0) {
+                               /*Hoosterman - how did this happen? */
+
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("yaffs tragedy: existing chunk < 0 in scan"
+                                   TENDSTR)));
+
+                       }
+
+                       /* NB The deleted flags should be false, otherwise the chunks will
+                        * not be loaded during a scan
+                        */
+
+                       newSerial = newTags.serialNumber;
+                       existingSerial = existingTags.serialNumber;
+
+                       if ((inScan > 0) &&
+                           (in->myDev->isYaffs2 ||
+                            existingChunk <= 0 ||
+                            ((existingSerial + 1) & 3) == newSerial)) {
+                               /* Forward scanning.
+                                * Use new
+                                * Delete the old one and drop through to update the tnode
+                                */
+                               yaffs_DeleteChunk(dev, existingChunk, 1,
+                                                 __LINE__);
+                       } else {
+                               /* Backward scanning or we want to use the existing one
+                                * Use existing.
+                                * Delete the new one and return early so that the tnode isn't changed
+                                */
+                               yaffs_DeleteChunk(dev, chunkInNAND, 1,
+                                                 __LINE__);
+                               return YAFFS_OK;
+                       }
+               }
+
+       }
+
+       if (existingChunk == 0) {
+               in->nDataChunks++;
+       }
+
+       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,chunkInNAND);
+
+       return YAFFS_OK;
+}
+
+static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
+                                        __u8 * buffer)
+{
+       int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL);
+
+       if (chunkInNAND >= 0) {
+               return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
+                                                      buffer,NULL);
+       } else {
+               T(YAFFS_TRACE_NANDACCESS,
+                 (TSTR("Chunk %d not found zero instead" TENDSTR),
+                  chunkInNAND));
+               /* get sane (zero) data if you read a hole */
+               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
+               return 0;
+       }
+
+}
+
+void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
+{
+       int block;
+       int page;
+       yaffs_ExtendedTags tags;
+       yaffs_BlockInfo *bi;
+
+       if (chunkId <= 0)
+               return;
+
+
+       dev->nDeletions++;
+       block = chunkId / dev->nChunksPerBlock;
+       page = chunkId % dev->nChunksPerBlock;
+
+
+       if(!yaffs_CheckChunkBit(dev,block,page))
+               T(YAFFS_TRACE_VERIFY,
+                       (TSTR("Deleting invalid chunk %d"TENDSTR),
+                        chunkId));
+
+       bi = yaffs_GetBlockInfo(dev, block);
+
+       T(YAFFS_TRACE_DELETION,
+         (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId));
+
+       if (markNAND &&
+           bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->isYaffs2) {
+
+               yaffs_InitialiseTags(&tags);
+
+               tags.chunkDeleted = 1;
+
+               yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags);
+               yaffs_HandleUpdateChunk(dev, chunkId, &tags);
+       } else {
+               dev->nUnmarkedDeletions++;
+       }
+
+       /* Pull out of the management area.
+        * If the whole block became dirty, this will kick off an erasure.
+        */
+       if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING ||
+           bi->blockState == YAFFS_BLOCK_STATE_FULL ||
+           bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
+           bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) {
+               dev->nFreeChunks++;
+
+               yaffs_ClearChunkBit(dev, block, page);
+
+               bi->pagesInUse--;
+
+               if (bi->pagesInUse == 0 &&
+                   !bi->hasShrinkHeader &&
+                   bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING &&
+                   bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+                       yaffs_BlockBecameDirty(dev, block);
+               }
+
+       } else {
+               /* T(("Bad news deleting chunk %d\n",chunkId)); */
+       }
+
+}
+
+static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode,
+                                       const __u8 * buffer, int nBytes,
+                                       int useReserve)
+{
+       /* Find old chunk Need to do this to get serial number
+        * Write new one and patch into tree.
+        * Invalidate old tags.
+        */
+
+       int prevChunkId;
+       yaffs_ExtendedTags prevTags;
+
+       int newChunkId;
+       yaffs_ExtendedTags newTags;
+
+       yaffs_Device *dev = in->myDev;
+
+       yaffs_CheckGarbageCollection(dev);
+
+       /* Get the previous chunk at this location in the file if it exists */
+       prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
+
+       /* Set up new tags */
+       yaffs_InitialiseTags(&newTags);
+
+       newTags.chunkId = chunkInInode;
+       newTags.objectId = in->objectId;
+       newTags.serialNumber =
+           (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
+       newTags.byteCount = nBytes;
+
+       newChunkId =
+           yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
+                                             useReserve);
+
+       if (newChunkId >= 0) {
+               yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0);
+
+               if (prevChunkId >= 0) {
+                       yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__);
+
+               }
+
+               yaffs_CheckFileSanity(in);
+       }
+       return newChunkId;
+
+}
+
+/* UpdateObjectHeader updates the header on NAND for an object.
+ * If name is not NULL, then that new name is used.
+ */
+int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
+                            int isShrink, int shadows)
+{
+
+       yaffs_BlockInfo *bi;
+
+       yaffs_Device *dev = in->myDev;
+
+       int prevChunkId;
+       int retVal = 0;
+       int result = 0;
+
+       int newChunkId;
+       yaffs_ExtendedTags newTags;
+       yaffs_ExtendedTags oldTags;
+
+       __u8 *buffer = NULL;
+       YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
+
+       yaffs_ObjectHeader *oh = NULL;
+
+       yaffs_strcpy(oldName,"silly old name");
+
+       if (!in->fake || force) {
+
+               yaffs_CheckGarbageCollection(dev);
+               yaffs_CheckObjectDetailsLoaded(in);
+
+               buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
+               oh = (yaffs_ObjectHeader *) buffer;
+
+               prevChunkId = in->chunkId;
+
+               if (prevChunkId >= 0) {
+                       result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
+                                                       buffer, &oldTags);
+
+                       yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
+
+                       memcpy(oldName, oh->name, sizeof(oh->name));
+               }
+
+               memset(buffer, 0xFF, dev->nDataBytesPerChunk);
+
+               oh->type = in->variantType;
+               oh->yst_mode = in->yst_mode;
+               oh->shadowsObject = shadows;
+
+#ifdef CONFIG_YAFFS_WINCE
+               oh->win_atime[0] = in->win_atime[0];
+               oh->win_ctime[0] = in->win_ctime[0];
+               oh->win_mtime[0] = in->win_mtime[0];
+               oh->win_atime[1] = in->win_atime[1];
+               oh->win_ctime[1] = in->win_ctime[1];
+               oh->win_mtime[1] = in->win_mtime[1];
+#else
+               oh->yst_uid = in->yst_uid;
+               oh->yst_gid = in->yst_gid;
+               oh->yst_atime = in->yst_atime;
+               oh->yst_mtime = in->yst_mtime;
+               oh->yst_ctime = in->yst_ctime;
+               oh->yst_rdev = in->yst_rdev;
+#endif
+               if (in->parent) {
+                       oh->parentObjectId = in->parent->objectId;
+               } else {
+                       oh->parentObjectId = 0;
+               }
+
+               if (name && *name) {
+                       memset(oh->name, 0, sizeof(oh->name));
+                       yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH);
+               } else if (prevChunkId>=0) {
+                       memcpy(oh->name, oldName, sizeof(oh->name));
+               } else {
+                       memset(oh->name, 0, sizeof(oh->name));
+               }
+
+               oh->isShrink = isShrink;
+
+               switch (in->variantType) {
+               case YAFFS_OBJECT_TYPE_UNKNOWN:
+                       /* Should not happen */
+                       break;
+               case YAFFS_OBJECT_TYPE_FILE:
+                       oh->fileSize =
+                           (oh->parentObjectId == YAFFS_OBJECTID_DELETED
+                            || oh->parentObjectId ==
+                            YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant.
+                           fileVariant.fileSize;
+                       break;
+               case YAFFS_OBJECT_TYPE_HARDLINK:
+                       oh->equivalentObjectId =
+                           in->variant.hardLinkVariant.equivalentObjectId;
+                       break;
+               case YAFFS_OBJECT_TYPE_SPECIAL:
+                       /* Do nothing */
+                       break;
+               case YAFFS_OBJECT_TYPE_DIRECTORY:
+                       /* Do nothing */
+                       break;
+               case YAFFS_OBJECT_TYPE_SYMLINK:
+                       yaffs_strncpy(oh->alias,
+                                     in->variant.symLinkVariant.alias,
+                                     YAFFS_MAX_ALIAS_LENGTH);
+                       oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
+                       break;
+               }
+
+               /* Tags */
+               yaffs_InitialiseTags(&newTags);
+               in->serial++;
+               newTags.chunkId = 0;
+               newTags.objectId = in->objectId;
+               newTags.serialNumber = in->serial;
+
+               /* Add extra info for file header */
+
+               newTags.extraHeaderInfoAvailable = 1;
+               newTags.extraParentObjectId = oh->parentObjectId;
+               newTags.extraFileLength = oh->fileSize;
+               newTags.extraIsShrinkHeader = oh->isShrink;
+               newTags.extraEquivalentObjectId = oh->equivalentObjectId;
+               newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0;
+               newTags.extraObjectType = in->variantType;
+
+               yaffs_VerifyObjectHeader(in,oh,&newTags,1);
+
+               /* Create new chunk in NAND */
+               newChunkId =
+                   yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
+                                                     (prevChunkId >= 0) ? 1 : 0);
+
+               if (newChunkId >= 0) {
+
+                       in->chunkId = newChunkId;
+
+                       if (prevChunkId >= 0) {
+                               yaffs_DeleteChunk(dev, prevChunkId, 1,
+                                                 __LINE__);
+                       }
+
+                       if(!yaffs_ObjectHasCachedWriteData(in))
+                               in->dirty = 0;
+
+                       /* If this was a shrink, then mark the block that the chunk lives on */
+                       if (isShrink) {
+                               bi = yaffs_GetBlockInfo(in->myDev,
+                                                       newChunkId /in->myDev-> nChunksPerBlock);
+                               bi->hasShrinkHeader = 1;
+                       }
+
+               }
+
+               retVal = newChunkId;
+
+       }
+
+       if (buffer)
+               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
+
+       return retVal;
+}
+
+/*------------------------ Short Operations Cache ----------------------------------------
+ *   In many situations where there is no high level buffering (eg WinCE) a lot of
+ *   reads might be short sequential reads, and a lot of writes may be short
+ *   sequential writes. eg. scanning/writing a jpeg file.
+ *   In these cases, a short read/write cache can provide a huge perfomance benefit
+ *   with dumb-as-a-rock code.
+ *   In Linux, the page cache provides read buffering aand the short op cache provides write
+ *   buffering.
+ *
+ *   There are a limited number (~10) of cache chunks per device so that we don't
+ *   need a very intelligent search.
+ */
+
+static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
+{
+       yaffs_Device *dev = obj->myDev;
+       int i;
+       yaffs_ChunkCache *cache;
+       int nCaches = obj->myDev->nShortOpCaches;
+
+       for(i = 0; i < nCaches; i++){
+               cache = &dev->srCache[i];
+               if (cache->object == obj &&
+                   cache->dirty)
+                       return 1;
+       }
+
+       return 0;
+}
+
+
+static void yaffs_FlushFilesChunkCache(yaffs_Object * obj)
+{
+       yaffs_Device *dev = obj->myDev;
+       int lowest = -99;       /* Stop compiler whining. */
+       int i;
+       yaffs_ChunkCache *cache;
+       int chunkWritten = 0;
+       int nCaches = obj->myDev->nShortOpCaches;
+
+       if (nCaches > 0) {
+               do {
+                       cache = NULL;
+
+                       /* Find the dirty cache for this object with the lowest chunk id. */
+                       for (i = 0; i < nCaches; i++) {
+                               if (dev->srCache[i].object == obj &&
+                                   dev->srCache[i].dirty) {
+                                       if (!cache
+                                           || dev->srCache[i].chunkId <
+                                           lowest) {
+                                               cache = &dev->srCache[i];
+                                               lowest = cache->chunkId;
+                                       }
+                               }
+                       }
+
+                       if (cache && !cache->locked) {
+                               /* Write it out and free it up */
+
+                               chunkWritten =
+                                   yaffs_WriteChunkDataToObject(cache->object,
+                                                                cache->chunkId,
+                                                                cache->data,
+                                                                cache->nBytes,
+                                                                1);
+                               cache->dirty = 0;
+                               cache->object = NULL;
+                       }
+
+               } while (cache && chunkWritten > 0);
+
+               if (cache) {
+                       /* Hoosterman, disk full while writing cache out. */
+                       T(YAFFS_TRACE_ERROR,
+                         (TSTR("yaffs tragedy: no space during cache write" TENDSTR)));
+
+               }
+       }
+
+}
+
+/*yaffs_FlushEntireDeviceCache(dev)
+ *
+ *
+ */
+
+void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
+{
+       yaffs_Object *obj;
+       int nCaches = dev->nShortOpCaches;
+       int i;
+
+       /* Find a dirty object in the cache and flush it...
+        * until there are no further dirty objects.
+        */
+       do {
+               obj = NULL;
+               for( i = 0; i < nCaches && !obj; i++) {
+                       if (dev->srCache[i].object &&
+                           dev->srCache[i].dirty)
+                               obj = dev->srCache[i].object;
+
+               }
+               if(obj)
+                       yaffs_FlushFilesChunkCache(obj);
+
+       } while(obj);
+
+}
+
+
+/* Grab us a cache chunk for use.
+ * First look for an empty one.
+ * Then look for the least recently used non-dirty one.
+ * Then look for the least recently used dirty one...., flush and look again.
+ */
+static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
+{
+       int i;
+       int usage;
+       int theOne;
+
+       if (dev->nShortOpCaches > 0) {
+               for (i = 0; i < dev->nShortOpCaches; i++) {
+                       if (!dev->srCache[i].object)
+                               return &dev->srCache[i];
+               }
+
+               return NULL;
+
+               theOne = -1;
+               usage = 0;      /* just to stop the compiler grizzling */
+
+               for (i = 0; i < dev->nShortOpCaches; i++) {
+                       if (!dev->srCache[i].dirty &&
+                           ((dev->srCache[i].lastUse < usage && theOne >= 0) ||
+                            theOne < 0)) {
+                               usage = dev->srCache[i].lastUse;
+                               theOne = i;
+                       }
+               }
+
+
+               return theOne >= 0 ? &dev->srCache[theOne] : NULL;
+       } else {
+               return NULL;
+       }
+
+}
+
+static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev)
+{
+       yaffs_ChunkCache *cache;
+       yaffs_Object *theObj;
+       int usage;
+       int i;
+       int pushout;
+
+       if (dev->nShortOpCaches > 0) {
+               /* Try find a non-dirty one... */
+
+               cache = yaffs_GrabChunkCacheWorker(dev);
+
+               if (!cache) {
+                       /* They were all dirty, find the last recently used object and flush
+                        * its cache, then  find again.
+                        * NB what's here is not very accurate, we actually flush the object
+                        * the last recently used page.
+                        */
+
+                       /* With locking we can't assume we can use entry zero */
+
+                       theObj = NULL;
+                       usage = -1;
+                       cache = NULL;
+                       pushout = -1;
+
+                       for (i = 0; i < dev->nShortOpCaches; i++) {
+                               if (dev->srCache[i].object &&
+                                   !dev->srCache[i].locked &&
+                                   (dev->srCache[i].lastUse < usage || !cache))
+                               {
+                                       usage = dev->srCache[i].lastUse;
+                                       theObj = dev->srCache[i].object;
+                                       cache = &dev->srCache[i];
+                                       pushout = i;
+                               }
+                       }
+
+                       if (!cache || cache->dirty) {
+                               /* Flush and try again */
+                               yaffs_FlushFilesChunkCache(theObj);
+                               cache = yaffs_GrabChunkCacheWorker(dev);
+                       }
+
+               }
+               return cache;
+       } else
+               return NULL;
+
+}
+
+/* Find a cached chunk */
+static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object * obj,
+                                             int chunkId)
+{
+       yaffs_Device *dev = obj->myDev;
+       int i;
+       if (dev->nShortOpCaches > 0) {
+               for (i = 0; i < dev->nShortOpCaches; i++) {
+                       if (dev->srCache[i].object == obj &&
+                           dev->srCache[i].chunkId == chunkId) {
+                               dev->cacheHits++;
+
+                               return &dev->srCache[i];
+                       }
+               }
+       }
+       return NULL;
+}
+
+/* Mark the chunk for the least recently used algorithym */
+static void yaffs_UseChunkCache(yaffs_Device * dev, yaffs_ChunkCache * cache,
+                               int isAWrite)
+{
+
+       if (dev->nShortOpCaches > 0) {
+               if (dev->srLastUse < 0 || dev->srLastUse > 100000000) {
+                       /* Reset the cache usages */
+                       int i;
+                       for (i = 1; i < dev->nShortOpCaches; i++) {
+                               dev->srCache[i].lastUse = 0;
+                       }
+                       dev->srLastUse = 0;
+               }
+
+               dev->srLastUse++;
+
+               cache->lastUse = dev->srLastUse;
+
+               if (isAWrite) {
+                       cache->dirty = 1;
+               }
+       }
+}
+
+/* Invalidate a single cache page.
+ * Do this when a whole page gets written,
+ * ie the short cache for this page is no longer valid.
+ */
+static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId)
+{
+       if (object->myDev->nShortOpCaches > 0) {
+               yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId);
+
+               if (cache) {
+                       cache->object = NULL;
+               }
+       }
+}
+
+/* Invalidate all the cache pages associated with this object
+ * Do this whenever ther file is deleted or resized.
+ */
+static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
+{
+       int i;
+       yaffs_Device *dev = in->myDev;
+
+       if (dev->nShortOpCaches > 0) {
+               /* Invalidate it. */
+               for (i = 0; i < dev->nShortOpCaches; i++) {
+                       if (dev->srCache[i].object == in) {
+                               dev->srCache[i].object = NULL;
+                       }
+               }
+       }
+}
+
+/*--------------------- Checkpointing --------------------*/
+
+
+static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
+{
+       yaffs_CheckpointValidity cp;
+
+       memset(&cp,0,sizeof(cp));
+
+       cp.structType = sizeof(cp);
+       cp.magic = YAFFS_MAGIC;
+       cp.version = YAFFS_CHECKPOINT_VERSION;
+       cp.head = (head) ? 1 : 0;
+
+       return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
+               1 : 0;
+}
+
+static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
+{
+       yaffs_CheckpointValidity cp;
+       int ok;
+
+       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
+
+       if(ok)
+               ok = (cp.structType == sizeof(cp)) &&
+                    (cp.magic == YAFFS_MAGIC) &&
+                    (cp.version == YAFFS_CHECKPOINT_VERSION) &&
+                    (cp.head == ((head) ? 1 : 0));
+       return ok ? 1 : 0;
+}
+
+static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
+                                          yaffs_Device *dev)
+{
+       cp->nErasedBlocks = dev->nErasedBlocks;
+       cp->allocationBlock = dev->allocationBlock;
+       cp->allocationPage = dev->allocationPage;
+       cp->nFreeChunks = dev->nFreeChunks;
+
+       cp->nDeletedFiles = dev->nDeletedFiles;
+       cp->nUnlinkedFiles = dev->nUnlinkedFiles;
+       cp->nBackgroundDeletions = dev->nBackgroundDeletions;
+       cp->sequenceNumber = dev->sequenceNumber;
+       cp->oldestDirtySequence = dev->oldestDirtySequence;
+
+}
+
+static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
+                                          yaffs_CheckpointDevice *cp)
+{
+       dev->nErasedBlocks = cp->nErasedBlocks;
+       dev->allocationBlock = cp->allocationBlock;
+       dev->allocationPage = cp->allocationPage;
+       dev->nFreeChunks = cp->nFreeChunks;
+
+       dev->nDeletedFiles = cp->nDeletedFiles;
+       dev->nUnlinkedFiles = cp->nUnlinkedFiles;
+       dev->nBackgroundDeletions = cp->nBackgroundDeletions;
+       dev->sequenceNumber = cp->sequenceNumber;
+       dev->oldestDirtySequence = cp->oldestDirtySequence;
+}
+
+
+static int yaffs_WriteCheckpointDevice(yaffs_Device *dev)
+{
+       yaffs_CheckpointDevice cp;
+       __u32 nBytes;
+       __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
+
+       int ok;
+
+       /* Write device runtime values*/
+       yaffs_DeviceToCheckpointDevice(&cp,dev);
+       cp.structType = sizeof(cp);
+
+       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
+
+       /* Write block info */
+       if(ok) {
+               nBytes = nBlocks * sizeof(yaffs_BlockInfo);
+               ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
+       }
+
+       /* Write chunk bits */
+       if(ok) {
+               nBytes = nBlocks * dev->chunkBitmapStride;
+               ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
+       }
+       return   ok ? 1 : 0;
+
+}
+
+static int yaffs_ReadCheckpointDevice(yaffs_Device *dev)
+{
+       yaffs_CheckpointDevice cp;
+       __u32 nBytes;
+       __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
+
+       int ok;
+
+       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
+       if(!ok)
+               return 0;
+
+       if(cp.structType != sizeof(cp))
+               return 0;
+
+
+       yaffs_CheckpointDeviceToDevice(dev,&cp);
+
+       nBytes = nBlocks * sizeof(yaffs_BlockInfo);
+
+       ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
+
+       if(!ok)
+               return 0;
+       nBytes = nBlocks * dev->chunkBitmapStride;
+
+       ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
+
+       return ok ? 1 : 0;
+}
+
+static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
+                                          yaffs_Object *obj)
+{
+
+       cp->objectId = obj->objectId;
+       cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
+       cp->chunkId = obj->chunkId;
+       cp->variantType = obj->variantType;
+       cp->deleted = obj->deleted;
+       cp->softDeleted = obj->softDeleted;
+       cp->unlinked = obj->unlinked;
+       cp->fake = obj->fake;
+       cp->renameAllowed = obj->renameAllowed;
+       cp->unlinkAllowed = obj->unlinkAllowed;
+       cp->serial = obj->serial;
+       cp->nDataChunks = obj->nDataChunks;
+
+       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
+               cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
+       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
+               cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
+}
+
+static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
+{
+
+       yaffs_Object *parent;
+
+       obj->objectId = cp->objectId;
+
+       if(cp->parentId)
+               parent = yaffs_FindOrCreateObjectByNumber(
+                                       obj->myDev,
+                                       cp->parentId,
+                                       YAFFS_OBJECT_TYPE_DIRECTORY);
+       else
+               parent = NULL;
+
+       if(parent)
+               yaffs_AddObjectToDirectory(parent, obj);
+
+       obj->chunkId = cp->chunkId;
+       obj->variantType = cp->variantType;
+       obj->deleted = cp->deleted;
+       obj->softDeleted = cp->softDeleted;
+       obj->unlinked = cp->unlinked;
+       obj->fake = cp->fake;
+       obj->renameAllowed = cp->renameAllowed;
+       obj->unlinkAllowed = cp->unlinkAllowed;
+       obj->serial = cp->serial;
+       obj->nDataChunks = cp->nDataChunks;
+
+       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
+               obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
+       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
+               obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
+
+       if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
+               obj->lazyLoaded = 1;
+}
+
+
+
+static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
+                                       __u32 level, int chunkOffset)
+{
+       int i;
+       yaffs_Device *dev = in->myDev;
+       int ok = 1;
+       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
+
+       if (tn) {
+               if (level > 0) {
+
+                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
+                               if (tn->internal[i]) {
+                                       ok = yaffs_CheckpointTnodeWorker(in,
+                                                       tn->internal[i],
+                                                       level - 1,
+                                                       (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
+                               }
+                       }
+               } else if (level == 0) {
+                       __u32 baseOffset = chunkOffset <<  YAFFS_TNODES_LEVEL0_BITS;
+                       /* printf("write tnode at %d\n",baseOffset); */
+                       ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
+                       if(ok)
+                               ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
+               }
+       }
+
+       return ok;
+
+}
+
+static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
+{
+       __u32 endMarker = ~0;
+       int ok = 1;
+
+       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
+               ok = yaffs_CheckpointTnodeWorker(obj,
+                                           obj->variant.fileVariant.top,
+                                           obj->variant.fileVariant.topLevel,
+                                           0);
+               if(ok)
+                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
+                               sizeof(endMarker));
+       }
+
+       return ok ? 1 : 0;
+}
+
+static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
+{
+       __u32 baseChunk;
+       int ok = 1;
+       yaffs_Device *dev = obj->myDev;
+       yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
+       yaffs_Tnode *tn;
+       int nread = 0;
+
+       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
+
+       while(ok && (~baseChunk)){
+               nread++;
+               /* Read level 0 tnode */
+
+
+               /* printf("read  tnode at %d\n",baseChunk); */
+               tn = yaffs_GetTnodeRaw(dev);
+               if(tn)
+                       ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
+                             (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
+               else
+                       ok = 0;
+
+               if(tn && ok){
+                       ok = yaffs_AddOrFindLevel0Tnode(dev,
+                                                       fileStructPtr,
+                                                       baseChunk,
+                                                       tn) ? 1 : 0;
+
+               }
+
+               if(ok)
+                       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
+
+       }
+
+       T(YAFFS_TRACE_CHECKPOINT,(
+               TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
+               nread,baseChunk,ok));
+
+       return ok ? 1 : 0;
+}
+
+
+static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
+{
+       yaffs_Object *obj;
+       yaffs_CheckpointObject cp;
+       int i;
+       int ok = 1;
+       struct list_head *lh;
+
+
+       /* Iterate through the objects in each hash entry,
+        * dumping them to the checkpointing stream.
+        */
+
+        for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
+               list_for_each(lh, &dev->objectBucket[i].list) {
+                       if (lh) {
+                               obj = list_entry(lh, yaffs_Object, hashLink);
+                               if (!obj->deferedFree) {
+                                       yaffs_ObjectToCheckpointObject(&cp,obj);
+                                       cp.structType = sizeof(cp);
+
+                                       T(YAFFS_TRACE_CHECKPOINT,(
+                                               TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
+                                               cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
+
+                                       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
+
+                                       if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
+                                               ok = yaffs_WriteCheckpointTnodes(obj);
+                                       }
+                               }
+                       }
+               }
+        }
+
+        /* Dump end of list */
+       memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
+       cp.structType = sizeof(cp);
+
+       if(ok)
+               ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
+
+       return ok ? 1 : 0;
+}
+
+static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
+{
+       yaffs_Object *obj;
+       yaffs_CheckpointObject cp;
+       int ok = 1;
+       int done = 0;
+       yaffs_Object *hardList = NULL;
+
+       while(ok && !done) {
+               ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
+               if(cp.structType != sizeof(cp)) {
+                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("struct size %d instead of %d ok %d"TENDSTR),
+                               cp.structType,sizeof(cp),ok));
+                       ok = 0;
+               }
+
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
+                       cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
+
+               if(ok && cp.objectId == ~0)
+                       done = 1;
+               else if(ok){
+                       obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
+                       if(obj) {
+                               yaffs_CheckpointObjectToObject(obj,&cp);
+                               if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
+                                       ok = yaffs_ReadCheckpointTnodes(obj);
+                               } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
+                                       obj->hardLinks.next =
+                                                   (struct list_head *)
+                                                   hardList;
+                                       hardList = obj;
+                               }
+
+                       }
+               }
+       }
+
+       if(ok)
+               yaffs_HardlinkFixup(dev,hardList);
+
+       return ok ? 1 : 0;
+}
+
+static int yaffs_WriteCheckpointSum(yaffs_Device *dev)
+{
+       __u32 checkpointSum;
+       int ok;
+
+       yaffs_GetCheckpointSum(dev,&checkpointSum);
+
+       ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
+
+       if(!ok)
+               return 0;
+
+       return 1;
+}
+
+static int yaffs_ReadCheckpointSum(yaffs_Device *dev)
+{
+       __u32 checkpointSum0;
+       __u32 checkpointSum1;
+       int ok;
+
+       yaffs_GetCheckpointSum(dev,&checkpointSum0);
+
+       ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
+
+       if(!ok)
+               return 0;
+
+       if(checkpointSum0 != checkpointSum1)
+               return 0;
+
+       return 1;
+}
+
+
+static int yaffs_WriteCheckpointData(yaffs_Device *dev)
+{
+
+       int ok = 1;
+
+       if(dev->skipCheckpointWrite || !dev->isYaffs2){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
+               ok = 0;
+       }
+
+       if(ok)
+               ok = yaffs_CheckpointOpen(dev,1);
+
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
+               ok = yaffs_WriteCheckpointValidityMarker(dev,1);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint device" TENDSTR)));
+               ok = yaffs_WriteCheckpointDevice(dev);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint objects" TENDSTR)));
+               ok = yaffs_WriteCheckpointObjects(dev);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
+               ok = yaffs_WriteCheckpointValidityMarker(dev,0);
+       }
+
+       if(ok){
+               ok = yaffs_WriteCheckpointSum(dev);
+       }
+
+
+       if(!yaffs_CheckpointClose(dev))
+                ok = 0;
+
+       if(ok)
+               dev->isCheckpointed = 1;
+        else
+               dev->isCheckpointed = 0;
+
+       return dev->isCheckpointed;
+}
+
+static int yaffs_ReadCheckpointData(yaffs_Device *dev)
+{
+       int ok = 1;
+
+       if(dev->skipCheckpointRead || !dev->isYaffs2){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
+               ok = 0;
+       }
+
+       if(ok)
+               ok = yaffs_CheckpointOpen(dev,0); /* open for read */
+
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
+               ok = yaffs_ReadCheckpointValidityMarker(dev,1);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint device" TENDSTR)));
+               ok = yaffs_ReadCheckpointDevice(dev);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
+               ok = yaffs_ReadCheckpointObjects(dev);
+       }
+       if(ok){
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
+               ok = yaffs_ReadCheckpointValidityMarker(dev,0);
+       }
+
+       if(ok){
+               ok = yaffs_ReadCheckpointSum(dev);
+               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
+       }
+
+       if(!yaffs_CheckpointClose(dev))
+               ok = 0;
+
+       if(ok)
+               dev->isCheckpointed = 1;
+        else
+               dev->isCheckpointed = 0;
+
+       return ok ? 1 : 0;
+
+}
+
+static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
+{
+       if(dev->isCheckpointed ||
+          dev->blocksInCheckpoint > 0){
+               dev->isCheckpointed = 0;
+               yaffs_CheckpointInvalidateStream(dev);
+               if(dev->superBlock && dev->markSuperBlockDirty)
+                       dev->markSuperBlockDirty(dev->superBlock);
+       }
+}
+
+
+int yaffs_CheckpointSave(yaffs_Device *dev)
+{
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
+       yaffs_VerifyObjects(dev);
+       yaffs_VerifyBlocks(dev);
+       yaffs_VerifyFreeChunks(dev);
+
+       if(!dev->isCheckpointed) {
+               yaffs_InvalidateCheckpoint(dev);
+               yaffs_WriteCheckpointData(dev);
+       }
+
+       T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
+       return dev->isCheckpointed;
+}
+
+int yaffs_CheckpointRestore(yaffs_Device *dev)
+{
+       int retval;
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
+       retval = yaffs_ReadCheckpointData(dev);
+
+       if(dev->isCheckpointed){
+               yaffs_VerifyObjects(dev);
+               yaffs_VerifyBlocks(dev);
+               yaffs_VerifyFreeChunks(dev);
+       }
+
+       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
+
+       return retval;
+}
+
+/*--------------------- File read/write ------------------------
+ * Read and write have very similar structures.
+ * In general the read/write has three parts to it
+ * An incomplete chunk to start with (if the read/write is not chunk-aligned)
+ * Some complete chunks
+ * An incomplete chunk to end off with
+ *
+ * Curve-balls: the first chunk might also be the last chunk.
+ */
+
+int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
+                          int nBytes)
+{
+
+       int chunk;
+       int start;
+       int nToCopy;
+       int n = nBytes;
+       int nDone = 0;
+       yaffs_ChunkCache *cache;
+
+       yaffs_Device *dev;
+
+       dev = in->myDev;
+
+       while (n > 0) {
+               //chunk = offset / dev->nDataBytesPerChunk + 1;
+               //start = offset % dev->nDataBytesPerChunk;
+               yaffs_AddrToChunk(dev,offset,&chunk,&start);
+               chunk++;
+
+               /* OK now check for the curveball where the start and end are in
+                * the same chunk.
+                */
+               if ((start + n) < dev->nDataBytesPerChunk) {
+                       nToCopy = n;
+               } else {
+                       nToCopy = dev->nDataBytesPerChunk - start;
+               }
+
+               cache = yaffs_FindChunkCache(in, chunk);
+
+               /* If the chunk is already in the cache or it is less than a whole chunk
+                * then use the cache (if there is caching)
+                * else bypass the cache.
+                */
+               if (cache || nToCopy != dev->nDataBytesPerChunk) {
+                       if (dev->nShortOpCaches > 0) {
+
+                               /* If we can't find the data in the cache, then load it up. */
+
+                               if (!cache) {
+                                       cache = yaffs_GrabChunkCache(in->myDev);
+                                       cache->object = in;
+                                       cache->chunkId = chunk;
+                                       cache->dirty = 0;
+                                       cache->locked = 0;
+                                       yaffs_ReadChunkDataFromObject(in, chunk,
+                                                                     cache->
+                                                                     data);
+                                       cache->nBytes = 0;
+                               }
+
+                               yaffs_UseChunkCache(dev, cache, 0);
+
+                               cache->locked = 1;
+
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_UnlockYAFFS(TRUE);
+#endif
+                               memcpy(buffer, &cache->data[start], nToCopy);
+
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_LockYAFFS(TRUE);
+#endif
+                               cache->locked = 0;
+                       } else {
+                               /* Read into the local buffer then copy..*/
+
+                               __u8 *localBuffer =
+                                   yaffs_GetTempBuffer(dev, __LINE__);
+                               yaffs_ReadChunkDataFromObject(in, chunk,
+                                                             localBuffer);
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_UnlockYAFFS(TRUE);
+#endif
+                               memcpy(buffer, &localBuffer[start], nToCopy);
+
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_LockYAFFS(TRUE);
+#endif
+                               yaffs_ReleaseTempBuffer(dev, localBuffer,
+                                                       __LINE__);
+                       }
+
+               } else {
+#ifdef CONFIG_YAFFS_WINCE
+                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
+
+                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
+                        * This is because we otherwise screw up WinCE's memory mapper
+                        */
+                       yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
+
+#ifdef CONFIG_YAFFS_WINCE
+                       yfsd_UnlockYAFFS(TRUE);
+#endif
+                       memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
+
+#ifdef CONFIG_YAFFS_WINCE
+                       yfsd_LockYAFFS(TRUE);
+                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
+#endif
+
+#else
+                       /* A full chunk. Read directly into the supplied buffer. */
+                       yaffs_ReadChunkDataFromObject(in, chunk, buffer);
+#endif
+               }
+
+               n -= nToCopy;
+               offset += nToCopy;
+               buffer += nToCopy;
+               nDone += nToCopy;
+
+       }
+
+       return nDone;
+}
+
+int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
+                         int nBytes, int writeThrough)
+{
+
+       int chunk;
+       int start;
+       int nToCopy;
+       int n = nBytes;
+       int nDone = 0;
+       int nToWriteBack;
+       int startOfWrite = offset;
+       int chunkWritten = 0;
+       int nBytesRead;
+
+       yaffs_Device *dev;
+
+       dev = in->myDev;
+
+       while (n > 0 && chunkWritten >= 0) {
+               //chunk = offset / dev->nDataBytesPerChunk + 1;
+               //start = offset % dev->nDataBytesPerChunk;
+               yaffs_AddrToChunk(dev,offset,&chunk,&start);
+               chunk++;
+
+               /* OK now check for the curveball where the start and end are in
+                * the same chunk.
+                */
+
+               if ((start + n) < dev->nDataBytesPerChunk) {
+                       nToCopy = n;
+
+                       /* Now folks, to calculate how many bytes to write back....
+                        * If we're overwriting and not writing to then end of file then
+                        * we need to write back as much as was there before.
+                        */
+
+                       nBytesRead =
+                           in->variant.fileVariant.fileSize -
+                           ((chunk - 1) * dev->nDataBytesPerChunk);
+
+                       if (nBytesRead > dev->nDataBytesPerChunk) {
+                               nBytesRead = dev->nDataBytesPerChunk;
+                       }
+
+                       nToWriteBack =
+                           (nBytesRead >
+                            (start + n)) ? nBytesRead : (start + n);
+
+               } else {
+                       nToCopy = dev->nDataBytesPerChunk - start;
+                       nToWriteBack = dev->nDataBytesPerChunk;
+               }
+
+               if (nToCopy != dev->nDataBytesPerChunk) {
+                       /* An incomplete start or end chunk (or maybe both start and end chunk) */
+                       if (dev->nShortOpCaches > 0) {
+                               yaffs_ChunkCache *cache;
+                               /* If we can't find the data in the cache, then load the cache */
+                               cache = yaffs_FindChunkCache(in, chunk);
+
+                               if (!cache
+                                   && yaffs_CheckSpaceForAllocation(in->
+                                                                    myDev)) {
+                                       cache = yaffs_GrabChunkCache(in->myDev);
+                                       cache->object = in;
+                                       cache->chunkId = chunk;
+                                       cache->dirty = 0;
+                                       cache->locked = 0;
+                                       yaffs_ReadChunkDataFromObject(in, chunk,
+                                                                     cache->
+                                                                     data);
+                               }
+                               else if(cache &&
+                                       !cache->dirty &&
+                                       !yaffs_CheckSpaceForAllocation(in->myDev)){
+                                       /* Drop the cache if it was a read cache item and
+                                        * no space check has been made for it.
+                                        */
+                                        cache = NULL;
+                               }
+
+                               if (cache) {
+                                       yaffs_UseChunkCache(dev, cache, 1);
+                                       cache->locked = 1;
+#ifdef CONFIG_YAFFS_WINCE
+                                       yfsd_UnlockYAFFS(TRUE);
+#endif
+
+                                       memcpy(&cache->data[start], buffer,
+                                              nToCopy);
+
+#ifdef CONFIG_YAFFS_WINCE
+                                       yfsd_LockYAFFS(TRUE);
+#endif
+                                       cache->locked = 0;
+                                       cache->nBytes = nToWriteBack;
+
+                                       if (writeThrough) {
+                                               chunkWritten =
+                                                   yaffs_WriteChunkDataToObject
+                                                   (cache->object,
+                                                    cache->chunkId,
+                                                    cache->data, cache->nBytes,
+                                                    1);
+                                               cache->dirty = 0;
+                                       }
+
+                               } else {
+                                       chunkWritten = -1;      /* fail the write */
+                               }
+                       } else {
+                               /* An incomplete start or end chunk (or maybe both start and end chunk)
+                                * Read into the local buffer then copy, then copy over and write back.
+                                */
+
+                               __u8 *localBuffer =
+                                   yaffs_GetTempBuffer(dev, __LINE__);
+
+                               yaffs_ReadChunkDataFromObject(in, chunk,
+                                                             localBuffer);
+
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_UnlockYAFFS(TRUE);
+#endif
+
+                               memcpy(&localBuffer[start], buffer, nToCopy);
+
+#ifdef CONFIG_YAFFS_WINCE
+                               yfsd_LockYAFFS(TRUE);
+#endif
+                               chunkWritten =
+                                   yaffs_WriteChunkDataToObject(in, chunk,
+                                                                localBuffer,
+                                                                nToWriteBack,
+                                                                0);
+
+                               yaffs_ReleaseTempBuffer(dev, localBuffer,
+                                                       __LINE__);
+
+                       }
+
+               } else {
+
+#ifdef CONFIG_YAFFS_WINCE
+                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
+                        * This is because we otherwise screw up WinCE's memory mapper
+                        */
+                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
+#ifdef CONFIG_YAFFS_WINCE
+                       yfsd_UnlockYAFFS(TRUE);
+#endif
+                       memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
+#ifdef CONFIG_YAFFS_WINCE
+                       yfsd_LockYAFFS(TRUE);
+#endif
+                       chunkWritten =
+                           yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
+                                                        dev->nDataBytesPerChunk,
+                                                        0);
+                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
+#else
+                       /* A full chunk. Write directly from the supplied buffer. */
+                       chunkWritten =
+                           yaffs_WriteChunkDataToObject(in, chunk, buffer,
+                                                        dev->nDataBytesPerChunk,
+                                                        0);
+#endif
+                       /* Since we've overwritten the cached data, we better invalidate it. */
+                       yaffs_InvalidateChunkCache(in, chunk);
+               }
+
+               if (chunkWritten >= 0) {
+                       n -= nToCopy;
+                       offset += nToCopy;
+                       buffer += nToCopy;
+                       nDone += nToCopy;
+               }
+
+       }
+
+       /* Update file object */
+
+       if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) {
+               in->variant.fileVariant.fileSize = (startOfWrite + nDone);
+       }
+
+       in->dirty = 1;
+
+       return nDone;
+}
+
+
+/* ---------------------- File resizing stuff ------------------ */
+
+static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
+{
+
+       yaffs_Device *dev = in->myDev;
+       int oldFileSize = in->variant.fileVariant.fileSize;
+
+       int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk;
+
+       int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) /
+           dev->nDataBytesPerChunk;
+       int i;
+       int chunkId;
+
+       /* Delete backwards so that we don't end up with holes if
+        * power is lost part-way through the operation.
+        */
+       for (i = lastDel; i >= startDel; i--) {
+               /* NB this could be optimised somewhat,
+                * eg. could retrieve the tags and write them without
+                * using yaffs_DeleteChunk
+                */
+
+               chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL);
+               if (chunkId > 0) {
+                       if (chunkId <
+                           (dev->internalStartBlock * dev->nChunksPerBlock)
+                           || chunkId >=
+                           ((dev->internalEndBlock +
+                             1) * dev->nChunksPerBlock)) {
+                               T(YAFFS_TRACE_ALWAYS,
+                                 (TSTR("Found daft chunkId %d for %d" TENDSTR),
+                                  chunkId, i));
+                       } else {
+                               in->nDataChunks--;
+                               yaffs_DeleteChunk(dev, chunkId, 1, __LINE__);
+                       }
+               }
+       }
+
+}
+
+int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
+{
+
+       int oldFileSize = in->variant.fileVariant.fileSize;
+       int newSizeOfPartialChunk;
+       int newFullChunks;
+
+       yaffs_Device *dev = in->myDev;
+
+       yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
+
+       yaffs_FlushFilesChunkCache(in);
+       yaffs_InvalidateWholeChunkCache(in);
+
+       yaffs_CheckGarbageCollection(dev);
+
+       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
+               return yaffs_GetFileSize(in);
+       }
+
+       if (newSize == oldFileSize) {
+               return oldFileSize;
+       }
+
+       if (newSize < oldFileSize) {
+
+               yaffs_PruneResizedChunks(in, newSize);
+
+               if (newSizeOfPartialChunk != 0) {
+                       int lastChunk = 1 + newFullChunks;
+
+                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
+
+                       /* Got to read and rewrite the last chunk with its new size and zero pad */
+                       yaffs_ReadChunkDataFromObject(in, lastChunk,
+                                                     localBuffer);
+
+                       memset(localBuffer + newSizeOfPartialChunk, 0,
+                              dev->nDataBytesPerChunk - newSizeOfPartialChunk);
+
+                       yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer,
+                                                    newSizeOfPartialChunk, 1);
+
+                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
+               }
+
+               in->variant.fileVariant.fileSize = newSize;
+
+               yaffs_PruneFileStructure(dev, &in->variant.fileVariant);
+       } else {
+               /* newsSize > oldFileSize */
+               in->variant.fileVariant.fileSize = newSize;
+       }
+
+
+
+       /* Write a new object header.
+        * show we've shrunk the file, if need be
+        * Do this only if the file is not in the deleted directories.
+        */
+       if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
+           in->parent->objectId != YAFFS_OBJECTID_DELETED) {
+               yaffs_UpdateObjectHeader(in, NULL, 0,
+                                        (newSize < oldFileSize) ? 1 : 0, 0);
+       }
+
+       return newSize;
+}
+
+loff_t yaffs_GetFileSize(yaffs_Object * obj)
+{
+       obj = yaffs_GetEquivalentObject(obj);
+
+       switch (obj->variantType) {
+       case YAFFS_OBJECT_TYPE_FILE:
+               return obj->variant.fileVariant.fileSize;
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+               return yaffs_strlen(obj->variant.symLinkVariant.alias);
+       default:
+               return 0;
+       }
+}
+
+
+
+int yaffs_FlushFile(yaffs_Object * in, int updateTime)
+{
+       int retVal;
+       if (in->dirty) {
+               yaffs_FlushFilesChunkCache(in);
+               if (updateTime) {
+#ifdef CONFIG_YAFFS_WINCE
+                       yfsd_WinFileTimeNow(in->win_mtime);
+#else
+
+                       in->yst_mtime = Y_CURRENT_TIME;
+
+#endif
+               }
+
+               retVal =
+                   (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
+                    0) ? YAFFS_OK : YAFFS_FAIL;
+       } else {
+               retVal = YAFFS_OK;
+       }
+
+       return retVal;
+
+}
+
+static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
+{
+
+       /* First off, invalidate the file's data in the cache, without flushing. */
+       yaffs_InvalidateWholeChunkCache(in);
+
+       if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
+               /* Move to the unlinked directory so we have a record that it was deleted. */
+               yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
+
+       }
+
+       yaffs_RemoveObjectFromDirectory(in);
+       yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
+       in->chunkId = -1;
+
+       yaffs_FreeObject(in);
+       return YAFFS_OK;
+
+}
+
+/* yaffs_DeleteFile deletes the whole file data
+ * and the inode associated with the file.
+ * It does not delete the links associated with the file.
+ */
+static int yaffs_UnlinkFile(yaffs_Object * in)
+{
+
+       int retVal;
+       int immediateDeletion = 0;
+
+       if (1) {
+#ifdef __KERNEL__
+               if (!in->myInode) {
+                       immediateDeletion = 1;
+
+               }
+#else
+               if (in->inUse <= 0) {
+                       immediateDeletion = 1;
+
+               }
+#endif
+               if (immediateDeletion) {
+                       retVal =
+                           yaffs_ChangeObjectName(in, in->myDev->deletedDir,
+                                                  "deleted", 0, 0);
+                       T(YAFFS_TRACE_TRACING,
+                         (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
+                          in->objectId));
+                       in->deleted = 1;
+                       in->myDev->nDeletedFiles++;
+                       if (0 && in->myDev->isYaffs2) {
+                               yaffs_ResizeFile(in, 0);
+                       }
+                       yaffs_SoftDeleteFile(in);
+               } else {
+                       retVal =
+                           yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
+                                                  "unlinked", 0, 0);
+               }
+
+       }
+       return retVal;
+}
+
+int yaffs_DeleteFile(yaffs_Object * in)
+{
+       int retVal = YAFFS_OK;
+
+       if (in->nDataChunks > 0) {
+               /* Use soft deletion if there is data in the file */
+               if (!in->unlinked) {
+                       retVal = yaffs_UnlinkFile(in);
+               }
+               if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
+                       in->deleted = 1;
+                       in->myDev->nDeletedFiles++;
+                       yaffs_SoftDeleteFile(in);
+               }
+               return in->deleted ? YAFFS_OK : YAFFS_FAIL;
+       } else {
+               /* The file has no data chunks so we toss it immediately */
+               yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
+               in->variant.fileVariant.top = NULL;
+               yaffs_DoGenericObjectDeletion(in);
+
+               return YAFFS_OK;
+       }
+}
+
+static int yaffs_DeleteDirectory(yaffs_Object * in)
+{
+       /* First check that the directory is empty. */
+       if (list_empty(&in->variant.directoryVariant.children)) {
+               return yaffs_DoGenericObjectDeletion(in);
+       }
+
+       return YAFFS_FAIL;
+
+}
+
+static int yaffs_DeleteSymLink(yaffs_Object * in)
+{
+       YFREE(in->variant.symLinkVariant.alias);
+
+       return yaffs_DoGenericObjectDeletion(in);
+}
+
+static int yaffs_DeleteHardLink(yaffs_Object * in)
+{
+       /* remove this hardlink from the list assocaited with the equivalent
+        * object
+        */
+       list_del(&in->hardLinks);
+       return yaffs_DoGenericObjectDeletion(in);
+}
+
+static void yaffs_DestroyObject(yaffs_Object * obj)
+{
+       switch (obj->variantType) {
+       case YAFFS_OBJECT_TYPE_FILE:
+               yaffs_DeleteFile(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_DIRECTORY:
+               yaffs_DeleteDirectory(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+               yaffs_DeleteSymLink(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_HARDLINK:
+               yaffs_DeleteHardLink(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_SPECIAL:
+               yaffs_DoGenericObjectDeletion(obj);
+               break;
+       case YAFFS_OBJECT_TYPE_UNKNOWN:
+               break;          /* should not happen. */
+       }
+}
+
+static int yaffs_UnlinkWorker(yaffs_Object * obj)
+{
+
+       if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
+               return yaffs_DeleteHardLink(obj);
+       } else if (!list_empty(&obj->hardLinks)) {
+               /* Curve ball: We're unlinking an object that has a hardlink.
+                *
+                * This problem arises because we are not strictly following
+                * The Linux link/inode model.
+                *
+                * We can't really delete the object.
+                * Instead, we do the following:
+                * - Select a hardlink.
+                * - Unhook it from the hard links
+                * - Unhook it from its parent directory (so that the rename can work)
+                * - Rename the object to the hardlink's name.
+                * - Delete the hardlink
+                */
+
+               yaffs_Object *hl;
+               int retVal;
+               YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
+
+               hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
+
+               list_del_init(&hl->hardLinks);
+               list_del_init(&hl->siblings);
+
+               yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
+
+               retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
+
+               if (retVal == YAFFS_OK) {
+                       retVal = yaffs_DoGenericObjectDeletion(hl);
+               }
+               return retVal;
+
+       } else {
+               switch (obj->variantType) {
+               case YAFFS_OBJECT_TYPE_FILE:
+                       return yaffs_UnlinkFile(obj);
+                       break;
+               case YAFFS_OBJECT_TYPE_DIRECTORY:
+                       return yaffs_DeleteDirectory(obj);
+                       break;
+               case YAFFS_OBJECT_TYPE_SYMLINK:
+                       return yaffs_DeleteSymLink(obj);
+                       break;
+               case YAFFS_OBJECT_TYPE_SPECIAL:
+                       return yaffs_DoGenericObjectDeletion(obj);
+                       break;
+               case YAFFS_OBJECT_TYPE_HARDLINK:
+               case YAFFS_OBJECT_TYPE_UNKNOWN:
+               default:
+                       return YAFFS_FAIL;
+               }
+       }
+}
+
+
+static int yaffs_UnlinkObject( yaffs_Object *obj)
+{
+
+       if (obj && obj->unlinkAllowed) {
+               return yaffs_UnlinkWorker(obj);
+       }
+
+       return YAFFS_FAIL;
+
+}
+int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name)
+{
+       yaffs_Object *obj;
+
+       obj = yaffs_FindObjectByName(dir, name);
+       return yaffs_UnlinkObject(obj);
+}
+
+/*----------------------- Initialisation Scanning ---------------------- */
+
+static void yaffs_HandleShadowedObject(yaffs_Device * dev, int objId,
+                                      int backwardScanning)
+{
+       yaffs_Object *obj;
+
+       if (!backwardScanning) {
+               /* Handle YAFFS1 forward scanning case
+                * For YAFFS1 we always do the deletion
+                */
+
+       } else {
+               /* Handle YAFFS2 case (backward scanning)
+                * If the shadowed object exists then ignore.
+                */
+               if (yaffs_FindObjectByNumber(dev, objId)) {
+                       return;
+               }
+       }
+
+       /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc.
+        * We put it in unlinked dir to be cleaned up after the scanning
+        */
+       obj =
+           yaffs_FindOrCreateObjectByNumber(dev, objId,
+                                            YAFFS_OBJECT_TYPE_FILE);
+       yaffs_AddObjectToDirectory(dev->unlinkedDir, obj);
+       obj->variant.fileVariant.shrinkSize = 0;
+       obj->valid = 1;         /* So that we don't read any other info for this file */
+
+}
+
+typedef struct {
+       int seq;
+       int block;
+} yaffs_BlockIndex;
+
+
+static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
+{
+       yaffs_Object *hl;
+       yaffs_Object *in;
+
+       while (hardList) {
+               hl = hardList;
+               hardList = (yaffs_Object *) (hardList->hardLinks.next);
+
+               in = yaffs_FindObjectByNumber(dev,
+                                             hl->variant.hardLinkVariant.
+                                             equivalentObjectId);
+
+               if (in) {
+                       /* Add the hardlink pointers */
+                       hl->variant.hardLinkVariant.equivalentObject = in;
+                       list_add(&hl->hardLinks, &in->hardLinks);
+               } else {
+                       /* Todo Need to report/handle this better.
+                        * Got a problem... hardlink to a non-existant object
+                        */
+                       hl->variant.hardLinkVariant.equivalentObject = NULL;
+                       INIT_LIST_HEAD(&hl->hardLinks);
+
+               }
+
+       }
+
+}
+
+
+
+
+
+static int ybicmp(const void *a, const void *b){
+    register int aseq = ((yaffs_BlockIndex *)a)->seq;
+    register int bseq = ((yaffs_BlockIndex *)b)->seq;
+    register int ablock = ((yaffs_BlockIndex *)a)->block;
+    register int bblock = ((yaffs_BlockIndex *)b)->block;
+    if( aseq == bseq )
+        return ablock - bblock;
+    else
+        return aseq - bseq;
+
+}
+
+static int yaffs_Scan(yaffs_Device * dev)
+{
+       yaffs_ExtendedTags tags;
+       int blk;
+       int blockIterator;
+       int startIterator;
+       int endIterator;
+       int nBlocksToScan = 0;
+       int result;
+
+       int chunk;
+       int c;
+       int deleted;
+       yaffs_BlockState state;
+       yaffs_Object *hardList = NULL;
+       yaffs_BlockInfo *bi;
+       int sequenceNumber;
+       yaffs_ObjectHeader *oh;
+       yaffs_Object *in;
+       yaffs_Object *parent;
+       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
+
+       int alloc_failed = 0;
+
+
+       __u8 *chunkData;
+
+       yaffs_BlockIndex *blockIndex = NULL;
+
+       if (dev->isYaffs2) {
+               T(YAFFS_TRACE_SCAN,
+                 (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       //TODO  Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
+
+       T(YAFFS_TRACE_SCAN,
+         (TSTR("yaffs_Scan starts  intstartblk %d intendblk %d..." TENDSTR),
+          dev->internalStartBlock, dev->internalEndBlock));
+
+       chunkData = yaffs_GetTempBuffer(dev, __LINE__);
+
+       dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
+
+       if (dev->isYaffs2) {
+               blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
+               if(!blockIndex)
+                       return YAFFS_FAIL;
+       }
+
+       /* Scan all the blocks to determine their state */
+       for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
+               bi = yaffs_GetBlockInfo(dev, blk);
+               yaffs_ClearChunkBits(dev, blk);
+               bi->pagesInUse = 0;
+               bi->softDeletions = 0;
+
+               yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber);
+
+               bi->blockState = state;
+               bi->sequenceNumber = sequenceNumber;
+
+               T(YAFFS_TRACE_SCAN_DEBUG,
+                 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
+                  state, sequenceNumber));
+
+               if (state == YAFFS_BLOCK_STATE_DEAD) {
+                       T(YAFFS_TRACE_BAD_BLOCKS,
+                         (TSTR("block %d is bad" TENDSTR), blk));
+               } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
+                       T(YAFFS_TRACE_SCAN_DEBUG,
+                         (TSTR("Block empty " TENDSTR)));
+                       dev->nErasedBlocks++;
+                       dev->nFreeChunks += dev->nChunksPerBlock;
+               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+
+                       /* Determine the highest sequence number */
+                       if (dev->isYaffs2 &&
+                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
+                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
+
+                               blockIndex[nBlocksToScan].seq = sequenceNumber;
+                               blockIndex[nBlocksToScan].block = blk;
+
+                               nBlocksToScan++;
+
+                               if (sequenceNumber >= dev->sequenceNumber) {
+                                       dev->sequenceNumber = sequenceNumber;
+                               }
+                       } else if (dev->isYaffs2) {
+                               /* TODO: Nasty sequence number! */
+                               T(YAFFS_TRACE_SCAN,
+                                 (TSTR
+                                  ("Block scanning block %d has bad sequence number %d"
+                                   TENDSTR), blk, sequenceNumber));
+
+                       }
+               }
+       }
+
+       /* Sort the blocks
+        * Dungy old bubble sort for now...
+        */
+       if (dev->isYaffs2) {
+               yaffs_BlockIndex temp;
+               int i;
+               int j;
+
+               for (i = 0; i < nBlocksToScan; i++)
+                       for (j = i + 1; j < nBlocksToScan; j++)
+                               if (blockIndex[i].seq > blockIndex[j].seq) {
+                                       temp = blockIndex[j];
+                                       blockIndex[j] = blockIndex[i];
+                                       blockIndex[i] = temp;
+                               }
+       }
+
+       /* Now scan the blocks looking at the data. */
+       if (dev->isYaffs2) {
+               startIterator = 0;
+               endIterator = nBlocksToScan - 1;
+               T(YAFFS_TRACE_SCAN_DEBUG,
+                 (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
+       } else {
+               startIterator = dev->internalStartBlock;
+               endIterator = dev->internalEndBlock;
+       }
+
+       /* For each block.... */
+       for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
+            blockIterator++) {
+
+               if (dev->isYaffs2) {
+                       /* get the block to scan in the correct order */
+                       blk = blockIndex[blockIterator].block;
+               } else {
+                       blk = blockIterator;
+               }
+
+               bi = yaffs_GetBlockInfo(dev, blk);
+               state = bi->blockState;
+
+               deleted = 0;
+
+               /* For each chunk in each block that needs scanning....*/
+               for (c = 0; !alloc_failed && c < dev->nChunksPerBlock &&
+                    state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) {
+                       /* Read the tags and decide what to do */
+                       chunk = blk * dev->nChunksPerBlock + c;
+
+                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+                                                       &tags);
+
+                       /* Let's have a good look at this chunk... */
+
+                       if (!dev->isYaffs2 && tags.chunkDeleted) {
+                               /* YAFFS1 only...
+                                * A deleted chunk
+                                */
+                               deleted++;
+                               dev->nFreeChunks++;
+                               /*T((" %d %d deleted\n",blk,c)); */
+                       } else if (!tags.chunkUsed) {
+                               /* An unassigned chunk in the block
+                                * This means that either the block is empty or
+                                * this is the one being allocated from
+                                */
+
+                               if (c == 0) {
+                                       /* We're looking at the first chunk in the block so the block is unused */
+                                       state = YAFFS_BLOCK_STATE_EMPTY;
+                                       dev->nErasedBlocks++;
+                               } else {
+                                       /* this is the block being allocated from */
+                                       T(YAFFS_TRACE_SCAN,
+                                         (TSTR
+                                          (" Allocating from %d %d" TENDSTR),
+                                          blk, c));
+                                       state = YAFFS_BLOCK_STATE_ALLOCATING;
+                                       dev->allocationBlock = blk;
+                                       dev->allocationPage = c;
+                                       dev->allocationBlockFinder = blk;
+                                       /* Set it to here to encourage the allocator to go forth from here. */
+
+                                       /* Yaffs2 sanity check:
+                                        * This should be the one with the highest sequence number
+                                        */
+                                       if (dev->isYaffs2
+                                           && (dev->sequenceNumber !=
+                                               bi->sequenceNumber)) {
+                                               T(YAFFS_TRACE_ALWAYS,
+                                                 (TSTR
+                                                  ("yaffs: Allocation block %d was not highest sequence id:"
+                                                   " block seq = %d, dev seq = %d"
+                                                   TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
+                                       }
+                               }
+
+                               dev->nFreeChunks += (dev->nChunksPerBlock - c);
+                       } else if (tags.chunkId > 0) {
+                               /* chunkId > 0 so it is a data chunk... */
+                               unsigned int endpos;
+
+                               yaffs_SetChunkBit(dev, blk, c);
+                               bi->pagesInUse++;
+
+                               in = yaffs_FindOrCreateObjectByNumber(dev,
+                                                                     tags.
+                                                                     objectId,
+                                                                     YAFFS_OBJECT_TYPE_FILE);
+                               /* PutChunkIntoFile checks for a clash (two data chunks with
+                                * the same chunkId).
+                                */
+
+                               if(!in)
+                                       alloc_failed = 1;
+
+                               if(in){
+                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
+                                               alloc_failed = 1;
+                               }
+
+                               endpos =
+                                   (tags.chunkId - 1) * dev->nDataBytesPerChunk +
+                                   tags.byteCount;
+                               if (in &&
+                                   in->variantType == YAFFS_OBJECT_TYPE_FILE
+                                   && in->variant.fileVariant.scannedFileSize <
+                                   endpos) {
+                                       in->variant.fileVariant.
+                                           scannedFileSize = endpos;
+                                       if (!dev->useHeaderFileSize) {
+                                               in->variant.fileVariant.
+                                                   fileSize =
+                                                   in->variant.fileVariant.
+                                                   scannedFileSize;
+                                       }
+
+                               }
+                               /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId));   */
+                       } else {
+                               /* chunkId == 0, so it is an ObjectHeader.
+                                * Thus, we read in the object header and make the object
+                                */
+                               yaffs_SetChunkBit(dev, blk, c);
+                               bi->pagesInUse++;
+
+                               result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
+                                                               chunkData,
+                                                               NULL);
+
+                               oh = (yaffs_ObjectHeader *) chunkData;
+
+                               in = yaffs_FindObjectByNumber(dev,
+                                                             tags.objectId);
+                               if (in && in->variantType != oh->type) {
+                                       /* This should not happen, but somehow
+                                        * Wev'e ended up with an objectId that has been reused but not yet
+                                        * deleted, and worse still it has changed type. Delete the old object.
+                                        */
+
+                                       yaffs_DestroyObject(in);
+
+                                       in = 0;
+                               }
+
+                               in = yaffs_FindOrCreateObjectByNumber(dev,
+                                                                     tags.
+                                                                     objectId,
+                                                                     oh->type);
+
+                               if(!in)
+                                       alloc_failed = 1;
+
+                               if (in && oh->shadowsObject > 0) {
+                                       yaffs_HandleShadowedObject(dev,
+                                                                  oh->
+                                                                  shadowsObject,
+                                                                  0);
+                               }
+
+                               if (in && in->valid) {
+                                       /* We have already filled this one. We have a duplicate and need to resolve it. */
+
+                                       unsigned existingSerial = in->serial;
+                                       unsigned newSerial = tags.serialNumber;
+
+                                       if (dev->isYaffs2 ||
+                                           ((existingSerial + 1) & 3) ==
+                                           newSerial) {
+                                               /* Use new one - destroy the exisiting one */
+                                               yaffs_DeleteChunk(dev,
+                                                                 in->chunkId,
+                                                                 1, __LINE__);
+                                               in->valid = 0;
+                                       } else {
+                                               /* Use existing - destroy this one. */
+                                               yaffs_DeleteChunk(dev, chunk, 1,
+                                                                 __LINE__);
+                                       }
+                               }
+
+                               if (in && !in->valid &&
+                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
+                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) {
+                                       /* We only load some info, don't fiddle with directory structure */
+                                       in->valid = 1;
+                                       in->variantType = oh->type;
+
+                                       in->yst_mode = oh->yst_mode;
+#ifdef CONFIG_YAFFS_WINCE
+                                       in->win_atime[0] = oh->win_atime[0];
+                                       in->win_ctime[0] = oh->win_ctime[0];
+                                       in->win_mtime[0] = oh->win_mtime[0];
+                                       in->win_atime[1] = oh->win_atime[1];
+                                       in->win_ctime[1] = oh->win_ctime[1];
+                                       in->win_mtime[1] = oh->win_mtime[1];
+#else
+                                       in->yst_uid = oh->yst_uid;
+                                       in->yst_gid = oh->yst_gid;
+                                       in->yst_atime = oh->yst_atime;
+                                       in->yst_mtime = oh->yst_mtime;
+                                       in->yst_ctime = oh->yst_ctime;
+                                       in->yst_rdev = oh->yst_rdev;
+#endif
+                                       in->chunkId = chunk;
+
+                               } else if (in && !in->valid) {
+                                       /* we need to load this info */
+
+                                       in->valid = 1;
+                                       in->variantType = oh->type;
+
+                                       in->yst_mode = oh->yst_mode;
+#ifdef CONFIG_YAFFS_WINCE
+                                       in->win_atime[0] = oh->win_atime[0];
+                                       in->win_ctime[0] = oh->win_ctime[0];
+                                       in->win_mtime[0] = oh->win_mtime[0];
+                                       in->win_atime[1] = oh->win_atime[1];
+                                       in->win_ctime[1] = oh->win_ctime[1];
+                                       in->win_mtime[1] = oh->win_mtime[1];
+#else
+                                       in->yst_uid = oh->yst_uid;
+                                       in->yst_gid = oh->yst_gid;
+                                       in->yst_atime = oh->yst_atime;
+                                       in->yst_mtime = oh->yst_mtime;
+                                       in->yst_ctime = oh->yst_ctime;
+                                       in->yst_rdev = oh->yst_rdev;
+#endif
+                                       in->chunkId = chunk;
+
+                                       yaffs_SetObjectName(in, oh->name);
+                                       in->dirty = 0;
+
+                                       /* directory stuff...
+                                        * hook up to parent
+                                        */
+
+                                       parent =
+                                           yaffs_FindOrCreateObjectByNumber
+                                           (dev, oh->parentObjectId,
+                                            YAFFS_OBJECT_TYPE_DIRECTORY);
+                                       if (parent->variantType ==
+                                           YAFFS_OBJECT_TYPE_UNKNOWN) {
+                                               /* Set up as a directory */
+                                               parent->variantType =
+                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
+                                               INIT_LIST_HEAD(&parent->variant.
+                                                              directoryVariant.
+                                                              children);
+                                       } else if (parent->variantType !=
+                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
+                                       {
+                                               /* Hoosterman, another problem....
+                                                * We're trying to use a non-directory as a directory
+                                                */
+
+                                               T(YAFFS_TRACE_ERROR,
+                                                 (TSTR
+                                                  ("yaffs tragedy: attempting to use non-directory as"
+                                                   " a directory in scan. Put in lost+found."
+                                                   TENDSTR)));
+                                               parent = dev->lostNFoundDir;
+                                       }
+
+                                       yaffs_AddObjectToDirectory(parent, in);
+
+                                       if (0 && (parent == dev->deletedDir ||
+                                                 parent == dev->unlinkedDir)) {
+                                               in->deleted = 1;        /* If it is unlinked at start up then it wants deleting */
+                                               dev->nDeletedFiles++;
+                                       }
+                                       /* Note re hardlinks.
+                                        * Since we might scan a hardlink before its equivalent object is scanned
+                                        * we put them all in a list.
+                                        * After scanning is complete, we should have all the objects, so we run through this
+                                        * list and fix up all the chains.
+                                        */
+
+                                       switch (in->variantType) {
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
+                                               /* Todo got a problem */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_FILE:
+                                               if (dev->isYaffs2
+                                                   && oh->isShrink) {
+                                                       /* Prune back the shrunken chunks */
+                                                       yaffs_PruneResizedChunks
+                                                           (in, oh->fileSize);
+                                                       /* Mark the block as having a shrinkHeader */
+                                                       bi->hasShrinkHeader = 1;
+                                               }
+
+                                               if (dev->useHeaderFileSize)
+
+                                                       in->variant.fileVariant.
+                                                           fileSize =
+                                                           oh->fileSize;
+
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_HARDLINK:
+                                               in->variant.hardLinkVariant.
+                                                   equivalentObjectId =
+                                                   oh->equivalentObjectId;
+                                               in->hardLinks.next =
+                                                   (struct list_head *)
+                                                   hardList;
+                                               hardList = in;
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_DIRECTORY:
+                                               /* Do nothing */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_SPECIAL:
+                                               /* Do nothing */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_SYMLINK:
+                                               in->variant.symLinkVariant.alias =
+                                                   yaffs_CloneString(oh->alias);
+                                               if(!in->variant.symLinkVariant.alias)
+                                                       alloc_failed = 1;
+                                               break;
+                                       }
+
+                                       if (parent == dev->deletedDir) {
+                                               yaffs_DestroyObject(in);
+                                               bi->hasShrinkHeader = 1;
+                                       }
+                               }
+                       }
+               }
+
+               if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+                       /* If we got this far while scanning, then the block is fully allocated.*/
+                       state = YAFFS_BLOCK_STATE_FULL;
+               }
+
+               bi->blockState = state;
+
+               /* Now let's see if it was dirty */
+               if (bi->pagesInUse == 0 &&
+                   !bi->hasShrinkHeader &&
+                   bi->blockState == YAFFS_BLOCK_STATE_FULL) {
+                       yaffs_BlockBecameDirty(dev, blk);
+               }
+
+       }
+
+       if (blockIndex) {
+               YFREE(blockIndex);
+       }
+
+
+       /* Ok, we've done all the scanning.
+        * Fix up the hard link chains.
+        * We should now have scanned all the objects, now it's time to add these
+        * hardlinks.
+        */
+
+       yaffs_HardlinkFixup(dev,hardList);
+
+       /* Handle the unlinked files. Since they were left in an unlinked state we should
+        * just delete them.
+        */
+       {
+               struct list_head *i;
+               struct list_head *n;
+
+               yaffs_Object *l;
+               /* Soft delete all the unlinked files */
+               list_for_each_safe(i, n,
+                                  &dev->unlinkedDir->variant.directoryVariant.
+                                  children) {
+                       if (i) {
+                               l = list_entry(i, yaffs_Object, siblings);
+                               yaffs_DestroyObject(l);
+                       }
+               }
+       }
+
+       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
+
+       if(alloc_failed){
+               return YAFFS_FAIL;
+       }
+
+       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
+
+
+       return YAFFS_OK;
+}
+
+static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
+{
+       __u8 *chunkData;
+       yaffs_ObjectHeader *oh;
+       yaffs_Device *dev = in->myDev;
+       yaffs_ExtendedTags tags;
+       int result;
+       int alloc_failed = 0;
+
+       if(!in)
+               return;
+
+#if 0
+       T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
+               in->objectId,
+               in->lazyLoaded ? "not yet" : "already"));
+#endif
+
+       if(in->lazyLoaded){
+               in->lazyLoaded = 0;
+               chunkData = yaffs_GetTempBuffer(dev, __LINE__);
+
+               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
+               oh = (yaffs_ObjectHeader *) chunkData;
+
+               in->yst_mode = oh->yst_mode;
+#ifdef CONFIG_YAFFS_WINCE
+               in->win_atime[0] = oh->win_atime[0];
+               in->win_ctime[0] = oh->win_ctime[0];
+               in->win_mtime[0] = oh->win_mtime[0];
+               in->win_atime[1] = oh->win_atime[1];
+               in->win_ctime[1] = oh->win_ctime[1];
+               in->win_mtime[1] = oh->win_mtime[1];
+#else
+               in->yst_uid = oh->yst_uid;
+               in->yst_gid = oh->yst_gid;
+               in->yst_atime = oh->yst_atime;
+               in->yst_mtime = oh->yst_mtime;
+               in->yst_ctime = oh->yst_ctime;
+               in->yst_rdev = oh->yst_rdev;
+
+#endif
+               yaffs_SetObjectName(in, oh->name);
+
+               if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
+                        in->variant.symLinkVariant.alias =
+                                                   yaffs_CloneString(oh->alias);
+                       if(!in->variant.symLinkVariant.alias)
+                               alloc_failed = 1; /* Not returned to caller */
+               }
+
+               yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
+       }
+}
+
+static int yaffs_ScanBackwards(yaffs_Device * dev)
+{
+       yaffs_ExtendedTags tags;
+       int blk;
+       int blockIterator;
+       int startIterator;
+       int endIterator;
+       int nBlocksToScan = 0;
+
+       int chunk;
+       int result;
+       int c;
+       int deleted;
+       yaffs_BlockState state;
+       yaffs_Object *hardList = NULL;
+       yaffs_BlockInfo *bi;
+       int sequenceNumber;
+       yaffs_ObjectHeader *oh;
+       yaffs_Object *in;
+       yaffs_Object *parent;
+       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
+       int itsUnlinked;
+       __u8 *chunkData;
+
+       int fileSize;
+       int isShrink;
+       int foundChunksInBlock;
+       int equivalentObjectId;
+       int alloc_failed = 0;
+
+
+       yaffs_BlockIndex *blockIndex = NULL;
+       int altBlockIndex = 0;
+
+       if (!dev->isYaffs2) {
+               T(YAFFS_TRACE_SCAN,
+                 (TSTR("yaffs_ScanBackwards is only for YAFFS2!" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       T(YAFFS_TRACE_SCAN,
+         (TSTR
+          ("yaffs_ScanBackwards starts  intstartblk %d intendblk %d..."
+           TENDSTR), dev->internalStartBlock, dev->internalEndBlock));
+
+
+       dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
+
+       blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
+
+       if(!blockIndex) {
+               blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
+               altBlockIndex = 1;
+       }
+
+       if(!blockIndex) {
+               T(YAFFS_TRACE_SCAN,
+                 (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       dev->blocksInCheckpoint = 0;
+
+       chunkData = yaffs_GetTempBuffer(dev, __LINE__);
+
+       /* Scan all the blocks to determine their state */
+       for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
+               bi = yaffs_GetBlockInfo(dev, blk);
+               yaffs_ClearChunkBits(dev, blk);
+               bi->pagesInUse = 0;
+               bi->softDeletions = 0;
+
+               yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber);
+
+               bi->blockState = state;
+               bi->sequenceNumber = sequenceNumber;
+
+               if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
+                       bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
+
+               T(YAFFS_TRACE_SCAN_DEBUG,
+                 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
+                  state, sequenceNumber));
+
+
+               if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
+                       dev->blocksInCheckpoint++;
+
+               } else if (state == YAFFS_BLOCK_STATE_DEAD) {
+                       T(YAFFS_TRACE_BAD_BLOCKS,
+                         (TSTR("block %d is bad" TENDSTR), blk));
+               } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
+                       T(YAFFS_TRACE_SCAN_DEBUG,
+                         (TSTR("Block empty " TENDSTR)));
+                       dev->nErasedBlocks++;
+                       dev->nFreeChunks += dev->nChunksPerBlock;
+               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+
+                       /* Determine the highest sequence number */
+                       if (dev->isYaffs2 &&
+                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
+                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
+
+                               blockIndex[nBlocksToScan].seq = sequenceNumber;
+                               blockIndex[nBlocksToScan].block = blk;
+
+                               nBlocksToScan++;
+
+                               if (sequenceNumber >= dev->sequenceNumber) {
+                                       dev->sequenceNumber = sequenceNumber;
+                               }
+                       } else if (dev->isYaffs2) {
+                               /* TODO: Nasty sequence number! */
+                               T(YAFFS_TRACE_SCAN,
+                                 (TSTR
+                                  ("Block scanning block %d has bad sequence number %d"
+                                   TENDSTR), blk, sequenceNumber));
+
+                       }
+               }
+       }
+
+       T(YAFFS_TRACE_SCAN,
+       (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan));
+
+
+
+       YYIELD();
+
+       /* Sort the blocks */
+#ifndef CONFIG_YAFFS_USE_OWN_SORT
+       yaffs_qsort(blockIndex, nBlocksToScan,
+               sizeof(yaffs_BlockIndex), ybicmp);
+#else
+       {
+               /* Dungy old bubble sort... */
+
+               yaffs_BlockIndex temp;
+               int i;
+               int j;
+
+               for (i = 0; i < nBlocksToScan; i++)
+                       for (j = i + 1; j < nBlocksToScan; j++)
+                               if (blockIndex[i].seq > blockIndex[j].seq) {
+                                       temp = blockIndex[j];
+                                       blockIndex[j] = blockIndex[i];
+                                       blockIndex[i] = temp;
+                               }
+       }
+#endif
+
+       YYIELD();
+
+       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
+
+       /* Now scan the blocks looking at the data. */
+       startIterator = 0;
+       endIterator = nBlocksToScan - 1;
+       T(YAFFS_TRACE_SCAN_DEBUG,
+         (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
+
+       /* For each block.... backwards */
+       for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
+            blockIterator--) {
+               /* Cooperative multitasking! This loop can run for so
+                  long that watchdog timers expire. */
+               YYIELD();
+
+               /* get the block to scan in the correct order */
+               blk = blockIndex[blockIterator].block;
+
+               bi = yaffs_GetBlockInfo(dev, blk);
+
+
+               state = bi->blockState;
+
+               deleted = 0;
+
+               /* For each chunk in each block that needs scanning.... */
+               foundChunksInBlock = 0;
+               for (c = dev->nChunksPerBlock - 1;
+                    !alloc_failed && c >= 0 &&
+                    (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
+                     state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
+                       /* Scan backwards...
+                        * Read the tags and decide what to do
+                        */
+
+                       chunk = blk * dev->nChunksPerBlock + c;
+
+                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
+                                                       &tags);
+
+                       /* Let's have a good look at this chunk... */
+
+                       if (!tags.chunkUsed) {
+                               /* An unassigned chunk in the block.
+                                * If there are used chunks after this one, then
+                                * it is a chunk that was skipped due to failing the erased
+                                * check. Just skip it so that it can be deleted.
+                                * But, more typically, We get here when this is an unallocated
+                                * chunk and his means that either the block is empty or
+                                * this is the one being allocated from
+                                */
+
+                               if(foundChunksInBlock)
+                               {
+                                       /* This is a chunk that was skipped due to failing the erased check */
+
+                               } else if (c == 0) {
+                                       /* We're looking at the first chunk in the block so the block is unused */
+                                       state = YAFFS_BLOCK_STATE_EMPTY;
+                                       dev->nErasedBlocks++;
+                               } else {
+                                       if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
+                                           state == YAFFS_BLOCK_STATE_ALLOCATING) {
+                                               if(dev->sequenceNumber == bi->sequenceNumber) {
+                                                       /* this is the block being allocated from */
+
+                                                       T(YAFFS_TRACE_SCAN,
+                                                         (TSTR
+                                                          (" Allocating from %d %d"
+                                                           TENDSTR), blk, c));
+
+                                                       state = YAFFS_BLOCK_STATE_ALLOCATING;
+                                                       dev->allocationBlock = blk;
+                                                       dev->allocationPage = c;
+                                                       dev->allocationBlockFinder = blk;
+                                               }
+                                               else {
+                                                       /* This is a partially written block that is not
+                                                        * the current allocation block. This block must have
+                                                        * had a write failure, so set up for retirement.
+                                                        */
+
+                                                        bi->needsRetiring = 1;
+                                                        bi->gcPrioritise = 1;
+
+                                                        T(YAFFS_TRACE_ALWAYS,
+                                                        (TSTR("Partially written block %d being set for retirement" TENDSTR),
+                                                        blk));
+                                               }
+
+                                       }
+
+                               }
+
+                               dev->nFreeChunks++;
+
+                       } else if (tags.chunkId > 0) {
+                               /* chunkId > 0 so it is a data chunk... */
+                               unsigned int endpos;
+                               __u32 chunkBase =
+                                   (tags.chunkId - 1) * dev->nDataBytesPerChunk;
+
+                               foundChunksInBlock = 1;
+
+
+                               yaffs_SetChunkBit(dev, blk, c);
+                               bi->pagesInUse++;
+
+                               in = yaffs_FindOrCreateObjectByNumber(dev,
+                                                                     tags.
+                                                                     objectId,
+                                                                     YAFFS_OBJECT_TYPE_FILE);
+                               if(!in){
+                                       /* Out of memory */
+                                       alloc_failed = 1;
+                               }
+
+                               if (in &&
+                                   in->variantType == YAFFS_OBJECT_TYPE_FILE
+                                   && chunkBase <
+                                   in->variant.fileVariant.shrinkSize) {
+                                       /* This has not been invalidated by a resize */
+                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId,
+                                                              chunk, -1)){
+                                               alloc_failed = 1;
+                                       }
+
+                                       /* File size is calculated by looking at the data chunks if we have not
+                                        * seen an object header yet. Stop this practice once we find an object header.
+                                        */
+                                       endpos =
+                                           (tags.chunkId -
+                                            1) * dev->nDataBytesPerChunk +
+                                           tags.byteCount;
+
+                                       if (!in->valid &&       /* have not got an object header yet */
+                                           in->variant.fileVariant.
+                                           scannedFileSize < endpos) {
+                                               in->variant.fileVariant.
+                                                   scannedFileSize = endpos;
+                                               in->variant.fileVariant.
+                                                   fileSize =
+                                                   in->variant.fileVariant.
+                                                   scannedFileSize;
+                                       }
+
+                               } else if(in) {
+                                       /* This chunk has been invalidated by a resize, so delete */
+                                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
+
+                               }
+                       } else {
+                               /* chunkId == 0, so it is an ObjectHeader.
+                                * Thus, we read in the object header and make the object
+                                */
+                               foundChunksInBlock = 1;
+
+                               yaffs_SetChunkBit(dev, blk, c);
+                               bi->pagesInUse++;
+
+                               oh = NULL;
+                               in = NULL;
+
+                               if (tags.extraHeaderInfoAvailable) {
+                                       in = yaffs_FindOrCreateObjectByNumber
+                                           (dev, tags.objectId,
+                                            tags.extraObjectType);
+                               }
+
+                               if (!in ||
+#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD
+                                   !in->valid ||
+#endif
+                                   tags.extraShadows ||
+                                   (!in->valid &&
+                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
+                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))
+                                   ) {
+
+                                       /* If we don't have  valid info then we need to read the chunk
+                                        * TODO In future we can probably defer reading the chunk and
+                                        * living with invalid data until needed.
+                                        */
+
+                                       result = yaffs_ReadChunkWithTagsFromNAND(dev,
+                                                                       chunk,
+                                                                       chunkData,
+                                                                       NULL);
+
+                                       oh = (yaffs_ObjectHeader *) chunkData;
+
+                                       if (!in)
+                                               in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
+
+                               }
+
+                               if (!in) {
+                                       /* TODO Hoosterman we have a problem! */
+                                       T(YAFFS_TRACE_ERROR,
+                                         (TSTR
+                                          ("yaffs tragedy: Could not make object for object  %d  "
+                                           "at chunk %d during scan"
+                                           TENDSTR), tags.objectId, chunk));
+
+                               }
+
+                               if (in->valid) {
+                                       /* We have already filled this one.
+                                        * We have a duplicate that will be discarded, but
+                                        * we first have to suck out resize info if it is a file.
+                                        */
+
+                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
+                                            ((oh &&
+                                              oh-> type == YAFFS_OBJECT_TYPE_FILE)||
+                                             (tags.extraHeaderInfoAvailable  &&
+                                              tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
+                                           ) {
+                                               __u32 thisSize =
+                                                   (oh) ? oh->fileSize : tags.
+                                                   extraFileLength;
+                                               __u32 parentObjectId =
+                                                   (oh) ? oh->
+                                                   parentObjectId : tags.
+                                                   extraParentObjectId;
+                                               unsigned isShrink =
+                                                   (oh) ? oh->isShrink : tags.
+                                                   extraIsShrinkHeader;
+
+                                               /* If it is deleted (unlinked at start also means deleted)
+                                                * we treat the file size as being zeroed at this point.
+                                                */
+                                               if (parentObjectId ==
+                                                   YAFFS_OBJECTID_DELETED
+                                                   || parentObjectId ==
+                                                   YAFFS_OBJECTID_UNLINKED) {
+                                                       thisSize = 0;
+                                                       isShrink = 1;
+                                               }
+
+                                               if (isShrink &&
+                                                   in->variant.fileVariant.
+                                                   shrinkSize > thisSize) {
+                                                       in->variant.fileVariant.
+                                                           shrinkSize =
+                                                           thisSize;
+                                               }
+
+                                               if (isShrink) {
+                                                       bi->hasShrinkHeader = 1;
+                                               }
+
+                                       }
+                                       /* Use existing - destroy this one. */
+                                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
+
+                               }
+
+                               if (!in->valid &&
+                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
+                                    tags.objectId ==
+                                    YAFFS_OBJECTID_LOSTNFOUND)) {
+                                       /* We only load some info, don't fiddle with directory structure */
+                                       in->valid = 1;
+
+                                       if(oh) {
+                                               in->variantType = oh->type;
+
+                                               in->yst_mode = oh->yst_mode;
+#ifdef CONFIG_YAFFS_WINCE
+                                               in->win_atime[0] = oh->win_atime[0];
+                                               in->win_ctime[0] = oh->win_ctime[0];
+                                               in->win_mtime[0] = oh->win_mtime[0];
+                                               in->win_atime[1] = oh->win_atime[1];
+                                               in->win_ctime[1] = oh->win_ctime[1];
+                                               in->win_mtime[1] = oh->win_mtime[1];
+#else
+                                               in->yst_uid = oh->yst_uid;
+                                               in->yst_gid = oh->yst_gid;
+                                               in->yst_atime = oh->yst_atime;
+                                               in->yst_mtime = oh->yst_mtime;
+                                               in->yst_ctime = oh->yst_ctime;
+                                               in->yst_rdev = oh->yst_rdev;
+
+#endif
+                                       } else {
+                                               in->variantType = tags.extraObjectType;
+                                               in->lazyLoaded = 1;
+                                       }
+
+                                       in->chunkId = chunk;
+
+                               } else if (!in->valid) {
+                                       /* we need to load this info */
+
+                                       in->valid = 1;
+                                       in->chunkId = chunk;
+
+                                       if(oh) {
+                                               in->variantType = oh->type;
+
+                                               in->yst_mode = oh->yst_mode;
+#ifdef CONFIG_YAFFS_WINCE
+                                               in->win_atime[0] = oh->win_atime[0];
+                                               in->win_ctime[0] = oh->win_ctime[0];
+                                               in->win_mtime[0] = oh->win_mtime[0];
+                                               in->win_atime[1] = oh->win_atime[1];
+                                               in->win_ctime[1] = oh->win_ctime[1];
+                                               in->win_mtime[1] = oh->win_mtime[1];
+#else
+                                               in->yst_uid = oh->yst_uid;
+                                               in->yst_gid = oh->yst_gid;
+                                               in->yst_atime = oh->yst_atime;
+                                               in->yst_mtime = oh->yst_mtime;
+                                               in->yst_ctime = oh->yst_ctime;
+                                               in->yst_rdev = oh->yst_rdev;
+#endif
+
+                                               if (oh->shadowsObject > 0)
+                                                       yaffs_HandleShadowedObject(dev,
+                                                                          oh->
+                                                                          shadowsObject,
+                                                                          1);
+
+
+                                               yaffs_SetObjectName(in, oh->name);
+                                               parent =
+                                                   yaffs_FindOrCreateObjectByNumber
+                                                       (dev, oh->parentObjectId,
+                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
+
+                                                fileSize = oh->fileSize;
+                                                isShrink = oh->isShrink;
+                                                equivalentObjectId = oh->equivalentObjectId;
+
+                                       }
+                                       else {
+                                               in->variantType = tags.extraObjectType;
+                                               parent =
+                                                   yaffs_FindOrCreateObjectByNumber
+                                                       (dev, tags.extraParentObjectId,
+                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
+                                                fileSize = tags.extraFileLength;
+                                                isShrink = tags.extraIsShrinkHeader;
+                                                equivalentObjectId = tags.extraEquivalentObjectId;
+                                               in->lazyLoaded = 1;
+
+                                       }
+                                       in->dirty = 0;
+
+                                       /* directory stuff...
+                                        * hook up to parent
+                                        */
+
+                                       if (parent->variantType ==
+                                           YAFFS_OBJECT_TYPE_UNKNOWN) {
+                                               /* Set up as a directory */
+                                               parent->variantType =
+                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
+                                               INIT_LIST_HEAD(&parent->variant.
+                                                              directoryVariant.
+                                                              children);
+                                       } else if (parent->variantType !=
+                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
+                                       {
+                                               /* Hoosterman, another problem....
+                                                * We're trying to use a non-directory as a directory
+                                                */
+
+                                               T(YAFFS_TRACE_ERROR,
+                                                 (TSTR
+                                                  ("yaffs tragedy: attempting to use non-directory as"
+                                                   " a directory in scan. Put in lost+found."
+                                                   TENDSTR)));
+                                               parent = dev->lostNFoundDir;
+                                       }
+
+                                       yaffs_AddObjectToDirectory(parent, in);
+
+                                       itsUnlinked = (parent == dev->deletedDir) ||
+                                                     (parent == dev->unlinkedDir);
+
+                                       if (isShrink) {
+                                               /* Mark the block as having a shrinkHeader */
+                                               bi->hasShrinkHeader = 1;
+                                       }
+
+                                       /* Note re hardlinks.
+                                        * Since we might scan a hardlink before its equivalent object is scanned
+                                        * we put them all in a list.
+                                        * After scanning is complete, we should have all the objects, so we run
+                                        * through this list and fix up all the chains.
+                                        */
+
+                                       switch (in->variantType) {
+                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
+                                               /* Todo got a problem */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_FILE:
+
+                                               if (in->variant.fileVariant.
+                                                   scannedFileSize < fileSize) {
+                                                       /* This covers the case where the file size is greater
+                                                        * than where the data is
+                                                        * This will happen if the file is resized to be larger
+                                                        * than its current data extents.
+                                                        */
+                                                       in->variant.fileVariant.fileSize = fileSize;
+                                                       in->variant.fileVariant.scannedFileSize =
+                                                           in->variant.fileVariant.fileSize;
+                                               }
+
+                                               if (isShrink &&
+                                                   in->variant.fileVariant.shrinkSize > fileSize) {
+                                                       in->variant.fileVariant.shrinkSize = fileSize;
+                                               }
+
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_HARDLINK:
+                                               if(!itsUnlinked) {
+                                                 in->variant.hardLinkVariant.equivalentObjectId =
+                                                   equivalentObjectId;
+                                                 in->hardLinks.next =
+                                                   (struct list_head *) hardList;
+                                                 hardList = in;
+                                               }
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_DIRECTORY:
+                                               /* Do nothing */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_SPECIAL:
+                                               /* Do nothing */
+                                               break;
+                                       case YAFFS_OBJECT_TYPE_SYMLINK:
+                                               if(oh){
+                                                  in->variant.symLinkVariant.alias =
+                                                   yaffs_CloneString(oh->
+                                                                     alias);
+                                                  if(!in->variant.symLinkVariant.alias)
+                                                       alloc_failed = 1;
+                                               }
+                                               break;
+                                       }
+
+                               }
+
+                       }
+
+               } /* End of scanning for each chunk */
+
+               if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
+                       /* If we got this far while scanning, then the block is fully allocated. */
+                       state = YAFFS_BLOCK_STATE_FULL;
+               }
+
+               bi->blockState = state;
+
+               /* Now let's see if it was dirty */
+               if (bi->pagesInUse == 0 &&
+                   !bi->hasShrinkHeader &&
+                   bi->blockState == YAFFS_BLOCK_STATE_FULL) {
+                       yaffs_BlockBecameDirty(dev, blk);
+               }
+
+       }
+
+       if (altBlockIndex)
+               YFREE_ALT(blockIndex);
+       else
+               YFREE(blockIndex);
+
+       /* Ok, we've done all the scanning.
+        * Fix up the hard link chains.
+        * We should now have scanned all the objects, now it's time to add these
+        * hardlinks.
+        */
+       yaffs_HardlinkFixup(dev,hardList);
+
+
+       /*
+       *  Sort out state of unlinked and deleted objects.
+       */
+       {
+               struct list_head *i;
+               struct list_head *n;
+
+               yaffs_Object *l;
+
+               /* Soft delete all the unlinked files */
+               list_for_each_safe(i, n,
+                                  &dev->unlinkedDir->variant.directoryVariant.
+                                  children) {
+                       if (i) {
+                               l = list_entry(i, yaffs_Object, siblings);
+                               yaffs_DestroyObject(l);
+                       }
+               }
+
+               /* Soft delete all the deletedDir files */
+               list_for_each_safe(i, n,
+                                  &dev->deletedDir->variant.directoryVariant.
+                                  children) {
+                       if (i) {
+                               l = list_entry(i, yaffs_Object, siblings);
+                               yaffs_DestroyObject(l);
+
+                       }
+               }
+       }
+
+       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
+
+       if(alloc_failed){
+               return YAFFS_FAIL;
+       }
+
+       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
+
+       return YAFFS_OK;
+}
+
+/*------------------------------  Directory Functions ----------------------------- */
+
+static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
+{
+       yaffs_Device *dev = obj->myDev;
+
+       if(dev && dev->removeObjectCallback)
+               dev->removeObjectCallback(obj);
+
+       list_del_init(&obj->siblings);
+       obj->parent = NULL;
+}
+
+
+static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
+                                      yaffs_Object * obj)
+{
+
+       if (!directory) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: Trying to add an object to a null pointer directory"
+                   TENDSTR)));
+               YBUG();
+       }
+       if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: Trying to add an object to a non-directory"
+                   TENDSTR)));
+               YBUG();
+       }
+
+       if (obj->siblings.prev == NULL) {
+               /* Not initialised */
+               INIT_LIST_HEAD(&obj->siblings);
+
+       } else if (!list_empty(&obj->siblings)) {
+               /* If it is holed up somewhere else, un hook it */
+               yaffs_RemoveObjectFromDirectory(obj);
+       }
+       /* Now add it */
+       list_add(&obj->siblings, &directory->variant.directoryVariant.children);
+       obj->parent = directory;
+
+       if (directory == obj->myDev->unlinkedDir
+           || directory == obj->myDev->deletedDir) {
+               obj->unlinked = 1;
+               obj->myDev->nUnlinkedFiles++;
+               obj->renameAllowed = 0;
+       }
+}
+
+yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
+                                    const YCHAR * name)
+{
+       int sum;
+
+       struct list_head *i;
+       YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
+
+       yaffs_Object *l;
+
+       if (!name) {
+               return NULL;
+       }
+
+       if (!directory) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: yaffs_FindObjectByName: null pointer directory"
+                   TENDSTR)));
+               YBUG();
+       }
+       if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
+               YBUG();
+       }
+
+       sum = yaffs_CalcNameSum(name);
+
+       list_for_each(i, &directory->variant.directoryVariant.children) {
+               if (i) {
+                       l = list_entry(i, yaffs_Object, siblings);
+
+                       yaffs_CheckObjectDetailsLoaded(l);
+
+                       /* Special case for lost-n-found */
+                       if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
+                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
+                                       return l;
+                               }
+                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
+                       {
+                               /* LostnFound cunk called Objxxx
+                                * Do a real check
+                                */
+                               yaffs_GetObjectName(l, buffer,
+                                                   YAFFS_MAX_NAME_LENGTH);
+                               if (yaffs_strncmp(name, buffer,YAFFS_MAX_NAME_LENGTH) == 0) {
+                                       return l;
+                               }
+
+                       }
+               }
+       }
+
+       return NULL;
+}
+
+
+#if 0
+int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
+                                  int (*fn) (yaffs_Object *))
+{
+       struct list_head *i;
+       yaffs_Object *l;
+
+       if (!theDir) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: yaffs_FindObjectByName: null pointer directory"
+                   TENDSTR)));
+               YBUG();
+       }
+       if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
+               YBUG();
+       }
+
+       list_for_each(i, &theDir->variant.directoryVariant.children) {
+               if (i) {
+                       l = list_entry(i, yaffs_Object, siblings);
+                       if (l && !fn(l)) {
+                               return YAFFS_FAIL;
+                       }
+               }
+       }
+
+       return YAFFS_OK;
+
+}
+#endif
+
+/* GetEquivalentObject dereferences any hard links to get to the
+ * actual object.
+ */
+
+yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
+{
+       if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
+               /* We want the object id of the equivalent object, not this one */
+               obj = obj->variant.hardLinkVariant.equivalentObject;
+               yaffs_CheckObjectDetailsLoaded(obj);
+       }
+       return obj;
+
+}
+
+int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
+{
+       memset(name, 0, buffSize * sizeof(YCHAR));
+
+       yaffs_CheckObjectDetailsLoaded(obj);
+
+       if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
+               yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1);
+       } else if (obj->chunkId <= 0) {
+               YCHAR locName[20];
+               /* make up a name */
+               yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX,
+                             obj->objectId);
+               yaffs_strncpy(name, locName, buffSize - 1);
+
+       }
+#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
+       else if (obj->shortName[0]) {
+               yaffs_strcpy(name, obj->shortName);
+       }
+#endif
+       else {
+               int result;
+               __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__);
+
+               yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer;
+
+               memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
+
+               if (obj->chunkId >= 0) {
+                       result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
+                                                       obj->chunkId, buffer,
+                                                       NULL);
+               }
+               yaffs_strncpy(name, oh->name, buffSize - 1);
+
+               yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__);
+       }
+
+       return yaffs_strlen(name);
+}
+
+int yaffs_GetObjectFileLength(yaffs_Object * obj)
+{
+
+       /* Dereference any hard linking */
+       obj = yaffs_GetEquivalentObject(obj);
+
+       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
+               return obj->variant.fileVariant.fileSize;
+       }
+       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
+               return yaffs_strlen(obj->variant.symLinkVariant.alias);
+       } else {
+               /* Only a directory should drop through to here */
+               return obj->myDev->nDataBytesPerChunk;
+       }
+}
+
+int yaffs_GetObjectLinkCount(yaffs_Object * obj)
+{
+       int count = 0;
+       struct list_head *i;
+
+       if (!obj->unlinked) {
+               count++;        /* the object itself */
+       }
+       list_for_each(i, &obj->hardLinks) {
+               count++;        /* add the hard links; */
+       }
+       return count;
+
+}
+
+int yaffs_GetObjectInode(yaffs_Object * obj)
+{
+       obj = yaffs_GetEquivalentObject(obj);
+
+       return obj->objectId;
+}
+
+unsigned yaffs_GetObjectType(yaffs_Object * obj)
+{
+       obj = yaffs_GetEquivalentObject(obj);
+
+       switch (obj->variantType) {
+       case YAFFS_OBJECT_TYPE_FILE:
+               return DT_REG;
+               break;
+       case YAFFS_OBJECT_TYPE_DIRECTORY:
+               return DT_DIR;
+               break;
+       case YAFFS_OBJECT_TYPE_SYMLINK:
+               return DT_LNK;
+               break;
+       case YAFFS_OBJECT_TYPE_HARDLINK:
+               return DT_REG;
+               break;
+       case YAFFS_OBJECT_TYPE_SPECIAL:
+               if (S_ISFIFO(obj->yst_mode))
+                       return DT_FIFO;
+               if (S_ISCHR(obj->yst_mode))
+                       return DT_CHR;
+               if (S_ISBLK(obj->yst_mode))
+                       return DT_BLK;
+               if (S_ISSOCK(obj->yst_mode))
+                       return DT_SOCK;
+       default:
+               return DT_REG;
+               break;
+       }
+}
+
+YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj)
+{
+       obj = yaffs_GetEquivalentObject(obj);
+       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
+               return yaffs_CloneString(obj->variant.symLinkVariant.alias);
+       } else {
+               return yaffs_CloneString(_Y(""));
+       }
+}
+
+#ifndef CONFIG_YAFFS_WINCE
+
+int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr)
+{
+       unsigned int valid = attr->ia_valid;
+
+       if (valid & ATTR_MODE)
+               obj->yst_mode = attr->ia_mode;
+       if (valid & ATTR_UID)
+               obj->yst_uid = attr->ia_uid;
+       if (valid & ATTR_GID)
+               obj->yst_gid = attr->ia_gid;
+
+       if (valid & ATTR_ATIME)
+               obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime);
+       if (valid & ATTR_CTIME)
+               obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime);
+       if (valid & ATTR_MTIME)
+               obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime);
+
+       if (valid & ATTR_SIZE)
+               yaffs_ResizeFile(obj, attr->ia_size);
+
+       yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
+
+       return YAFFS_OK;
+
+}
+int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr)
+{
+       unsigned int valid = 0;
+
+       attr->ia_mode = obj->yst_mode;
+       valid |= ATTR_MODE;
+       attr->ia_uid = obj->yst_uid;
+       valid |= ATTR_UID;
+       attr->ia_gid = obj->yst_gid;
+       valid |= ATTR_GID;
+
+       Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime;
+       valid |= ATTR_ATIME;
+       Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime;
+       valid |= ATTR_CTIME;
+       Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime;
+       valid |= ATTR_MTIME;
+
+       attr->ia_size = yaffs_GetFileSize(obj);
+       valid |= ATTR_SIZE;
+
+       attr->ia_valid = valid;
+
+       return YAFFS_OK;
+
+}
+
+#endif
+
+#if 0
+int yaffs_DumpObject(yaffs_Object * obj)
+{
+       YCHAR name[257];
+
+       yaffs_GetObjectName(obj, name, 256);
+
+       T(YAFFS_TRACE_ALWAYS,
+         (TSTR
+          ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d"
+           " chunk %d type %d size %d\n"
+           TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name,
+          obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId,
+          yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
+
+       return YAFFS_OK;
+}
+#endif
+
+/*---------------------------- Initialisation code -------------------------------------- */
+
+static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
+{
+
+       /* Common functions, gotta have */
+       if (!dev->eraseBlockInNAND || !dev->initialiseNAND)
+               return 0;
+
+#ifdef CONFIG_YAFFS_YAFFS2
+
+       /* Can use the "with tags" style interface for yaffs1 or yaffs2 */
+       if (dev->writeChunkWithTagsToNAND &&
+           dev->readChunkWithTagsFromNAND &&
+           !dev->writeChunkToNAND &&
+           !dev->readChunkFromNAND &&
+           dev->markNANDBlockBad && dev->queryNANDBlock)
+               return 1;
+#endif
+
+       /* Can use the "spare" style interface for yaffs1 */
+       if (!dev->isYaffs2 &&
+           !dev->writeChunkWithTagsToNAND &&
+           !dev->readChunkWithTagsFromNAND &&
+           dev->writeChunkToNAND &&
+           dev->readChunkFromNAND &&
+           !dev->markNANDBlockBad && !dev->queryNANDBlock)
+               return 1;
+
+       return 0;               /* bad */
+}
+
+
+static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
+{
+       /* Initialise the unlinked, deleted, root and lost and found directories */
+
+       dev->lostNFoundDir = dev->rootDir =  NULL;
+       dev->unlinkedDir = dev->deletedDir = NULL;
+
+       dev->unlinkedDir =
+           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
+
+       dev->deletedDir =
+           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
+
+       dev->rootDir =
+           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_ROOT,
+                                     YAFFS_ROOT_MODE | S_IFDIR);
+       dev->lostNFoundDir =
+           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
+                                     YAFFS_LOSTNFOUND_MODE | S_IFDIR);
+
+       if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
+               yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
+               return YAFFS_OK;
+       }
+
+       return YAFFS_FAIL;
+}
+
+int yaffs_GutsInitialise(yaffs_Device * dev)
+{
+       int init_failed = 0;
+       unsigned x;
+       int bits;
+
+       T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR)));
+
+       /* Check stuff that must be set */
+
+       if (!dev) {
+               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Need a device" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       dev->internalStartBlock = dev->startBlock;
+       dev->internalEndBlock = dev->endBlock;
+       dev->blockOffset = 0;
+       dev->chunkOffset = 0;
+       dev->nFreeChunks = 0;
+
+       if (dev->startBlock == 0) {
+               dev->internalStartBlock = dev->startBlock + 1;
+               dev->internalEndBlock = dev->endBlock + 1;
+               dev->blockOffset = 1;
+               dev->chunkOffset = dev->nChunksPerBlock;
+       }
+
+       /* Check geometry parameters. */
+
+       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
+           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
+            dev->nChunksPerBlock < 2 ||
+            dev->nReservedBlocks < 2 ||
+            dev->internalStartBlock <= 0 ||
+            dev->internalEndBlock <= 0 ||
+            dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
+           ) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
+                   TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
+               return YAFFS_FAIL;
+       }
+
+       if (yaffs_InitialiseNAND(dev) != YAFFS_OK) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       /* Got the right mix of functions? */
+       if (!yaffs_CheckDevFunctions(dev)) {
+               /* Function missing */
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR
+                  ("yaffs: device function(s) missing or wrong\n" TENDSTR)));
+
+               return YAFFS_FAIL;
+       }
+
+       /* This is really a compilation check. */
+       if (!yaffs_CheckStructures()) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("yaffs_CheckStructures failed\n" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       if (dev->isMounted) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("yaffs: device already mounted\n" TENDSTR)));
+               return YAFFS_FAIL;
+       }
+
+       /* Finished with most checks. One or two more checks happen later on too. */
+
+       dev->isMounted = 1;
+
+
+
+       /* OK now calculate a few things for the device */
+
+       /*
+        *  Calculate all the chunk size manipulation numbers:
+        */
+        /* Start off assuming it is a power of 2 */
+        dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
+        dev->chunkMask = (1<<dev->chunkShift) - 1;
+
+        if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
+               /* Yes it is a power of 2, disable crumbs */
+               dev->crumbMask = 0;
+               dev->crumbShift = 0;
+               dev->crumbsPerChunk = 0;
+        } else {
+               /* Not a power of 2, use crumbs instead */
+               dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
+               dev->crumbMask = (1<<dev->crumbShift)-1;
+               dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
+               dev->chunkShift = 0;
+               dev->chunkMask = 0;
+       }
+
+
+       /*
+        * Calculate chunkGroupBits.
+        * We need to find the next power of 2 > than internalEndBlock
+        */
+
+       x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
+
+       bits = ShiftsGE(x);
+
+       /* Set up tnode width if wide tnodes are enabled. */
+       if(!dev->wideTnodesDisabled){
+               /* bits must be even so that we end up with 32-bit words */
+               if(bits & 1)
+                       bits++;
+               if(bits < 16)
+                       dev->tnodeWidth = 16;
+               else
+                       dev->tnodeWidth = bits;
+       }
+       else
+               dev->tnodeWidth = 16;
+
+       dev->tnodeMask = (1<<dev->tnodeWidth)-1;
+
+       /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
+        * so if the bitwidth of the
+        * chunk range we're using is greater than 16 we need
+        * to figure out chunk shift and chunkGroupSize
+        */
+
+       if (bits <= dev->tnodeWidth)
+               dev->chunkGroupBits = 0;
+       else
+               dev->chunkGroupBits = bits - dev->tnodeWidth;
+
+
+       dev->chunkGroupSize = 1 << dev->chunkGroupBits;
+
+       if (dev->nChunksPerBlock < dev->chunkGroupSize) {
+               /* We have a problem because the soft delete won't work if
+                * the chunk group size > chunks per block.
+                * This can be remedied by using larger "virtual blocks".
+                */
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("yaffs: chunk group too large\n" TENDSTR)));
+
+               return YAFFS_FAIL;
+       }
+
+       /* OK, we've finished verifying the device, lets continue with initialisation */
+
+       /* More device initialisation */
+       dev->garbageCollections = 0;
+       dev->passiveGarbageCollections = 0;
+       dev->currentDirtyChecker = 0;
+       dev->bufferedBlock = -1;
+       dev->doingBufferedBlockRewrite = 0;
+       dev->nDeletedFiles = 0;
+       dev->nBackgroundDeletions = 0;
+       dev->nUnlinkedFiles = 0;
+       dev->eccFixed = 0;
+       dev->eccUnfixed = 0;
+       dev->tagsEccFixed = 0;
+       dev->tagsEccUnfixed = 0;
+       dev->nErasureFailures = 0;
+       dev->nErasedBlocks = 0;
+       dev->isDoingGC = 0;
+       dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
+
+       /* Initialise temporary buffers and caches. */
+       if(!yaffs_InitialiseTempBuffers(dev))
+               init_failed = 1;
+
+       dev->srCache = NULL;
+       dev->gcCleanupList = NULL;
+
+
+       if (!init_failed &&
+           dev->nShortOpCaches > 0) {
+               int i;
+               __u8 *buf;
+               int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
+
+               if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
+                       dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES;
+               }
+
+               buf = dev->srCache =  YMALLOC(srCacheBytes);
+
+               if(dev->srCache)
+                       memset(dev->srCache,0,srCacheBytes);
+
+               for (i = 0; i < dev->nShortOpCaches && buf; i++) {
+                       dev->srCache[i].object = NULL;
+                       dev->srCache[i].lastUse = 0;
+                       dev->srCache[i].dirty = 0;
+                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
+               }
+               if(!buf)
+                       init_failed = 1;
+
+               dev->srLastUse = 0;
+       }
+
+       dev->cacheHits = 0;
+
+       if(!init_failed){
+               dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
+               if(!dev->gcCleanupList)
+                       init_failed = 1;
+       }
+
+       if (dev->isYaffs2) {
+               dev->useHeaderFileSize = 1;
+       }
+       if(!init_failed && !yaffs_InitialiseBlocks(dev))
+               init_failed = 1;
+
+       yaffs_InitialiseTnodes(dev);
+       yaffs_InitialiseObjects(dev);
+
+       if(!init_failed && !yaffs_CreateInitialDirectories(dev))
+               init_failed = 1;
+
+
+       if(!init_failed){
+               /* Now scan the flash. */
+               if (dev->isYaffs2) {
+                       if(yaffs_CheckpointRestore(dev)) {
+                               T(YAFFS_TRACE_ALWAYS,
+                                 (TSTR("yaffs: restored from checkpoint" TENDSTR)));
+                       } else {
+
+                               /* Clean up the mess caused by an aborted checkpoint load
+                                * and scan backwards.
+                                */
+                               yaffs_DeinitialiseBlocks(dev);
+                               yaffs_DeinitialiseTnodes(dev);
+                               yaffs_DeinitialiseObjects(dev);
+
+
+                               dev->nErasedBlocks = 0;
+                               dev->nFreeChunks = 0;
+                               dev->allocationBlock = -1;
+                               dev->allocationPage = -1;
+                               dev->nDeletedFiles = 0;
+                               dev->nUnlinkedFiles = 0;
+                               dev->nBackgroundDeletions = 0;
+                               dev->oldestDirtySequence = 0;
+
+                               if(!init_failed && !yaffs_InitialiseBlocks(dev))
+                                       init_failed = 1;
+
+                               yaffs_InitialiseTnodes(dev);
+                               yaffs_InitialiseObjects(dev);
+
+                               if(!init_failed && !yaffs_CreateInitialDirectories(dev))
+                                       init_failed = 1;
+
+                               if(!init_failed && !yaffs_ScanBackwards(dev))
+                                       init_failed = 1;
+                       }
+               }else
+                       if(!yaffs_Scan(dev))
+                               init_failed = 1;
+       }
+
+       if(init_failed){
+               /* Clean up the mess */
+               T(YAFFS_TRACE_TRACING,
+                 (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR)));
+
+               yaffs_Deinitialise(dev);
+               return YAFFS_FAIL;
+       }
+
+       /* Zero out stats */
+       dev->nPageReads = 0;
+       dev->nPageWrites = 0;
+       dev->nBlockErasures = 0;
+       dev->nGCCopies = 0;
+       dev->nRetriedWrites = 0;
+
+       dev->nRetiredBlocks = 0;
+
+       yaffs_VerifyFreeChunks(dev);
+       yaffs_VerifyBlocks(dev);
+
+
+       T(YAFFS_TRACE_TRACING,
+         (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
+       return YAFFS_OK;
+
+}
+
+void yaffs_Deinitialise(yaffs_Device * dev)
+{
+       if (dev->isMounted) {
+               int i;
+
+               yaffs_DeinitialiseBlocks(dev);
+               yaffs_DeinitialiseTnodes(dev);
+               yaffs_DeinitialiseObjects(dev);
+               if (dev->nShortOpCaches > 0 &&
+                   dev->srCache) {
+
+                       for (i = 0; i < dev->nShortOpCaches; i++) {
+                               if(dev->srCache[i].data)
+                                       YFREE(dev->srCache[i].data);
+                               dev->srCache[i].data = NULL;
+                       }
+
+                       YFREE(dev->srCache);
+                       dev->srCache = NULL;
+               }
+
+               YFREE(dev->gcCleanupList);
+
+               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
+                       YFREE(dev->tempBuffer[i].buffer);
+               }
+
+               dev->isMounted = 0;
+       }
+
+}
+
+static int yaffs_CountFreeChunks(yaffs_Device * dev)
+{
+       int nFree;
+       int b;
+
+       yaffs_BlockInfo *blk;
+
+       for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock;
+            b++) {
+               blk = yaffs_GetBlockInfo(dev, b);
+
+               switch (blk->blockState) {
+               case YAFFS_BLOCK_STATE_EMPTY:
+               case YAFFS_BLOCK_STATE_ALLOCATING:
+               case YAFFS_BLOCK_STATE_COLLECTING:
+               case YAFFS_BLOCK_STATE_FULL:
+                       nFree +=
+                           (dev->nChunksPerBlock - blk->pagesInUse +
+                            blk->softDeletions);
+                       break;
+               default:
+                       break;
+               }
+
+       }
+
+       return nFree;
+}
+
+int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
+{
+       /* This is what we report to the outside world */
+
+       int nFree;
+       int nDirtyCacheChunks;
+       int blocksForCheckpoint;
+
+#if 1
+       nFree = dev->nFreeChunks;
+#else
+       nFree = yaffs_CountFreeChunks(dev);
+#endif
+
+       nFree += dev->nDeletedFiles;
+
+       /* Now count the number of dirty chunks in the cache and subtract those */
+
+       {
+               int i;
+               for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
+                       if (dev->srCache[i].dirty)
+                               nDirtyCacheChunks++;
+               }
+       }
+
+       nFree -= nDirtyCacheChunks;
+
+       nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
+
+       /* Now we figure out how much to reserve for the checkpoint and report that... */
+       blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
+       if(blocksForCheckpoint < 0)
+               blocksForCheckpoint = 0;
+
+       nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
+
+       if (nFree < 0)
+               nFree = 0;
+
+       return nFree;
+
+}
+
+static int yaffs_freeVerificationFailures;
+
+static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
+{
+       int counted;
+       int difference;
+
+       if(yaffs_SkipVerification(dev))
+               return;
+
+       counted = yaffs_CountFreeChunks(dev);
+
+       difference = dev->nFreeChunks - counted;
+
+       if (difference) {
+               T(YAFFS_TRACE_ALWAYS,
+                 (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
+                  dev->nFreeChunks, counted, difference));
+               yaffs_freeVerificationFailures++;
+       }
+}
+
+/*---------------------------------------- YAFFS test code ----------------------*/
+
+#define yaffs_CheckStruct(structure,syze, name) \
+           if(sizeof(structure) != syze) \
+              { \
+                T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
+                name,syze,sizeof(structure))); \
+                return YAFFS_FAIL; \
+               }
+
+static int yaffs_CheckStructures(void)
+{
+/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
+/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
+/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
+#ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
+       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
+#endif
+           yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
+
+           return YAFFS_OK;
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_guts.h
new file mode 100644 (file)
index 0000000..ea06c1a
--- /dev/null
@@ -0,0 +1,902 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_GUTS_H__
+#define __YAFFS_GUTS_H__
+
+#include "devextras.h"
+#include "yportenv.h"
+
+#define YAFFS_OK       1
+#define YAFFS_FAIL  0
+
+/* Give us a  Y=0x59,
+ * Give us an A=0x41,
+ * Give us an FF=0xFF
+ * Give us an S=0x53
+ * And what have we got...
+ */
+#define YAFFS_MAGIC                    0x5941FF53
+
+#define YAFFS_NTNODES_LEVEL0           16
+#define YAFFS_TNODES_LEVEL0_BITS       4
+#define YAFFS_TNODES_LEVEL0_MASK       0xf
+
+#define YAFFS_NTNODES_INTERNAL                 (YAFFS_NTNODES_LEVEL0 / 2)
+#define YAFFS_TNODES_INTERNAL_BITS     (YAFFS_TNODES_LEVEL0_BITS - 1)
+#define YAFFS_TNODES_INTERNAL_MASK     0x7
+#define YAFFS_TNODES_MAX_LEVEL         6
+
+#ifndef CONFIG_YAFFS_NO_YAFFS1
+#define YAFFS_BYTES_PER_SPARE          16
+#define YAFFS_BYTES_PER_CHUNK          512
+#define YAFFS_CHUNK_SIZE_SHIFT         9
+#define YAFFS_CHUNKS_PER_BLOCK         32
+#define YAFFS_BYTES_PER_BLOCK          (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
+#endif
+
+#define YAFFS_MIN_YAFFS2_CHUNK_SIZE    1024
+#define YAFFS_MIN_YAFFS2_SPARE_SIZE    32
+
+#define YAFFS_MAX_CHUNK_ID             0x000FFFFF
+
+#define YAFFS_UNUSED_OBJECT_ID         0x0003FFFF
+
+#define YAFFS_ALLOCATION_NOBJECTS      100
+#define YAFFS_ALLOCATION_NTNODES       100
+#define YAFFS_ALLOCATION_NLINKS                100
+
+#define YAFFS_NOBJECT_BUCKETS          256
+
+
+#define YAFFS_OBJECT_SPACE             0x40000
+
+#define YAFFS_CHECKPOINT_VERSION       3
+
+#ifdef CONFIG_YAFFS_UNICODE
+#define YAFFS_MAX_NAME_LENGTH          127
+#define YAFFS_MAX_ALIAS_LENGTH         79
+#else
+#define YAFFS_MAX_NAME_LENGTH          255
+#define YAFFS_MAX_ALIAS_LENGTH         159
+#endif
+
+#define YAFFS_SHORT_NAME_LENGTH                15
+
+/* Some special object ids for pseudo objects */
+#define YAFFS_OBJECTID_ROOT            1
+#define YAFFS_OBJECTID_LOSTNFOUND      2
+#define YAFFS_OBJECTID_UNLINKED                3
+#define YAFFS_OBJECTID_DELETED         4
+
+/* Sseudo object ids for checkpointing */
+#define YAFFS_OBJECTID_SB_HEADER       0x10
+#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20
+#define YAFFS_SEQUENCE_CHECKPOINT_DATA  0x21
+
+/* */
+
+#define YAFFS_MAX_SHORT_OP_CACHES      20
+
+#define YAFFS_N_TEMP_BUFFERS           4
+
+/* We limit the number attempts at sucessfully saving a chunk of data.
+ * Small-page devices have 32 pages per block; large-page devices have 64.
+ * Default to something in the order of 5 to 10 blocks worth of chunks.
+ */
+#define YAFFS_WR_ATTEMPTS              (5*64)
+
+/* Sequence numbers are used in YAFFS2 to determine block allocation order.
+ * The range is limited slightly to help distinguish bad numbers from good.
+ * This also allows us to perhaps in the future use special numbers for
+ * special purposes.
+ * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
+ * and is a larger number than the lifetime of a 2GB device.
+ */
+#define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
+#define YAFFS_HIGHEST_SEQUENCE_NUMBER  0xEFFFFF00
+
+/* ChunkCache is used for short read/write operations.*/
+typedef struct {
+       struct yaffs_ObjectStruct *object;
+       int chunkId;
+       int lastUse;
+       int dirty;
+       int nBytes;             /* Only valid if the cache is dirty */
+       int locked;             /* Can't push out or flush while locked. */
+#ifdef CONFIG_YAFFS_YAFFS2
+       __u8 *data;
+#else
+       __u8 data[YAFFS_BYTES_PER_CHUNK];
+#endif
+} yaffs_ChunkCache;
+
+
+
+/* Tags structures in RAM
+ * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise
+ * the structure size will get blown out.
+ */
+
+#ifndef CONFIG_YAFFS_NO_YAFFS1
+typedef struct {
+       unsigned chunkId:20;
+       unsigned serialNumber:2;
+       unsigned byteCount:10;
+       unsigned objectId:18;
+       unsigned ecc:12;
+       unsigned unusedStuff:2;
+
+} yaffs_Tags;
+
+typedef union {
+       yaffs_Tags asTags;
+       __u8 asBytes[8];
+} yaffs_TagsUnion;
+
+#endif
+
+/* Stuff used for extended tags in YAFFS2 */
+
+typedef enum {
+       YAFFS_ECC_RESULT_UNKNOWN,
+       YAFFS_ECC_RESULT_NO_ERROR,
+       YAFFS_ECC_RESULT_FIXED,
+       YAFFS_ECC_RESULT_UNFIXED
+} yaffs_ECCResult;
+
+typedef enum {
+       YAFFS_OBJECT_TYPE_UNKNOWN,
+       YAFFS_OBJECT_TYPE_FILE,
+       YAFFS_OBJECT_TYPE_SYMLINK,
+       YAFFS_OBJECT_TYPE_DIRECTORY,
+       YAFFS_OBJECT_TYPE_HARDLINK,
+       YAFFS_OBJECT_TYPE_SPECIAL
+} yaffs_ObjectType;
+
+#define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL
+
+typedef struct {
+
+       unsigned validMarker0;
+       unsigned chunkUsed;     /*  Status of the chunk: used or unused */
+       unsigned objectId;      /* If 0 then this is not part of an object (unused) */
+       unsigned chunkId;       /* If 0 then this is a header, else a data chunk */
+       unsigned byteCount;     /* Only valid for data chunks */
+
+       /* The following stuff only has meaning when we read */
+       yaffs_ECCResult eccResult;
+       unsigned blockBad;
+
+       /* YAFFS 1 stuff */
+       unsigned chunkDeleted;  /* The chunk is marked deleted */
+       unsigned serialNumber;  /* Yaffs1 2-bit serial number */
+
+       /* YAFFS2 stuff */
+       unsigned sequenceNumber;        /* The sequence number of this block */
+
+       /* Extra info if this is an object header (YAFFS2 only) */
+
+       unsigned extraHeaderInfoAvailable;      /* There is extra info available if this is not zero */
+       unsigned extraParentObjectId;   /* The parent object */
+       unsigned extraIsShrinkHeader;   /* Is it a shrink header? */
+       unsigned extraShadows;          /* Does this shadow another object? */
+
+       yaffs_ObjectType extraObjectType;       /* What object type? */
+
+       unsigned extraFileLength;               /* Length if it is a file */
+       unsigned extraEquivalentObjectId;       /* Equivalent object Id if it is a hard link */
+
+       unsigned validMarker1;
+
+} yaffs_ExtendedTags;
+
+/* Spare structure for YAFFS1 */
+typedef struct {
+       __u8 tagByte0;
+       __u8 tagByte1;
+       __u8 tagByte2;
+       __u8 tagByte3;
+       __u8 pageStatus;        /* set to 0 to delete the chunk */
+       __u8 blockStatus;
+       __u8 tagByte4;
+       __u8 tagByte5;
+       __u8 ecc1[3];
+       __u8 tagByte6;
+       __u8 tagByte7;
+       __u8 ecc2[3];
+} yaffs_Spare;
+
+/*Special structure for passing through to mtd */
+struct yaffs_NANDSpare {
+       yaffs_Spare spare;
+       int eccres1;
+       int eccres2;
+};
+
+/* Block data in RAM */
+
+typedef enum {
+       YAFFS_BLOCK_STATE_UNKNOWN = 0,
+
+       YAFFS_BLOCK_STATE_SCANNING,
+       YAFFS_BLOCK_STATE_NEEDS_SCANNING,
+       /* The block might have something on it (ie it is allocating or full, perhaps empty)
+        * but it needs to be scanned to determine its true state.
+        * This state is only valid during yaffs_Scan.
+        * NB We tolerate empty because the pre-scanner might be incapable of deciding
+        * However, if this state is returned on a YAFFS2 device, then we expect a sequence number
+        */
+
+       YAFFS_BLOCK_STATE_EMPTY,
+       /* This block is empty */
+
+       YAFFS_BLOCK_STATE_ALLOCATING,
+       /* This block is partially allocated.
+        * At least one page holds valid data.
+        * This is the one currently being used for page
+        * allocation. Should never be more than one of these
+        */
+
+       YAFFS_BLOCK_STATE_FULL,
+       /* All the pages in this block have been allocated.
+        */
+
+       YAFFS_BLOCK_STATE_DIRTY,
+       /* All pages have been allocated and deleted.
+        * Erase me, reuse me.
+        */
+
+       YAFFS_BLOCK_STATE_CHECKPOINT,
+       /* This block is assigned to holding checkpoint data.
+        */
+
+       YAFFS_BLOCK_STATE_COLLECTING,
+       /* This block is being garbage collected */
+
+       YAFFS_BLOCK_STATE_DEAD
+       /* This block has failed and is not in use */
+} yaffs_BlockState;
+
+#define        YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1)
+
+
+typedef struct {
+
+       int softDeletions:10;   /* number of soft deleted pages */
+       int pagesInUse:10;      /* number of pages in use */
+       yaffs_BlockState blockState:4;  /* One of the above block states */
+       __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
+                               /* and retire the block. */
+       __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
+       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
+                                  It should be prioritised for GC */
+        __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
+
+#ifdef CONFIG_YAFFS_YAFFS2
+       __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */
+       __u32 sequenceNumber;    /* block sequence number for yaffs2 */
+#endif
+
+} yaffs_BlockInfo;
+
+/* -------------------------- Object structure -------------------------------*/
+/* This is the object structure as stored on NAND */
+
+typedef struct {
+       yaffs_ObjectType type;
+
+       /* Apply to everything  */
+       int parentObjectId;
+       __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
+       YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
+
+       /* Thes following apply to directories, files, symlinks - not hard links */
+       __u32 yst_mode;         /* protection */
+
+#ifdef CONFIG_YAFFS_WINCE
+       __u32 notForWinCE[5];
+#else
+       __u32 yst_uid;
+       __u32 yst_gid;
+       __u32 yst_atime;
+       __u32 yst_mtime;
+       __u32 yst_ctime;
+#endif
+
+       /* File size  applies to files only */
+       int fileSize;
+
+       /* Equivalent object id applies to hard links only. */
+       int equivalentObjectId;
+
+       /* Alias is for symlinks only. */
+       YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1];
+
+       __u32 yst_rdev;         /* device stuff for block and char devices (major/min) */
+
+#ifdef CONFIG_YAFFS_WINCE
+       __u32 win_ctime[2];
+       __u32 win_atime[2];
+       __u32 win_mtime[2];
+       __u32 roomToGrow[4];
+#else
+       __u32 roomToGrow[10];
+#endif
+
+       int shadowsObject;      /* This object header shadows the specified object if > 0 */
+
+       /* isShrink applies to object headers written when we shrink the file (ie resize) */
+       __u32 isShrink;
+
+} yaffs_ObjectHeader;
+
+/*--------------------------- Tnode -------------------------- */
+
+union yaffs_Tnode_union {
+#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
+       union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL + 1];
+#else
+       union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
+#endif
+/*     __u16 level0[YAFFS_NTNODES_LEVEL0]; */
+
+};
+
+typedef union yaffs_Tnode_union yaffs_Tnode;
+
+struct yaffs_TnodeList_struct {
+       struct yaffs_TnodeList_struct *next;
+       yaffs_Tnode *tnodes;
+};
+
+typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
+
+/*------------------------  Object -----------------------------*/
+/* An object can be one of:
+ * - a directory (no data, has children links
+ * - a regular file (data.... not prunes :->).
+ * - a symlink [symbolic link] (the alias).
+ * - a hard link
+ */
+
+typedef struct {
+       __u32 fileSize;
+       __u32 scannedFileSize;
+       __u32 shrinkSize;
+       int topLevel;
+       yaffs_Tnode *top;
+} yaffs_FileStructure;
+
+typedef struct {
+       struct list_head children;      /* list of child links */
+} yaffs_DirectoryStructure;
+
+typedef struct {
+       YCHAR *alias;
+} yaffs_SymLinkStructure;
+
+typedef struct {
+       struct yaffs_ObjectStruct *equivalentObject;
+       __u32 equivalentObjectId;
+} yaffs_HardLinkStructure;
+
+typedef union {
+       yaffs_FileStructure fileVariant;
+       yaffs_DirectoryStructure directoryVariant;
+       yaffs_SymLinkStructure symLinkVariant;
+       yaffs_HardLinkStructure hardLinkVariant;
+} yaffs_ObjectVariant;
+
+struct yaffs_ObjectStruct {
+       __u8 deleted:1;         /* This should only apply to unlinked files. */
+       __u8 softDeleted:1;     /* it has also been soft deleted */
+       __u8 unlinked:1;        /* An unlinked file. The file should be in the unlinked directory.*/
+       __u8 fake:1;            /* A fake object has no presence on NAND. */
+       __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
+       __u8 unlinkAllowed:1;
+       __u8 dirty:1;           /* the object needs to be written to flash */
+       __u8 valid:1;           /* When the file system is being loaded up, this
+                                * object might be created before the data
+                                * is available (ie. file data records appear before the header).
+                                */
+       __u8 lazyLoaded:1;      /* This object has been lazy loaded and is missing some detail */
+
+       __u8 deferedFree:1;     /* For Linux kernel. Object is removed from NAND, but is
+                                * still in the inode cache. Free of object is defered.
+                                * until the inode is released.
+                                */
+
+       __u8 serial;            /* serial number of chunk in NAND. Cached here */
+       __u16 sum;              /* sum of the name to speed searching */
+
+       struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
+
+       struct list_head hashLink;      /* list of objects in this hash bucket */
+
+       struct list_head hardLinks;     /* all the equivalent hard linked objects */
+
+       /* directory structure stuff */
+       /* also used for linking up the free list */
+       struct yaffs_ObjectStruct *parent;
+       struct list_head siblings;
+
+       /* Where's my object header in NAND? */
+       int chunkId;
+
+       int nDataChunks;        /* Number of data chunks attached to the file. */
+
+       __u32 objectId;         /* the object id value */
+
+       __u32 yst_mode;
+
+#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
+       YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1];
+#endif
+
+#ifndef __KERNEL__
+       __u32 inUse;
+#endif
+
+#ifdef CONFIG_YAFFS_WINCE
+       __u32 win_ctime[2];
+       __u32 win_mtime[2];
+       __u32 win_atime[2];
+#else
+       __u32 yst_uid;
+       __u32 yst_gid;
+       __u32 yst_atime;
+       __u32 yst_mtime;
+       __u32 yst_ctime;
+#endif
+
+       __u32 yst_rdev;
+
+#ifdef __KERNEL__
+       struct inode *myInode;
+
+#endif
+
+       yaffs_ObjectType variantType;
+
+       yaffs_ObjectVariant variant;
+
+};
+
+typedef struct yaffs_ObjectStruct yaffs_Object;
+
+struct yaffs_ObjectList_struct {
+       yaffs_Object *objects;
+       struct yaffs_ObjectList_struct *next;
+};
+
+typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
+
+typedef struct {
+       struct list_head list;
+       int count;
+} yaffs_ObjectBucket;
+
+
+/* yaffs_CheckpointObject holds the definition of an object as dumped
+ * by checkpointing.
+ */
+
+typedef struct {
+        int structType;
+       __u32 objectId;
+       __u32 parentId;
+       int chunkId;
+
+       yaffs_ObjectType variantType:3;
+       __u8 deleted:1;
+       __u8 softDeleted:1;
+       __u8 unlinked:1;
+       __u8 fake:1;
+       __u8 renameAllowed:1;
+       __u8 unlinkAllowed:1;
+       __u8 serial;
+
+       int nDataChunks;
+       __u32 fileSizeOrEquivalentObjectId;
+
+}yaffs_CheckpointObject;
+
+/*--------------------- Temporary buffers ----------------
+ *
+ * These are chunk-sized working buffers. Each device has a few
+ */
+
+typedef struct {
+       __u8 *buffer;
+       int line;       /* track from whence this buffer was allocated */
+       int maxLine;
+} yaffs_TempBuffer;
+
+/*----------------- Device ---------------------------------*/
+
+struct yaffs_DeviceStruct {
+       struct list_head devList;
+       const char *name;
+
+       /* Entry parameters set up way early. Yaffs sets up the rest.*/
+       int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
+       int nChunksPerBlock;    /* does not need to be a power of 2 */
+       int nBytesPerSpare;     /* spare area size */
+       int startBlock;         /* Start block we're allowed to use */
+       int endBlock;           /* End block we're allowed to use */
+       int nReservedBlocks;    /* We want this tuneable so that we can reduce */
+                               /* reserved blocks on NOR and RAM. */
+
+
+       /* Stuff used by the shared space checkpointing mechanism */
+       /* If this value is zero, then this mechanism is disabled */
+
+       int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
+
+
+
+
+       int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
+                                * the number of short op caches (don't use too many)
+                                */
+
+       int useHeaderFileSize;  /* Flag to determine if we should use file sizes from the header */
+
+       int useNANDECC;         /* Flag to decide whether or not to use NANDECC */
+
+       void *genericDevice;    /* Pointer to device context
+                                * On an mtd this holds the mtd pointer.
+                                */
+        void *superBlock;
+
+       /* NAND access functions (Must be set before calling YAFFS)*/
+
+       int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
+                                int chunkInNAND, const __u8 * data,
+                                const yaffs_Spare * spare);
+       int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev,
+                                 int chunkInNAND, __u8 * data,
+                                 yaffs_Spare * spare);
+       int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
+                                int blockInNAND);
+       int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
+
+#ifdef CONFIG_YAFFS_YAFFS2
+       int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
+                                        int chunkInNAND, const __u8 * data,
+                                        const yaffs_ExtendedTags * tags);
+       int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev,
+                                         int chunkInNAND, __u8 * data,
+                                         yaffs_ExtendedTags * tags);
+       int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo);
+       int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo,
+                              yaffs_BlockState * state, int *sequenceNumber);
+#endif
+
+       int isYaffs2;
+
+       /* The removeObjectCallback function must be supplied by OS flavours that
+        * need it. The Linux kernel does not use this, but yaffs direct does use
+        * it to implement the faster readdir
+        */
+       void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
+
+       /* Callback to mark the superblock dirsty */
+       void (*markSuperBlockDirty)(void * superblock);
+
+       int wideTnodesDisabled; /* Set to disable wide tnodes */
+
+
+       /* End of stuff that must be set before initialisation. */
+
+       /* Checkpoint control. Can be set before or after initialisation */
+       __u8 skipCheckpointRead;
+       __u8 skipCheckpointWrite;
+
+       /* Runtime parameters. Set up by YAFFS. */
+
+       __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
+       __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
+
+       /* Stuff to support wide tnodes */
+       __u32 tnodeWidth;
+       __u32 tnodeMask;
+
+       /* Stuff to support various file offses to chunk/offset translations */
+       /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
+       __u32 crumbMask;
+       __u32 crumbShift;
+       __u32 crumbsPerChunk;
+
+       /* Straight shifting for nDataBytesPerChunk being a power of 2 */
+       __u32 chunkShift;
+       __u32 chunkMask;
+
+
+#ifdef __KERNEL__
+
+       struct semaphore sem;   /* Semaphore for waiting on erasure.*/
+       struct semaphore grossLock;     /* Gross locking semaphore */
+       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
+                                * at compile time so we have to allocate it.
+                                */
+       void (*putSuperFunc) (struct super_block * sb);
+#endif
+
+       int isMounted;
+
+       int isCheckpointed;
+
+
+       /* Stuff to support block offsetting to support start block zero */
+       int internalStartBlock;
+       int internalEndBlock;
+       int blockOffset;
+       int chunkOffset;
+
+
+       /* Runtime checkpointing stuff */
+       int checkpointPageSequence;   /* running sequence number of checkpoint pages */
+       int checkpointByteCount;
+       int checkpointByteOffset;
+       __u8 *checkpointBuffer;
+       int checkpointOpenForWrite;
+       int blocksInCheckpoint;
+       int checkpointCurrentChunk;
+       int checkpointCurrentBlock;
+       int checkpointNextBlock;
+       int *checkpointBlockList;
+       int checkpointMaxBlocks;
+       __u32 checkpointSum;
+       __u32 checkpointXor;
+
+       /* Block Info */
+       yaffs_BlockInfo *blockInfo;
+       __u8 *chunkBits;        /* bitmap of chunks in use */
+       unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
+       unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
+       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
+                                * Must be consistent with nChunksPerBlock.
+                                */
+
+       int nErasedBlocks;
+       int allocationBlock;    /* Current block being allocated off */
+       __u32 allocationPage;
+       int allocationBlockFinder;      /* Used to search for next allocation block */
+
+       /* Runtime state */
+       int nTnodesCreated;
+       yaffs_Tnode *freeTnodes;
+       int nFreeTnodes;
+       yaffs_TnodeList *allocatedTnodeList;
+
+       int isDoingGC;
+
+       int nObjectsCreated;
+       yaffs_Object *freeObjects;
+       int nFreeObjects;
+
+       yaffs_ObjectList *allocatedObjectList;
+
+       yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
+
+       int nFreeChunks;
+
+       int currentDirtyChecker;        /* Used to find current dirtiest block */
+
+       __u32 *gcCleanupList;   /* objects to delete at the end of a GC. */
+       int nonAggressiveSkip;  /* GC state/mode */
+
+       /* Statistcs */
+       int nPageWrites;
+       int nPageReads;
+       int nBlockErasures;
+       int nErasureFailures;
+       int nGCCopies;
+       int garbageCollections;
+       int passiveGarbageCollections;
+       int nRetriedWrites;
+       int nRetiredBlocks;
+       int eccFixed;
+       int eccUnfixed;
+       int tagsEccFixed;
+       int tagsEccUnfixed;
+       int nDeletions;
+       int nUnmarkedDeletions;
+
+       int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
+
+       /* Special directories */
+       yaffs_Object *rootDir;
+       yaffs_Object *lostNFoundDir;
+
+       /* Buffer areas for storing data to recover from write failures TODO
+        *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
+        *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
+        */
+
+       int bufferedBlock;      /* Which block is buffered here? */
+       int doingBufferedBlockRewrite;
+
+       yaffs_ChunkCache *srCache;
+       int srLastUse;
+
+       int cacheHits;
+
+       /* Stuff for background deletion and unlinked files.*/
+       yaffs_Object *unlinkedDir;      /* Directory where unlinked and deleted files live. */
+       yaffs_Object *deletedDir;       /* Directory where deleted objects are sent to disappear. */
+       yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/
+       int nDeletedFiles;              /* Count of files awaiting deletion;*/
+       int nUnlinkedFiles;             /* Count of unlinked files. */
+       int nBackgroundDeletions;       /* Count of background deletions. */
+
+
+       yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
+       int maxTemp;
+       int unmanagedTempAllocations;
+       int unmanagedTempDeallocations;
+
+       /* yaffs2 runtime stuff */
+       unsigned sequenceNumber;        /* Sequence number of currently allocating block */
+       unsigned oldestDirtySequence;
+
+};
+
+typedef struct yaffs_DeviceStruct yaffs_Device;
+
+/* The static layout of bllock usage etc is stored in the super block header */
+typedef struct {
+        int StructType;
+       int version;
+       int checkpointStartBlock;
+       int checkpointEndBlock;
+       int startBlock;
+       int endBlock;
+       int rfu[100];
+} yaffs_SuperBlockHeader;
+
+/* The CheckpointDevice structure holds the device information that changes at runtime and
+ * must be preserved over unmount/mount cycles.
+ */
+typedef struct {
+        int structType;
+       int nErasedBlocks;
+       int allocationBlock;    /* Current block being allocated off */
+       __u32 allocationPage;
+       int nFreeChunks;
+
+       int nDeletedFiles;              /* Count of files awaiting deletion;*/
+       int nUnlinkedFiles;             /* Count of unlinked files. */
+       int nBackgroundDeletions;       /* Count of background deletions. */
+
+       /* yaffs2 runtime stuff */
+       unsigned sequenceNumber;        /* Sequence number of currently allocating block */
+       unsigned oldestDirtySequence;
+
+} yaffs_CheckpointDevice;
+
+
+typedef struct {
+    int structType;
+    __u32 magic;
+    __u32 version;
+    __u32 head;
+} yaffs_CheckpointValidity;
+
+/* Function to manipulate block info */
+static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
+{
+       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR
+                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
+                  blk));
+               YBUG();
+       }
+       return &dev->blockInfo[blk - dev->internalStartBlock];
+}
+
+/*----------------------- YAFFS Functions -----------------------*/
+
+int yaffs_GutsInitialise(yaffs_Device * dev);
+void yaffs_Deinitialise(yaffs_Device * dev);
+
+int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev);
+
+int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
+                      yaffs_Object * newDir, const YCHAR * newName);
+
+int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name);
+int yaffs_DeleteFile(yaffs_Object * obj);
+
+int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize);
+int yaffs_GetObjectFileLength(yaffs_Object * obj);
+int yaffs_GetObjectInode(yaffs_Object * obj);
+unsigned yaffs_GetObjectType(yaffs_Object * obj);
+int yaffs_GetObjectLinkCount(yaffs_Object * obj);
+
+int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr);
+int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr);
+
+/* File operations */
+int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
+                          int nBytes);
+int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
+                         int nBytes, int writeThrough);
+int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
+
+yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
+                             __u32 mode, __u32 uid, __u32 gid);
+int yaffs_FlushFile(yaffs_Object * obj, int updateTime);
+
+/* Flushing and checkpointing */
+void yaffs_FlushEntireDeviceCache(yaffs_Device *dev);
+
+int yaffs_CheckpointSave(yaffs_Device *dev);
+int yaffs_CheckpointRestore(yaffs_Device *dev);
+
+/* Directory operations */
+yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
+                                  __u32 mode, __u32 uid, __u32 gid);
+yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name);
+int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
+                                  int (*fn) (yaffs_Object *));
+
+yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number);
+
+/* Link operations */
+yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
+                        yaffs_Object * equivalentObject);
+
+yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj);
+
+/* Symlink operations */
+yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
+                                __u32 mode, __u32 uid, __u32 gid,
+                                const YCHAR * alias);
+YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj);
+
+/* Special inodes (fifos, sockets and devices) */
+yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
+                                __u32 mode, __u32 uid, __u32 gid, __u32 rdev);
+
+/* Special directories */
+yaffs_Object *yaffs_Root(yaffs_Device * dev);
+yaffs_Object *yaffs_LostNFound(yaffs_Device * dev);
+
+#ifdef CONFIG_YAFFS_WINCE
+/* CONFIG_YAFFS_WINCE special stuff */
+void yfsd_WinFileTimeNow(__u32 target[2]);
+#endif
+
+#ifdef __KERNEL__
+
+void yaffs_HandleDeferedFree(yaffs_Object * obj);
+#endif
+
+/* Debug dump  */
+int yaffs_DumpObject(yaffs_Object * obj);
+
+void yaffs_GutsTest(yaffs_Device * dev);
+
+/* A few useful functions */
+void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
+void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn);
+int yaffs_CheckFF(__u8 * buffer, int nBytes);
+void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.c
new file mode 100644 (file)
index 0000000..466e5a4
--- /dev/null
@@ -0,0 +1,241 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+const char *yaffs_mtdif_c_version =
+    "$Id: yaffs_mtdif.c,v 1.19 2007-02-14 01:09:06 wookey Exp $";
+
+#include "yportenv.h"
+
+
+#include "yaffs_mtdif.h"
+
+#include "linux/mtd/mtd.h"
+#include "linux/types.h"
+#include "linux/time.h"
+#include "linux/mtd/nand.h"
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
+static struct nand_oobinfo yaffs_oobinfo = {
+       .useecc = 1,
+       .eccbytes = 6,
+       .eccpos = {8, 9, 10, 13, 14, 15}
+};
+
+static struct nand_oobinfo yaffs_noeccinfo = {
+       .useecc = 0,
+};
+#endif
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
+{
+       oob[0] = spare->tagByte0;
+       oob[1] = spare->tagByte1;
+       oob[2] = spare->tagByte2;
+       oob[3] = spare->tagByte3;
+       oob[4] = spare->tagByte4;
+       oob[5] = spare->tagByte5 & 0x3f;
+       oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80;
+       oob[5] |= spare->pageStatus == 0 ? 0: 0x40;
+       oob[6] = spare->tagByte6;
+       oob[7] = spare->tagByte7;
+}
+
+static inline void translate_oob2spare(yaffs_Spare *spare, __u8 *oob)
+{
+       struct yaffs_NANDSpare *nspare = (struct yaffs_NANDSpare *)spare;
+       spare->tagByte0 = oob[0];
+       spare->tagByte1 = oob[1];
+       spare->tagByte2 = oob[2];
+       spare->tagByte3 = oob[3];
+       spare->tagByte4 = oob[4];
+       spare->tagByte5 = oob[5] == 0xff ? 0xff : oob[5] & 0x3f;
+       spare->blockStatus = oob[5] & 0x80 ? 0xff : 'Y';
+       spare->pageStatus = oob[5] & 0x40 ? 0xff : 0;
+       spare->ecc1[0] = spare->ecc1[1] = spare->ecc1[2] = 0xff;
+       spare->tagByte6 = oob[6];
+       spare->tagByte7 = oob[7];
+       spare->ecc2[0] = spare->ecc2[1] = spare->ecc2[2] = 0xff;
+
+       nspare->eccres1 = nspare->eccres2 = 0; /* FIXME */
+}
+#endif
+
+int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
+                            const __u8 * data, const yaffs_Spare * spare)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       struct mtd_oob_ops ops;
+#endif
+       size_t dummy;
+       int retval = 0;
+
+       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       __u8 spareAsBytes[8]; /* OOB */
+
+       if (data && !spare)
+               retval = mtd->write(mtd, addr, dev->nDataBytesPerChunk,
+                               &dummy, data);
+       else if (spare) {
+               if (dev->useNANDECC) {
+                       translate_spare2oob(spare, spareAsBytes);
+                       ops.mode = MTD_OOB_AUTO;
+                       ops.ooblen = 8; /* temp hack */
+               } else {
+                       ops.mode = MTD_OOB_RAW;
+                       ops.ooblen = YAFFS_BYTES_PER_SPARE;
+               }
+               ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
+               ops.datbuf = (u8 *)data;
+               ops.ooboffs = 0;
+               ops.oobbuf = spareAsBytes;
+               retval = mtd->write_oob(mtd, addr, &ops);
+       }
+#else
+       __u8 *spareAsBytes = (__u8 *) spare;
+
+       if (data && spare) {
+               if (dev->useNANDECC)
+                       retval =
+                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                          &dummy, data, spareAsBytes,
+                                          &yaffs_oobinfo);
+               else
+                       retval =
+                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                          &dummy, data, spareAsBytes,
+                                          &yaffs_noeccinfo);
+       } else {
+               if (data)
+                       retval =
+                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
+                                      data);
+               if (spare)
+                       retval =
+                           mtd->write_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
+                                          &dummy, spareAsBytes);
+       }
+#endif
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
+int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
+                             yaffs_Spare * spare)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       struct mtd_oob_ops ops;
+#endif
+       size_t dummy;
+       int retval = 0;
+
+       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       __u8 spareAsBytes[8]; /* OOB */
+
+       if (data && !spare)
+               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
+                               &dummy, data);
+       else if (spare) {
+               if (dev->useNANDECC) {
+                       ops.mode = MTD_OOB_AUTO;
+                       ops.ooblen = 8; /* temp hack */
+               } else {
+                       ops.mode = MTD_OOB_RAW;
+                       ops.ooblen = YAFFS_BYTES_PER_SPARE;
+               }
+               ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
+               ops.datbuf = data;
+               ops.ooboffs = 0;
+               ops.oobbuf = spareAsBytes;
+               retval = mtd->read_oob(mtd, addr, &ops);
+               if (dev->useNANDECC)
+                       translate_oob2spare(spare, spareAsBytes);
+       }
+#else
+       __u8 *spareAsBytes = (__u8 *) spare;
+
+       if (data && spare) {
+               if (dev->useNANDECC) {
+                       /* Careful, this call adds 2 ints */
+                       /* to the end of the spare data.  Calling function */
+                       /* should allocate enough memory for spare, */
+                       /* i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. */
+                       retval =
+                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                         &dummy, data, spareAsBytes,
+                                         &yaffs_oobinfo);
+               } else {
+                       retval =
+                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                         &dummy, data, spareAsBytes,
+                                         &yaffs_noeccinfo);
+               }
+       } else {
+               if (data)
+                       retval =
+                           mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
+                                     data);
+               if (spare)
+                       retval =
+                           mtd->read_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
+                                         &dummy, spareAsBytes);
+       }
+#endif
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
+int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+       __u32 addr =
+           ((loff_t) blockNumber) * dev->nDataBytesPerChunk
+               * dev->nChunksPerBlock;
+       struct erase_info ei;
+       int retval = 0;
+
+       ei.mtd = mtd;
+       ei.addr = addr;
+       ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock;
+       ei.time = 1000;
+       ei.retries = 2;
+       ei.callback = NULL;
+       ei.priv = (u_long) dev;
+
+       /* Todo finish off the ei if required */
+
+       sema_init(&dev->sem, 0);
+
+       retval = mtd->erase(mtd, &ei);
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
+int nandmtd_InitialiseNAND(yaffs_Device * dev)
+{
+       return YAFFS_OK;
+}
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif.h
new file mode 100644 (file)
index 0000000..317600c
--- /dev/null
@@ -0,0 +1,27 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_MTDIF_H__
+#define __YAFFS_MTDIF_H__
+
+#include "yaffs_guts.h"
+
+int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
+                            const __u8 * data, const yaffs_Spare * spare);
+int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
+                             yaffs_Spare * spare);
+int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber);
+int nandmtd_InitialiseNAND(yaffs_Device * dev);
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1-compat.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1-compat.c
new file mode 100644 (file)
index 0000000..6a376f1
--- /dev/null
@@ -0,0 +1,434 @@
+From ian@brightstareng.com Fri May 18 15:06:49 2007
+From ian@brightstareng.com Fri May 18 15:08:21 2007
+Received: from 206.173.66.57.ptr.us.xo.net ([206.173.66.57] helo=zebra.brightstareng.com)
+       by apollo.linkchoose.co.uk with esmtp (Exim 4.60)
+       (envelope-from <ian@brightstareng.com>)
+       id 1Hp380-00011e-T6
+       for david.goodenough@linkchoose.co.uk; Fri, 18 May 2007 15:08:21 +0100
+Received: from localhost (localhost.localdomain [127.0.0.1])
+       by zebra.brightstareng.com (Postfix) with ESMTP
+       id 4819F28C004; Fri, 18 May 2007 10:07:49 -0400 (EDT)
+Received: from zebra.brightstareng.com ([127.0.0.1])
+ by localhost (zebra [127.0.0.1]) (amavisd-new, port 10024) with ESMTP
+ id 05328-06; Fri, 18 May 2007 10:07:16 -0400 (EDT)
+Received: from pippin (unknown [192.168.1.25])
+       by zebra.brightstareng.com (Postfix) with ESMTP
+       id 8BEF528C1BC; Fri, 18 May 2007 10:06:53 -0400 (EDT)
+From: Ian McDonnell <ian@brightstareng.com>
+To: David Goodenough <david.goodenough@linkchoose.co.uk>
+Subject: Re: something tested this time -- yaffs_mtdif1-compat.c
+Date: Fri, 18 May 2007 10:06:49 -0400
+User-Agent: KMail/1.9.1
+References: <200705142207.06909.ian@brightstareng.com> <200705171131.53536.ian@brightstareng.com> <200705181334.32166.david.goodenough@linkchoose.co.uk>
+In-Reply-To: <200705181334.32166.david.goodenough@linkchoose.co.uk>
+Cc: Andrea Conti <alyf@alyf.net>,
+ Charles Manning <manningc2@actrix.gen.nz>
+MIME-Version: 1.0
+Content-Type: Multipart/Mixed;
+  boundary="Boundary-00=_5LbTGmt62YoutxM"
+Message-Id: <200705181006.49860.ian@brightstareng.com>
+X-Virus-Scanned: by amavisd-new at brightstareng.com
+Status: R
+X-Status: NT
+X-KMail-EncryptionState:
+X-KMail-SignatureState:
+X-KMail-MDN-Sent:
+
+--Boundary-00=_5LbTGmt62YoutxM
+Content-Type: text/plain;
+  charset="iso-8859-15"
+Content-Transfer-Encoding: 7bit
+Content-Disposition: inline
+
+David, Andrea,
+
+On Friday 18 May 2007 08:34, you wrote:
+> Yea team.  With this fix in place (I put it in the wrong place
+> at first) I can now mount and ls the Yaffs partition without
+> an error messages!
+
+Good news!
+
+Attached is a newer yaffs_mtdif1.c with a bandaid to help the
+2.6.18 and 2.6.19 versions of MTD not trip on the oob read.
+See the LINUX_VERSION_CODE conditional in
+nandmtd1_ReadChunkWithTagsFromNAND.
+
+-imcd
+
+--Boundary-00=_5LbTGmt62YoutxM
+Content-Type: text/x-csrc;
+  charset="iso-8859-15";
+  name="yaffs_mtdif1.c"
+Content-Transfer-Encoding: 7bit
+Content-Disposition: attachment;
+       filename="yaffs_mtdif1.c"
+
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * yaffs_mtdif1.c  NAND mtd interface functions for small-page NAND.
+ *
+ * Copyright (C) 2002 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This module provides the interface between yaffs_nand.c and the
+ * MTD API.  This version is used when the MTD interface supports the
+ * 'mtd_oob_ops' style calls to read_oob and write_oob, circa 2.6.17,
+ * and we have small-page NAND device.
+ *
+ * These functions are invoked via function pointers in yaffs_nand.c.
+ * This replaces functionality provided by functions in yaffs_mtdif.c
+ * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are
+ * called in yaffs_mtdif.c when the function pointers are NULL.
+ * We assume the MTD layer is performing ECC (useNANDECC is true).
+ */
+
+#include "yportenv.h"
+#include "yaffs_guts.h"
+#include "yaffs_packedtags1.h"
+#include "yaffs_tagscompat.h"  // for yaffs_CalcTagsECC
+
+#include "linux/kernel.h"
+#include "linux/version.h"
+#include "linux/types.h"
+#include "linux/mtd/mtd.h"
+
+/* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+
+const char *yaffs_mtdif1_c_version = "$Id$";
+
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+# define YTAG1_SIZE 8
+#else
+# define YTAG1_SIZE 9
+#endif
+
+#if 0
+/* Use the following nand_ecclayout with MTD when using
+ * CONFIG_YAFFS_9BYTE_TAGS and the older on-NAND tags layout.
+ * If you have existing Yaffs images and the byte order differs from this,
+ * adjust 'oobfree' to match your existing Yaffs data.
+ *
+ * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the
+ * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to
+ * the 9th byte.
+ *
+ * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5
+ * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P
+ * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus
+ * byte and B is the small-page bad-block indicator byte.
+ */
+static struct nand_ecclayout nand_oob_16 = {
+       .eccbytes = 6,
+       .eccpos = { 8, 9, 10, 13, 14, 15 },
+       .oobavail = 9,
+       .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } }
+};
+#endif
+
+/* Write a chunk (page) of data to NAND.
+ *
+ * Caller always provides ExtendedTags data which are converted to a more
+ * compact (packed) form for storage in NAND.  A mini-ECC runs over the
+ * contents of the tags meta-data; used to valid the tags when read.
+ *
+ *  - Pack ExtendedTags to PackedTags1 form
+ *  - Compute mini-ECC for PackedTags1
+ *  - Write data and packed tags to NAND.
+ *
+ * Note: Due to the use of the PackedTags1 meta-data which does not include
+ * a full sequence number (as found in the larger PackedTags2 form) it is
+ * necessary for Yaffs to re-write a chunk/page (just once) to mark it as
+ * discarded and dirty.  This is not ideal: newer NAND parts are supposed
+ * to be written just once.  When Yaffs performs this operation, this
+ * function is called with a NULL data pointer -- calling MTD write_oob
+ * without data is valid usage (2.6.17).
+ *
+ * Any underlying MTD error results in YAFFS_FAIL.
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
+       int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkBytes = dev->nDataBytesPerChunk;
+       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
+       struct mtd_oob_ops ops;
+       yaffs_PackedTags1 pt1;
+       int retval;
+
+       /* we assume that PackedTags1 and yaffs_Tags are compatible */
+       compile_time_assertion(sizeof(yaffs_PackedTags1) == 12);
+       compile_time_assertion(sizeof(yaffs_Tags) == 8);
+
+       yaffs_PackTags1(&pt1, etags);
+       yaffs_CalcTagsECC((yaffs_Tags *)&pt1);
+
+       /* When deleting a chunk, the upper layer provides only skeletal
+        * etags, one with chunkDeleted set.  However, we need to update the
+        * tags, not erase them completely.  So we use the NAND write property
+        * that only zeroed-bits stick and set tag bytes to all-ones and
+        * zero just the (not) deleted bit.
+        */
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+       if (etags->chunkDeleted) {
+               memset(&pt1, 0xff, 8);
+               /* clear delete status bit to indicate deleted */
+               pt1.deleted = 0;
+       }
+#else
+       ((__u8 *)&pt1)[8] = 0xff;
+       if (etags->chunkDeleted) {
+               memset(&pt1, 0xff, 8);
+               /* zero pageStatus byte to indicate deleted */
+               ((__u8 *)&pt1)[8] = 0;
+       }
+#endif
+
+       memset(&ops, 0, sizeof(ops));
+       ops.mode = MTD_OOB_AUTO;
+       ops.len = (data) ? chunkBytes : 0;
+       ops.ooblen = YTAG1_SIZE;
+       ops.datbuf = (__u8 *)data;
+       ops.oobbuf = (__u8 *)&pt1;
+
+       retval = mtd->write_oob(mtd, addr, &ops);
+       if (retval) {
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d\n",
+                       chunkInNAND, retval);
+       }
+       return retval ? YAFFS_FAIL : YAFFS_OK;
+}
+
+/* Return with empty ExtendedTags but add eccResult.
+ */
+static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
+{
+       if (etags) {
+               memset(etags, 0, sizeof(*etags));
+               etags->eccResult = eccResult;
+       }
+       return retval;
+}
+
+/* Read a chunk (page) from NAND.
+ *
+ * Caller expects ExtendedTags data to be usable even on error; that is,
+ * all members except eccResult and blockBad are zeroed.
+ *
+ *  - Check ECC results for data (if applicable)
+ *  - Check for blank/erased block (return empty ExtendedTags if blank)
+ *  - Check the PackedTags1 mini-ECC (correct if necessary/possible)
+ *  - Convert PackedTags1 to ExtendedTags
+ *  - Update eccResult and blockBad members to refect state.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
+       int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkBytes = dev->nDataBytesPerChunk;
+       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
+       int eccres = YAFFS_ECC_RESULT_NO_ERROR;
+       struct mtd_oob_ops ops;
+       yaffs_PackedTags1 pt1;
+       int retval;
+       int deleted;
+
+       memset(&ops, 0, sizeof(ops));
+       ops.mode = MTD_OOB_AUTO;
+       ops.len = (data) ? chunkBytes : 0;
+       ops.ooblen = YTAG1_SIZE;
+       ops.datbuf = data;
+       ops.oobbuf = (__u8 *)&pt1;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+       /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
+        * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
+        */
+       ops.len = (ops.datbuf) ? ops.len : ops.ooblen;
+#endif
+       /* Read page and oob using MTD.
+        * Check status and determine ECC result.
+        */
+       retval = mtd->read_oob(mtd, addr, &ops);
+       if (retval) {
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d\n",
+                       chunkInNAND, retval);
+       }
+
+       switch (retval) {
+       case 0:
+               /* no error */
+               break;
+
+       case -EUCLEAN:
+               /* MTD's ECC fixed the data */
+               eccres = YAFFS_ECC_RESULT_FIXED;
+               dev->eccFixed++;
+               break;
+
+       case -EBADMSG:
+               /* MTD's ECC could not fix the data */
+               dev->eccUnfixed++;
+               /* fall into... */
+       default:
+               rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
+               etags->blockBad = (mtd->block_isbad)(mtd, addr);
+               return YAFFS_FAIL;
+       }
+
+       /* Check for a blank/erased chunk.
+        */
+       if (yaffs_CheckFF((__u8 *)&pt1, 8)) {
+               /* when blank, upper layers want eccResult to be <= NO_ERROR */
+               return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
+       }
+
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+       /* Read deleted status (bit) then return it to it's non-deleted
+        * state before performing tags mini-ECC check. pt1.deleted is
+        * inverted.
+        */
+       deleted = !pt1.deleted;
+       pt1.deleted = 1;
+#else
+       (void) deleted; /* not used */
+#endif
+
+       /* Check the packed tags mini-ECC and correct if necessary/possible.
+        */
+       retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1);
+       switch (retval) {
+       case 0:
+               /* no tags error, use MTD result */
+               break;
+       case 1:
+               /* recovered tags-ECC error */
+               dev->tagsEccFixed++;
+               eccres = YAFFS_ECC_RESULT_FIXED;
+               break;
+       default:
+               /* unrecovered tags-ECC error */
+               dev->tagsEccUnfixed++;
+               return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL);
+       }
+
+       /* Unpack the tags to extended form and set ECC result.
+        * [set shouldBeFF just to keep yaffs_UnpackTags1 happy]
+        */
+       pt1.shouldBeFF = 0xFFFFFFFF;
+       yaffs_UnpackTags1(etags, &pt1);
+       etags->eccResult = eccres;
+
+       /* Set deleted state.
+        */
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+       etags->chunkDeleted = deleted;
+#else
+       etags->chunkDeleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7);
+#endif
+       return YAFFS_OK;
+}
+
+/* Mark a block bad.
+ *
+ * This is a persistant state.
+ * Use of this function should be rare.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
+       int retval;
+
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
+
+       retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
+       return (retval) ? YAFFS_FAIL : YAFFS_OK;
+}
+
+/* Check any MTD prerequists.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
+{
+       /* 2.6.18 has mtd->ecclayout->oobavail */
+       /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
+       int oobavail = mtd->ecclayout->oobavail;
+
+       if (oobavail < YTAG1_SIZE) {
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d",
+                       oobavail, YTAG1_SIZE);
+               return YAFFS_FAIL;
+       }
+       return YAFFS_OK;
+}
+
+/* Query for the current state of a specific block.
+ *
+ * Examine the tags of the first chunk of the block and return the state:
+ *  - YAFFS_BLOCK_STATE_DEAD, the block is marked bad
+ *  - YAFFS_BLOCK_STATE_NEEDS_SCANNING, the block is in use
+ *  - YAFFS_BLOCK_STATE_EMPTY, the block is clean
+ *
+ * Always returns YAFFS_OK.
+ */
+int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+       yaffs_BlockState * pState, int *pSequenceNumber)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkNo = blockNo * dev->nChunksPerBlock;
+       yaffs_ExtendedTags etags;
+       int state = YAFFS_BLOCK_STATE_DEAD;
+       int seqnum = 0;
+       int retval;
+
+       /* We don't yet have a good place to test for MTD config prerequists.
+        * Do it here as we are called during the initial scan.
+        */
+       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
+               return YAFFS_FAIL;
+       }
+
+       retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
+       if (etags.blockBad) {
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad", blockNo);
+               state = YAFFS_BLOCK_STATE_DEAD;
+       }
+       else if (etags.chunkUsed) {
+               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+               seqnum = etags.sequenceNumber;
+       }
+       else {
+               state = YAFFS_BLOCK_STATE_EMPTY;
+       }
+
+       *pState = state;
+       *pSequenceNumber = seqnum;
+
+       /* query always succeeds */
+       return YAFFS_OK;
+}
+
+#endif /*KERNEL_VERSION*/
+
+--Boundary-00=_5LbTGmt62YoutxM--
+
+
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.c
new file mode 100644 (file)
index 0000000..36d5ade
--- /dev/null
@@ -0,0 +1,363 @@
+/*
+ * YAFFS: Yet another FFS. A NAND-flash specific file system.
+ * yaffs_mtdif1.c  NAND mtd interface functions for small-page NAND.
+ *
+ * Copyright (C) 2002 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/*
+ * This module provides the interface between yaffs_nand.c and the
+ * MTD API.  This version is used when the MTD interface supports the
+ * 'mtd_oob_ops' style calls to read_oob and write_oob, circa 2.6.17,
+ * and we have small-page NAND device.
+ *
+ * These functions are invoked via function pointers in yaffs_nand.c.
+ * This replaces functionality provided by functions in yaffs_mtdif.c
+ * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are
+ * called in yaffs_mtdif.c when the function pointers are NULL.
+ * We assume the MTD layer is performing ECC (useNANDECC is true).
+ */
+
+#include "yportenv.h"
+#include "yaffs_guts.h"
+#include "yaffs_packedtags1.h"
+#include "yaffs_tagscompat.h"  // for yaffs_CalcTagsECC
+
+#include "linux/kernel.h"
+#include "linux/version.h"
+#include "linux/types.h"
+#include "linux/mtd/mtd.h"
+
+/* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+
+const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.3 2007/05/15 20:16:11 ian Exp $";
+
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+# define YTAG1_SIZE 8
+#else
+# define YTAG1_SIZE 9
+#endif
+
+#if 0
+/* Use the following nand_ecclayout with MTD when using
+ * CONFIG_YAFFS_9BYTE_TAGS and the older on-NAND tags layout.
+ * If you have existing Yaffs images and the byte order differs from this,
+ * adjust 'oobfree' to match your existing Yaffs data.
+ *
+ * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the
+ * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to
+ * the 9th byte.
+ *
+ * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5
+ * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P
+ * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus
+ * byte and B is the small-page bad-block indicator byte.
+ */
+static struct nand_ecclayout nand_oob_16 = {
+       .eccbytes = 6,
+       .eccpos = { 8, 9, 10, 13, 14, 15 },
+       .oobavail = 9,
+       .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } }
+};
+#endif
+
+/* Write a chunk (page) of data to NAND.
+ *
+ * Caller always provides ExtendedTags data which are converted to a more
+ * compact (packed) form for storage in NAND.  A mini-ECC runs over the
+ * contents of the tags meta-data; used to valid the tags when read.
+ *
+ *  - Pack ExtendedTags to PackedTags1 form
+ *  - Compute mini-ECC for PackedTags1
+ *  - Write data and packed tags to NAND.
+ *
+ * Note: Due to the use of the PackedTags1 meta-data which does not include
+ * a full sequence number (as found in the larger PackedTags2 form) it is
+ * necessary for Yaffs to re-write a chunk/page (just once) to mark it as
+ * discarded and dirty.  This is not ideal: newer NAND parts are supposed
+ * to be written just once.  When Yaffs performs this operation, this
+ * function is called with a NULL data pointer -- calling MTD write_oob
+ * without data is valid usage (2.6.17).
+ *
+ * Any underlying MTD error results in YAFFS_FAIL.
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
+       int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkBytes = dev->nDataBytesPerChunk;
+       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
+       struct mtd_oob_ops ops;
+       yaffs_PackedTags1 pt1;
+       int retval;
+
+       /* we assume that PackedTags1 and yaffs_Tags are compatible */
+       compile_time_assertion(sizeof(yaffs_PackedTags1) == 12);
+       compile_time_assertion(sizeof(yaffs_Tags) == 8);
+
+       dev->nPageWrites++;
+
+       yaffs_PackTags1(&pt1, etags);
+       yaffs_CalcTagsECC((yaffs_Tags *)&pt1);
+
+       /* When deleting a chunk, the upper layer provides only skeletal
+        * etags, one with chunkDeleted set.  However, we need to update the
+        * tags, not erase them completely.  So we use the NAND write property
+        * that only zeroed-bits stick and set tag bytes to all-ones and
+        * zero just the (not) deleted bit.
+        */
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+       if (etags->chunkDeleted) {
+               memset(&pt1, 0xff, 8);
+               /* clear delete status bit to indicate deleted */
+               pt1.deleted = 0;
+       }
+#else
+       ((__u8 *)&pt1)[8] = 0xff;
+       if (etags->chunkDeleted) {
+               memset(&pt1, 0xff, 8);
+               /* zero pageStatus byte to indicate deleted */
+               ((__u8 *)&pt1)[8] = 0;
+       }
+#endif
+
+       memset(&ops, 0, sizeof(ops));
+       ops.mode = MTD_OOB_AUTO;
+       ops.len = (data) ? chunkBytes : 0;
+       ops.ooblen = YTAG1_SIZE;
+       ops.datbuf = (__u8 *)data;
+       ops.oobbuf = (__u8 *)&pt1;
+
+       retval = mtd->write_oob(mtd, addr, &ops);
+       if (retval) {
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "write_oob failed, chunk %d, mtd error %d\n",
+                       chunkInNAND, retval);
+       }
+       return retval ? YAFFS_FAIL : YAFFS_OK;
+}
+
+/* Return with empty ExtendedTags but add eccResult.
+ */
+static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
+{
+       if (etags) {
+               memset(etags, 0, sizeof(*etags));
+               etags->eccResult = eccResult;
+       }
+       return retval;
+}
+
+/* Read a chunk (page) from NAND.
+ *
+ * Caller expects ExtendedTags data to be usable even on error; that is,
+ * all members except eccResult and blockBad are zeroed.
+ *
+ *  - Check ECC results for data (if applicable)
+ *  - Check for blank/erased block (return empty ExtendedTags if blank)
+ *  - Check the PackedTags1 mini-ECC (correct if necessary/possible)
+ *  - Convert PackedTags1 to ExtendedTags
+ *  - Update eccResult and blockBad members to refect state.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
+       int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkBytes = dev->nDataBytesPerChunk;
+       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
+       int eccres = YAFFS_ECC_RESULT_NO_ERROR;
+       struct mtd_oob_ops ops;
+       yaffs_PackedTags1 pt1;
+       int retval;
+       int deleted;
+
+       dev->nPageReads++;
+
+       memset(&ops, 0, sizeof(ops));
+       ops.mode = MTD_OOB_AUTO;
+       ops.len = (data) ? chunkBytes : 0;
+       ops.ooblen = YTAG1_SIZE;
+       ops.datbuf = data;
+       ops.oobbuf = (__u8 *)&pt1;
+
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
+       /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
+        * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
+        */
+       ops.len = (ops.datbuf) ? ops.len : ops.ooblen;
+#endif
+       /* Read page and oob using MTD.
+        * Check status and determine ECC result.
+        */
+       retval = mtd->read_oob(mtd, addr, &ops);
+       if (retval) {
+               yaffs_trace(YAFFS_TRACE_MTD,
+                       "read_oob failed, chunk %d, mtd error %d\n",
+                       chunkInNAND, retval);
+       }
+
+       switch (retval) {
+       case 0:
+               /* no error */
+               break;
+
+       case -EUCLEAN:
+               /* MTD's ECC fixed the data */
+               eccres = YAFFS_ECC_RESULT_FIXED;
+               dev->eccFixed++;
+               break;
+
+       case -EBADMSG:
+               /* MTD's ECC could not fix the data */
+               dev->eccUnfixed++;
+               /* fall into... */
+       default:
+               rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
+               etags->blockBad = (mtd->block_isbad)(mtd, addr);
+               return YAFFS_FAIL;
+       }
+
+       /* Check for a blank/erased chunk.
+        */
+       if (yaffs_CheckFF((__u8 *)&pt1, 8)) {
+               /* when blank, upper layers want eccResult to be <= NO_ERROR */
+               return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
+       }
+
+#ifndef CONFIG_YAFFS_9BYTE_TAGS
+       /* Read deleted status (bit) then return it to it's non-deleted
+        * state before performing tags mini-ECC check. pt1.deleted is
+        * inverted.
+        */
+       deleted = !pt1.deleted;
+       pt1.deleted = 1;
+#else
+       deleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7);
+#endif
+
+       /* Check the packed tags mini-ECC and correct if necessary/possible.
+        */
+       retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1);
+       switch (retval) {
+       case 0:
+               /* no tags error, use MTD result */
+               break;
+       case 1:
+               /* recovered tags-ECC error */
+               dev->tagsEccFixed++;
+               if (eccres == YAFFS_ECC_RESULT_NO_ERROR)
+                       eccres = YAFFS_ECC_RESULT_FIXED;
+               break;
+       default:
+               /* unrecovered tags-ECC error */
+               dev->tagsEccUnfixed++;
+               return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL);
+       }
+
+       /* Unpack the tags to extended form and set ECC result.
+        * [set shouldBeFF just to keep yaffs_UnpackTags1 happy]
+        */
+       pt1.shouldBeFF = 0xFFFFFFFF;
+       yaffs_UnpackTags1(etags, &pt1);
+       etags->eccResult = eccres;
+
+       /* Set deleted state */
+       etags->chunkDeleted = deleted;
+       return YAFFS_OK;
+}
+
+/* Mark a block bad.
+ *
+ * This is a persistant state.
+ * Use of this function should be rare.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
+       int retval;
+
+       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
+
+       retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
+       return (retval) ? YAFFS_FAIL : YAFFS_OK;
+}
+
+/* Check any MTD prerequists.
+ *
+ * Returns YAFFS_OK or YAFFS_FAIL.
+ */
+static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
+{
+       /* 2.6.18 has mtd->ecclayout->oobavail */
+       /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
+       int oobavail = mtd->ecclayout->oobavail;
+
+       if (oobavail < YTAG1_SIZE) {
+               yaffs_trace(YAFFS_TRACE_ERROR,
+                       "mtd device has only %d bytes for tags, need %d\n",
+                       oobavail, YTAG1_SIZE);
+               return YAFFS_FAIL;
+       }
+       return YAFFS_OK;
+}
+
+/* Query for the current state of a specific block.
+ *
+ * Examine the tags of the first chunk of the block and return the state:
+ *  - YAFFS_BLOCK_STATE_DEAD, the block is marked bad
+ *  - YAFFS_BLOCK_STATE_NEEDS_SCANNING, the block is in use
+ *  - YAFFS_BLOCK_STATE_EMPTY, the block is clean
+ *
+ * Always returns YAFFS_OK.
+ */
+int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+       yaffs_BlockState * pState, int *pSequenceNumber)
+{
+       struct mtd_info * mtd = dev->genericDevice;
+       int chunkNo = blockNo * dev->nChunksPerBlock;
+       yaffs_ExtendedTags etags;
+       int state = YAFFS_BLOCK_STATE_DEAD;
+       int seqnum = 0;
+       int retval;
+
+       /* We don't yet have a good place to test for MTD config prerequists.
+        * Do it here as we are called during the initial scan.
+        */
+       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
+               return YAFFS_FAIL;
+       }
+
+       retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
+       if (etags.blockBad) {
+               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
+                       "block %d is marked bad", blockNo);
+               state = YAFFS_BLOCK_STATE_DEAD;
+       }
+       else if (etags.chunkUsed) {
+               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+               seqnum = etags.sequenceNumber;
+       }
+       else {
+               state = YAFFS_BLOCK_STATE_EMPTY;
+       }
+
+       *pState = state;
+       *pSequenceNumber = seqnum;
+
+       /* query always succeeds */
+       return YAFFS_OK;
+}
+
+#endif /*KERNEL_VERSION*/
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif1.h
new file mode 100644 (file)
index 0000000..c4f6197
--- /dev/null
@@ -0,0 +1,28 @@
+/*
+ * YAFFS: Yet another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_MTDIF1_H__
+#define __YAFFS_MTDIF1_H__
+
+int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
+       const __u8 * data, const yaffs_ExtendedTags * tags);
+
+int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
+       __u8 * data, yaffs_ExtendedTags * tags);
+
+int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
+
+int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+       yaffs_BlockState * state, int *sequenceNumber);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.c
new file mode 100644 (file)
index 0000000..cdad073
--- /dev/null
@@ -0,0 +1,232 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+/* mtd interface for YAFFS2 */
+
+const char *yaffs_mtdif2_c_version =
+    "$Id: yaffs_mtdif2.c,v 1.17 2007-02-14 01:09:06 wookey Exp $";
+
+#include "yportenv.h"
+
+
+#include "yaffs_mtdif2.h"
+
+#include "linux/mtd/mtd.h"
+#include "linux/types.h"
+#include "linux/time.h"
+
+#include "yaffs_packedtags2.h"
+
+int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
+                                     const __u8 * data,
+                                     const yaffs_ExtendedTags * tags)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       struct mtd_oob_ops ops;
+#else
+       size_t dummy;
+#endif
+       int retval = 0;
+
+       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
+
+       yaffs_PackedTags2 pt;
+
+       T(YAFFS_TRACE_MTD,
+         (TSTR
+          ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
+           TENDSTR), chunkInNAND, data, tags));
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       if (tags)
+               yaffs_PackTags2(&pt, tags);
+       else
+               BUG(); /* both tags and data should always be present */
+
+       if (data) {
+               ops.mode = MTD_OOB_AUTO;
+               ops.ooblen = sizeof(pt);
+               ops.len = dev->nDataBytesPerChunk;
+               ops.ooboffs = 0;
+               ops.datbuf = (__u8 *)data;
+               ops.oobbuf = (void *)&pt;
+               retval = mtd->write_oob(mtd, addr, &ops);
+       } else
+               BUG(); /* both tags and data should always be present */
+#else
+       if (tags) {
+               yaffs_PackTags2(&pt, tags);
+       }
+
+       if (data && tags) {
+               if (dev->useNANDECC)
+                       retval =
+                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                          &dummy, data, (__u8 *) & pt, NULL);
+               else
+                       retval =
+                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                          &dummy, data, (__u8 *) & pt, NULL);
+       } else {
+               if (data)
+                       retval =
+                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
+                                      data);
+               if (tags)
+                       retval =
+                           mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
+                                          (__u8 *) & pt);
+
+       }
+#endif
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
+int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
+                                      __u8 * data, yaffs_ExtendedTags * tags)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       struct mtd_oob_ops ops;
+#endif
+       size_t dummy;
+       int retval = 0;
+
+       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
+
+       yaffs_PackedTags2 pt;
+
+       T(YAFFS_TRACE_MTD,
+         (TSTR
+          ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
+           TENDSTR), chunkInNAND, data, tags));
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
+       if (data && !tags)
+               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
+                               &dummy, data);
+       else if (tags) {
+               ops.mode = MTD_OOB_AUTO;
+               ops.ooblen = sizeof(pt);
+               ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt);
+               ops.ooboffs = 0;
+               ops.datbuf = data;
+               ops.oobbuf = dev->spareBuffer;
+               retval = mtd->read_oob(mtd, addr, &ops);
+       }
+#else
+       if (data && tags) {
+               if (dev->useNANDECC) {
+                       retval =
+                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                         &dummy, data, dev->spareBuffer,
+                                         NULL);
+               } else {
+                       retval =
+                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
+                                         &dummy, data, dev->spareBuffer,
+                                         NULL);
+               }
+       } else {
+               if (data)
+                       retval =
+                           mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
+                                     data);
+               if (tags)
+                       retval =
+                           mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
+                                         dev->spareBuffer);
+       }
+#endif
+
+       memcpy(&pt, dev->spareBuffer, sizeof(pt));
+
+       if (tags)
+               yaffs_UnpackTags2(tags, &pt);
+
+       if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
+               tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
+int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+       int retval;
+       T(YAFFS_TRACE_MTD,
+         (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo));
+
+       retval =
+           mtd->block_markbad(mtd,
+                              blockNo * dev->nChunksPerBlock *
+                              dev->nDataBytesPerChunk);
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+
+}
+
+int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+                           yaffs_BlockState * state, int *sequenceNumber)
+{
+       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
+       int retval;
+
+       T(YAFFS_TRACE_MTD,
+         (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo));
+       retval =
+           mtd->block_isbad(mtd,
+                            blockNo * dev->nChunksPerBlock *
+                            dev->nDataBytesPerChunk);
+
+       if (retval) {
+               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
+
+               *state = YAFFS_BLOCK_STATE_DEAD;
+               *sequenceNumber = 0;
+       } else {
+               yaffs_ExtendedTags t;
+               nandmtd2_ReadChunkWithTagsFromNAND(dev,
+                                                  blockNo *
+                                                  dev->nChunksPerBlock, NULL,
+                                                  &t);
+
+               if (t.chunkUsed) {
+                       *sequenceNumber = t.sequenceNumber;
+                       *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+               } else {
+                       *sequenceNumber = 0;
+                       *state = YAFFS_BLOCK_STATE_EMPTY;
+               }
+       }
+       T(YAFFS_TRACE_MTD,
+         (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber,
+          *state));
+
+       if (retval == 0)
+               return YAFFS_OK;
+       else
+               return YAFFS_FAIL;
+}
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_mtdif2.h
new file mode 100644 (file)
index 0000000..b67ba52
--- /dev/null
@@ -0,0 +1,29 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_MTDIF2_H__
+#define __YAFFS_MTDIF2_H__
+
+#include "yaffs_guts.h"
+int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
+                                     const __u8 * data,
+                                     const yaffs_ExtendedTags * tags);
+int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
+                                      __u8 * data, yaffs_ExtendedTags * tags);
+int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
+int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+                           yaffs_BlockState * state, int *sequenceNumber);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.c
new file mode 100644 (file)
index 0000000..4e25033
--- /dev/null
@@ -0,0 +1,134 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+const char *yaffs_nand_c_version =
+    "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
+
+#include "yaffs_nand.h"
+#include "yaffs_tagscompat.h"
+#include "yaffs_tagsvalidity.h"
+
+
+int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
+                                          __u8 * buffer,
+                                          yaffs_ExtendedTags * tags)
+{
+       int result;
+       yaffs_ExtendedTags localTags;
+
+       int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
+
+       /* If there are no tags provided, use local tags to get prioritised gc working */
+       if(!tags)
+               tags = &localTags;
+
+       if (dev->readChunkWithTagsFromNAND)
+               result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer,
+                                                     tags);
+       else
+               result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
+                                                                       realignedChunkInNAND,
+                                                                       buffer,
+                                                                       tags);
+       if(tags &&
+          tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
+
+               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
+                yaffs_HandleChunkError(dev,bi);
+       }
+
+       return result;
+}
+
+int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
+                                                  int chunkInNAND,
+                                                  const __u8 * buffer,
+                                                  yaffs_ExtendedTags * tags)
+{
+       chunkInNAND -= dev->chunkOffset;
+
+
+       if (tags) {
+               tags->sequenceNumber = dev->sequenceNumber;
+               tags->chunkUsed = 1;
+               if (!yaffs_ValidateTags(tags)) {
+                       T(YAFFS_TRACE_ERROR,
+                         (TSTR("Writing uninitialised tags" TENDSTR)));
+                       YBUG();
+               }
+               T(YAFFS_TRACE_WRITE,
+                 (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND,
+                  tags->objectId, tags->chunkId));
+       } else {
+               T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR)));
+               YBUG();
+       }
+
+       if (dev->writeChunkWithTagsToNAND)
+               return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer,
+                                                    tags);
+       else
+               return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev,
+                                                                      chunkInNAND,
+                                                                      buffer,
+                                                                      tags);
+}
+
+int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo)
+{
+       blockNo -= dev->blockOffset;
+
+;
+       if (dev->markNANDBlockBad)
+               return dev->markNANDBlockBad(dev, blockNo);
+       else
+               return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo);
+}
+
+int yaffs_QueryInitialBlockState(yaffs_Device * dev,
+                                                int blockNo,
+                                                yaffs_BlockState * state,
+                                                unsigned *sequenceNumber)
+{
+       blockNo -= dev->blockOffset;
+
+       if (dev->queryNANDBlock)
+               return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber);
+       else
+               return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo,
+                                                            state,
+                                                            sequenceNumber);
+}
+
+
+int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
+                                 int blockInNAND)
+{
+       int result;
+
+       blockInNAND -= dev->blockOffset;
+
+
+       dev->nBlockErasures++;
+       result = dev->eraseBlockInNAND(dev, blockInNAND);
+
+       return result;
+}
+
+int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
+{
+       return dev->initialiseNAND(dev);
+}
+
+
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nand.h
new file mode 100644 (file)
index 0000000..5fa334b
--- /dev/null
@@ -0,0 +1,44 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_NAND_H__
+#define __YAFFS_NAND_H__
+#include "yaffs_guts.h"
+
+
+
+int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
+                                          __u8 * buffer,
+                                          yaffs_ExtendedTags * tags);
+
+int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
+                                                  int chunkInNAND,
+                                                  const __u8 * buffer,
+                                                  yaffs_ExtendedTags * tags);
+
+int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo);
+
+int yaffs_QueryInitialBlockState(yaffs_Device * dev,
+                                                int blockNo,
+                                                yaffs_BlockState * state,
+                                                unsigned *sequenceNumber);
+
+int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
+                                 int blockInNAND);
+
+int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev);
+
+#endif
+
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nandemul2k.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_nandemul2k.h
new file mode 100644 (file)
index 0000000..cd2e96f
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/* Interface to emulated NAND functions (2k page size) */
+
+#ifndef __YAFFS_NANDEMUL2K_H__
+#define __YAFFS_NANDEMUL2K_H__
+
+#include "yaffs_guts.h"
+
+int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
+                                       int chunkInNAND, const __u8 * data,
+                                       yaffs_ExtendedTags * tags);
+int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,
+                                        int chunkInNAND, __u8 * data,
+                                        yaffs_ExtendedTags * tags);
+int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
+int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
+                             yaffs_BlockState * state, int *sequenceNumber);
+int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
+                               int blockInNAND);
+int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev);
+int nandemul2k_GetBytesPerChunk(void);
+int nandemul2k_GetChunksPerBlock(void);
+int nandemul2k_GetNumberOfBlocks(void);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.c
new file mode 100644 (file)
index 0000000..f480bf1
--- /dev/null
@@ -0,0 +1,52 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "yaffs_packedtags1.h"
+#include "yportenv.h"
+
+void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t)
+{
+       pt->chunkId = t->chunkId;
+       pt->serialNumber = t->serialNumber;
+       pt->byteCount = t->byteCount;
+       pt->objectId = t->objectId;
+       pt->ecc = 0;
+       pt->deleted = (t->chunkDeleted) ? 0 : 1;
+       pt->unusedStuff = 0;
+       pt->shouldBeFF = 0xFFFFFFFF;
+
+}
+
+void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt)
+{
+       static const __u8 allFF[] =
+           { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff };
+
+       if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) {
+               t->blockBad = 0;
+               if (pt->shouldBeFF != 0xFFFFFFFF) {
+                       t->blockBad = 1;
+               }
+               t->chunkUsed = 1;
+               t->objectId = pt->objectId;
+               t->chunkId = pt->chunkId;
+               t->byteCount = pt->byteCount;
+               t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+               t->chunkDeleted = (pt->deleted) ? 0 : 1;
+               t->serialNumber = pt->serialNumber;
+       } else {
+               memset(t, 0, sizeof(yaffs_ExtendedTags));
+
+       }
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags1.h
new file mode 100644 (file)
index 0000000..776c5c2
--- /dev/null
@@ -0,0 +1,37 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/* This is used to pack YAFFS1 tags, not YAFFS2 tags. */
+
+#ifndef __YAFFS_PACKEDTAGS1_H__
+#define __YAFFS_PACKEDTAGS1_H__
+
+#include "yaffs_guts.h"
+
+typedef struct {
+       unsigned chunkId:20;
+       unsigned serialNumber:2;
+       unsigned byteCount:10;
+       unsigned objectId:18;
+       unsigned ecc:12;
+       unsigned deleted:1;
+       unsigned unusedStuff:1;
+       unsigned shouldBeFF;
+
+} yaffs_PackedTags1;
+
+void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t);
+void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt);
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.c
new file mode 100644 (file)
index 0000000..e420f95
--- /dev/null
@@ -0,0 +1,182 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "yaffs_packedtags2.h"
+#include "yportenv.h"
+#include "yaffs_tagsvalidity.h"
+
+/* This code packs a set of extended tags into a binary structure for
+ * NAND storage
+ */
+
+/* Some of the information is "extra" struff which can be packed in to
+ * speed scanning
+ * This is defined by having the EXTRA_HEADER_INFO_FLAG set.
+ */
+
+/* Extra flags applied to chunkId */
+
+#define EXTRA_HEADER_INFO_FLAG 0x80000000
+#define EXTRA_SHRINK_FLAG      0x40000000
+#define EXTRA_SHADOWS_FLAG     0x20000000
+#define EXTRA_SPARE_FLAGS      0x10000000
+
+#define ALL_EXTRA_FLAGS                0xF0000000
+
+/* Also, the top 4 bits of the object Id are set to the object type. */
+#define EXTRA_OBJECT_TYPE_SHIFT (28)
+#define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
+
+static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
+{
+       T(YAFFS_TRACE_MTD,
+         (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
+          pt->t.objectId, pt->t.chunkId, pt->t.byteCount,
+          pt->t.sequenceNumber));
+}
+
+static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
+{
+       T(YAFFS_TRACE_MTD,
+         (TSTR
+          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte "
+           "%d del %d ser %d seq %d"
+           TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId,
+          t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber,
+          t->sequenceNumber));
+
+}
+
+void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
+{
+       pt->t.chunkId = t->chunkId;
+       pt->t.sequenceNumber = t->sequenceNumber;
+       pt->t.byteCount = t->byteCount;
+       pt->t.objectId = t->objectId;
+
+       if (t->chunkId == 0 && t->extraHeaderInfoAvailable) {
+               /* Store the extra header info instead */
+               /* We save the parent object in the chunkId */
+               pt->t.chunkId = EXTRA_HEADER_INFO_FLAG
+                       | t->extraParentObjectId;
+               if (t->extraIsShrinkHeader) {
+                       pt->t.chunkId |= EXTRA_SHRINK_FLAG;
+               }
+               if (t->extraShadows) {
+                       pt->t.chunkId |= EXTRA_SHADOWS_FLAG;
+               }
+
+               pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK;
+               pt->t.objectId |=
+                   (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
+
+               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
+                       pt->t.byteCount = t->extraEquivalentObjectId;
+               } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
+                       pt->t.byteCount = t->extraFileLength;
+               } else {
+                       pt->t.byteCount = 0;
+               }
+       }
+
+       yaffs_DumpPackedTags2(pt);
+       yaffs_DumpTags2(t);
+
+#ifndef YAFFS_IGNORE_TAGS_ECC
+       {
+               yaffs_ECCCalculateOther((unsigned char *)&pt->t,
+                                       sizeof(yaffs_PackedTags2TagsPart),
+                                       &pt->ecc);
+       }
+#endif
+}
+
+void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
+{
+
+       memset(t, 0, sizeof(yaffs_ExtendedTags));
+
+       yaffs_InitialiseTags(t);
+
+       if (pt->t.sequenceNumber != 0xFFFFFFFF) {
+               /* Page is in use */
+#ifdef YAFFS_IGNORE_TAGS_ECC
+               {
+                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+               }
+#else
+               {
+                       yaffs_ECCOther ecc;
+                       int result;
+                       yaffs_ECCCalculateOther((unsigned char *)&pt->t,
+                                               sizeof
+                                               (yaffs_PackedTags2TagsPart),
+                                               &ecc);
+                       result =
+                           yaffs_ECCCorrectOther((unsigned char *)&pt->t,
+                                                 sizeof
+                                                 (yaffs_PackedTags2TagsPart),
+                                                 &pt->ecc, &ecc);
+                       switch(result){
+                               case 0:
+                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+                                       break;
+                               case 1:
+                                       t->eccResult = YAFFS_ECC_RESULT_FIXED;
+                                       break;
+                               case -1:
+                                       t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
+                                       break;
+                               default:
+                                       t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
+                       }
+               }
+#endif
+               t->blockBad = 0;
+               t->chunkUsed = 1;
+               t->objectId = pt->t.objectId;
+               t->chunkId = pt->t.chunkId;
+               t->byteCount = pt->t.byteCount;
+               t->chunkDeleted = 0;
+               t->serialNumber = 0;
+               t->sequenceNumber = pt->t.sequenceNumber;
+
+               /* Do extra header info stuff */
+
+               if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) {
+                       t->chunkId = 0;
+                       t->byteCount = 0;
+
+                       t->extraHeaderInfoAvailable = 1;
+                       t->extraParentObjectId =
+                           pt->t.chunkId & (~(ALL_EXTRA_FLAGS));
+                       t->extraIsShrinkHeader =
+                           (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
+                       t->extraShadows =
+                           (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
+                       t->extraObjectType =
+                           pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT;
+                       t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
+
+                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
+                               t->extraEquivalentObjectId = pt->t.byteCount;
+                       } else {
+                               t->extraFileLength = pt->t.byteCount;
+                       }
+               }
+       }
+
+       yaffs_DumpPackedTags2(pt);
+       yaffs_DumpTags2(t);
+
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_packedtags2.h
new file mode 100644 (file)
index 0000000..c2242ff
--- /dev/null
@@ -0,0 +1,38 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+/* This is used to pack YAFFS2 tags, not YAFFS1tags. */
+
+#ifndef __YAFFS_PACKEDTAGS2_H__
+#define __YAFFS_PACKEDTAGS2_H__
+
+#include "yaffs_guts.h"
+#include "yaffs_ecc.h"
+
+typedef struct {
+       unsigned sequenceNumber;
+       unsigned objectId;
+       unsigned chunkId;
+       unsigned byteCount;
+} yaffs_PackedTags2TagsPart;
+
+typedef struct {
+       yaffs_PackedTags2TagsPart t;
+       yaffs_ECCOther ecc;
+} yaffs_PackedTags2;
+
+void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t);
+void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt);
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.c
new file mode 100644 (file)
index 0000000..474be9c
--- /dev/null
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 1992, 1993
+ *     The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "yportenv.h"
+//#include <linux/string.h>
+
+/*
+ * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
+ */
+#define swapcode(TYPE, parmi, parmj, n) {              \
+       long i = (n) / sizeof (TYPE);                   \
+       register TYPE *pi = (TYPE *) (parmi);           \
+       register TYPE *pj = (TYPE *) (parmj);           \
+       do {                                            \
+               register TYPE   t = *pi;                \
+               *pi++ = *pj;                            \
+               *pj++ = t;                              \
+        } while (--i > 0);                             \
+}
+
+#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
+       es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
+
+static __inline void
+swapfunc(char *a, char *b, int n, int swaptype)
+{
+       if (swaptype <= 1)
+               swapcode(long, a, b, n)
+       else
+               swapcode(char, a, b, n)
+}
+
+#define swap(a, b)                                     \
+       if (swaptype == 0) {                            \
+               long t = *(long *)(a);                  \
+               *(long *)(a) = *(long *)(b);            \
+               *(long *)(b) = t;                       \
+       } else                                          \
+               swapfunc(a, b, es, swaptype)
+
+#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
+
+static __inline char *
+med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
+{
+       return cmp(a, b) < 0 ?
+              (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
+              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
+}
+
+#ifndef min
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+void
+yaffs_qsort(void *aa, size_t n, size_t es,
+       int (*cmp)(const void *, const void *))
+{
+       char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+       int d, r, swaptype, swap_cnt;
+       register char *a = aa;
+
+loop:  SWAPINIT(a, es);
+       swap_cnt = 0;
+       if (n < 7) {
+               for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
+                            pl -= es)
+                               swap(pl, pl - es);
+               return;
+       }
+       pm = (char *)a + (n / 2) * es;
+       if (n > 7) {
+               pl = (char *)a;
+               pn = (char *)a + (n - 1) * es;
+               if (n > 40) {
+                       d = (n / 8) * es;
+                       pl = med3(pl, pl + d, pl + 2 * d, cmp);
+                       pm = med3(pm - d, pm, pm + d, cmp);
+                       pn = med3(pn - 2 * d, pn - d, pn, cmp);
+               }
+               pm = med3(pl, pm, pn, cmp);
+       }
+       swap(a, pm);
+       pa = pb = (char *)a + es;
+
+       pc = pd = (char *)a + (n - 1) * es;
+       for (;;) {
+               while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+                       if (r == 0) {
+                               swap_cnt = 1;
+                               swap(pa, pb);
+                               pa += es;
+                       }
+                       pb += es;
+               }
+               while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+                       if (r == 0) {
+                               swap_cnt = 1;
+                               swap(pc, pd);
+                               pd -= es;
+                       }
+                       pc -= es;
+               }
+               if (pb > pc)
+                       break;
+               swap(pb, pc);
+               swap_cnt = 1;
+               pb += es;
+               pc -= es;
+       }
+       if (swap_cnt == 0) {  /* Switch to insertion sort */
+               for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
+                            pl -= es)
+                               swap(pl, pl - es);
+               return;
+       }
+
+       pn = (char *)a + n * es;
+       r = min(pa - (char *)a, pb - pa);
+       vecswap(a, pb - r, r);
+       r = min((long)(pd - pc), (long)(pn - pd - es));
+       vecswap(pb, pn - r, r);
+       if ((r = pb - pa) > es)
+               yaffs_qsort(a, r / es, es, cmp);
+       if ((r = pd - pc) > es) {
+               /* Iterate rather than recurse to save stack space */
+               a = pn - r;
+               n = r / es;
+               goto loop;
+       }
+/*             yaffs_qsort(pn - r, r / es, es, cmp);*/
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_qsort.h
new file mode 100644 (file)
index 0000000..610b7ec
--- /dev/null
@@ -0,0 +1,23 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+
+#ifndef __YAFFS_QSORT_H__
+#define __YAFFS_QSORT_H__
+
+extern void yaffs_qsort (void *const base, size_t total_elems, size_t size,
+                   int (*cmp)(const void *, const void *));
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.c
new file mode 100644 (file)
index 0000000..7622b1a
--- /dev/null
@@ -0,0 +1,530 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "yaffs_guts.h"
+#include "yaffs_tagscompat.h"
+#include "yaffs_ecc.h"
+
+static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
+#ifdef NOTYET
+static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
+static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
+                                    const __u8 * data,
+                                    const yaffs_Spare * spare);
+static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
+                                   const yaffs_Spare * spare);
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
+#endif
+
+static const char yaffs_countBitsTable[256] = {
+       0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+       4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+};
+
+int yaffs_CountBits(__u8 x)
+{
+       int retVal;
+       retVal = yaffs_countBitsTable[x];
+       return retVal;
+}
+
+/********** Tags ECC calculations  *********/
+
+void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
+{
+       yaffs_ECCCalculate(data, spare->ecc1);
+       yaffs_ECCCalculate(&data[256], spare->ecc2);
+}
+
+void yaffs_CalcTagsECC(yaffs_Tags * tags)
+{
+       /* Calculate an ecc */
+
+       unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+       unsigned i, j;
+       unsigned ecc = 0;
+       unsigned bit = 0;
+
+       tags->ecc = 0;
+
+       for (i = 0; i < 8; i++) {
+               for (j = 1; j & 0xff; j <<= 1) {
+                       bit++;
+                       if (b[i] & j) {
+                               ecc ^= bit;
+                       }
+               }
+       }
+
+       tags->ecc = ecc;
+
+}
+
+int yaffs_CheckECCOnTags(yaffs_Tags * tags)
+{
+       unsigned ecc = tags->ecc;
+
+       yaffs_CalcTagsECC(tags);
+
+       ecc ^= tags->ecc;
+
+       if (ecc && ecc <= 64) {
+               /* TODO: Handle the failure better. Retire? */
+               unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
+
+               ecc--;
+
+               b[ecc / 8] ^= (1 << (ecc & 7));
+
+               /* Now recvalc the ecc */
+               yaffs_CalcTagsECC(tags);
+
+               return 1;       /* recovered error */
+       } else if (ecc) {
+               /* Wierd ecc failure value */
+               /* TODO Need to do somethiong here */
+               return -1;      /* unrecovered error */
+       }
+
+       return 0;
+}
+
+/********** Tags **********/
+
+static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
+                                   yaffs_Tags * tagsPtr)
+{
+       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+
+       yaffs_CalcTagsECC(tagsPtr);
+
+       sparePtr->tagByte0 = tu->asBytes[0];
+       sparePtr->tagByte1 = tu->asBytes[1];
+       sparePtr->tagByte2 = tu->asBytes[2];
+       sparePtr->tagByte3 = tu->asBytes[3];
+       sparePtr->tagByte4 = tu->asBytes[4];
+       sparePtr->tagByte5 = tu->asBytes[5];
+       sparePtr->tagByte6 = tu->asBytes[6];
+       sparePtr->tagByte7 = tu->asBytes[7];
+}
+
+static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
+                                  yaffs_Tags * tagsPtr)
+{
+       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
+       int result;
+
+       tu->asBytes[0] = sparePtr->tagByte0;
+       tu->asBytes[1] = sparePtr->tagByte1;
+       tu->asBytes[2] = sparePtr->tagByte2;
+       tu->asBytes[3] = sparePtr->tagByte3;
+       tu->asBytes[4] = sparePtr->tagByte4;
+       tu->asBytes[5] = sparePtr->tagByte5;
+       tu->asBytes[6] = sparePtr->tagByte6;
+       tu->asBytes[7] = sparePtr->tagByte7;
+
+       result = yaffs_CheckECCOnTags(tagsPtr);
+       if (result > 0) {
+               dev->tagsEccFixed++;
+       } else if (result < 0) {
+               dev->tagsEccUnfixed++;
+       }
+}
+
+static void yaffs_SpareInitialise(yaffs_Spare * spare)
+{
+       memset(spare, 0xFF, sizeof(yaffs_Spare));
+}
+
+static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
+                                 int chunkInNAND, const __u8 * data,
+                                 yaffs_Spare * spare)
+{
+       if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
+               T(YAFFS_TRACE_ERROR,
+                 (TSTR("**>> yaffs chunk %d is not valid" TENDSTR),
+                  chunkInNAND));
+               return YAFFS_FAIL;
+       }
+
+       dev->nPageWrites++;
+       return dev->writeChunkToNAND(dev, chunkInNAND, data, spare);
+}
+
+static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
+                                  int chunkInNAND,
+                                  __u8 * data,
+                                  yaffs_Spare * spare,
+                                  yaffs_ECCResult * eccResult,
+                                  int doErrorCorrection)
+{
+       int retVal;
+       yaffs_Spare localSpare;
+
+       dev->nPageReads++;
+
+       if (!spare && data) {
+               /* If we don't have a real spare, then we use a local one. */
+               /* Need this for the calculation of the ecc */
+               spare = &localSpare;
+       }
+
+       if (!dev->useNANDECC) {
+               retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare);
+               if (data && doErrorCorrection) {
+                       /* Do ECC correction */
+                       /* Todo handle any errors */
+                       int eccResult1, eccResult2;
+                       __u8 calcEcc[3];
+
+                       yaffs_ECCCalculate(data, calcEcc);
+                       eccResult1 =
+                           yaffs_ECCCorrect(data, spare->ecc1, calcEcc);
+                       yaffs_ECCCalculate(&data[256], calcEcc);
+                       eccResult2 =
+                           yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc);
+
+                       if (eccResult1 > 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>yaffs ecc error fix performed on chunk %d:0"
+                                   TENDSTR), chunkInNAND));
+                               dev->eccFixed++;
+                       } else if (eccResult1 < 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>yaffs ecc error unfixed on chunk %d:0"
+                                   TENDSTR), chunkInNAND));
+                               dev->eccUnfixed++;
+                       }
+
+                       if (eccResult2 > 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>yaffs ecc error fix performed on chunk %d:1"
+                                   TENDSTR), chunkInNAND));
+                               dev->eccFixed++;
+                       } else if (eccResult2 < 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>yaffs ecc error unfixed on chunk %d:1"
+                                   TENDSTR), chunkInNAND));
+                               dev->eccUnfixed++;
+                       }
+
+                       if (eccResult1 || eccResult2) {
+                               /* We had a data problem on this page */
+                               yaffs_HandleReadDataError(dev, chunkInNAND);
+                       }
+
+                       if (eccResult1 < 0 || eccResult2 < 0)
+                               *eccResult = YAFFS_ECC_RESULT_UNFIXED;
+                       else if (eccResult1 > 0 || eccResult2 > 0)
+                               *eccResult = YAFFS_ECC_RESULT_FIXED;
+                       else
+                               *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+               }
+       } else {
+               /* Must allocate enough memory for spare+2*sizeof(int) */
+               /* for ecc results from device. */
+               struct yaffs_NANDSpare nspare;
+               retVal =
+                   dev->readChunkFromNAND(dev, chunkInNAND, data,
+                                          (yaffs_Spare *) & nspare);
+               memcpy(spare, &nspare, sizeof(yaffs_Spare));
+               if (data && doErrorCorrection) {
+                       if (nspare.eccres1 > 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>mtd ecc error fix performed on chunk %d:0"
+                                   TENDSTR), chunkInNAND));
+                       } else if (nspare.eccres1 < 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>mtd ecc error unfixed on chunk %d:0"
+                                   TENDSTR), chunkInNAND));
+                       }
+
+                       if (nspare.eccres2 > 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>mtd ecc error fix performed on chunk %d:1"
+                                   TENDSTR), chunkInNAND));
+                       } else if (nspare.eccres2 < 0) {
+                               T(YAFFS_TRACE_ERROR,
+                                 (TSTR
+                                  ("**>>mtd ecc error unfixed on chunk %d:1"
+                                   TENDSTR), chunkInNAND));
+                       }
+
+                       if (nspare.eccres1 || nspare.eccres2) {
+                               /* We had a data problem on this page */
+                               yaffs_HandleReadDataError(dev, chunkInNAND);
+                       }
+
+                       if (nspare.eccres1 < 0 || nspare.eccres2 < 0)
+                               *eccResult = YAFFS_ECC_RESULT_UNFIXED;
+                       else if (nspare.eccres1 > 0 || nspare.eccres2 > 0)
+                               *eccResult = YAFFS_ECC_RESULT_FIXED;
+                       else
+                               *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
+
+               }
+       }
+       return retVal;
+}
+
+#ifdef NOTYET
+static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
+                                 int chunkInNAND)
+{
+
+       static int init = 0;
+       static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
+       static __u8 data[YAFFS_BYTES_PER_CHUNK];
+       /* Might as well always allocate the larger size for */
+       /* dev->useNANDECC == true; */
+       static __u8 spare[sizeof(struct yaffs_NANDSpare)];
+
+       dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare);
+
+       if (!init) {
+               memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK);
+               init = 1;
+       }
+
+       if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK))
+               return YAFFS_FAIL;
+       if (memcmp(cmpbuf, spare, 16))
+               return YAFFS_FAIL;
+
+       return YAFFS_OK;
+
+}
+#endif
+
+/*
+ * Functions for robustisizing
+ */
+
+static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
+{
+       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
+
+       /* Mark the block for retirement */
+       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
+       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
+         (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
+
+       /* TODO:
+        * Just do a garbage collection on the affected block
+        * then retire the block
+        * NB recursion
+        */
+}
+
+#ifdef NOTYET
+static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
+{
+}
+
+static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
+                                    const __u8 * data,
+                                    const yaffs_Spare * spare)
+{
+}
+
+static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
+                                   const yaffs_Spare * spare)
+{
+}
+
+static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
+{
+       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
+
+       /* Mark the block for retirement */
+       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
+       /* Delete the chunk */
+       yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
+}
+
+static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
+                              const yaffs_Spare * s0, const yaffs_Spare * s1)
+{
+
+       if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
+           s0->tagByte0 != s1->tagByte0 ||
+           s0->tagByte1 != s1->tagByte1 ||
+           s0->tagByte2 != s1->tagByte2 ||
+           s0->tagByte3 != s1->tagByte3 ||
+           s0->tagByte4 != s1->tagByte4 ||
+           s0->tagByte5 != s1->tagByte5 ||
+           s0->tagByte6 != s1->tagByte6 ||
+           s0->tagByte7 != s1->tagByte7 ||
+           s0->ecc1[0] != s1->ecc1[0] ||
+           s0->ecc1[1] != s1->ecc1[1] ||
+           s0->ecc1[2] != s1->ecc1[2] ||
+           s0->ecc2[0] != s1->ecc2[0] ||
+           s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) {
+               return 0;
+       }
+
+       return 1;
+}
+#endif                         /* NOTYET */
+
+int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
+                                                   int chunkInNAND,
+                                                   const __u8 * data,
+                                                   const yaffs_ExtendedTags *
+                                                   eTags)
+{
+       yaffs_Spare spare;
+       yaffs_Tags tags;
+
+       yaffs_SpareInitialise(&spare);
+
+       if (eTags->chunkDeleted) {
+               spare.pageStatus = 0;
+       } else {
+               tags.objectId = eTags->objectId;
+               tags.chunkId = eTags->chunkId;
+               tags.byteCount = eTags->byteCount;
+               tags.serialNumber = eTags->serialNumber;
+
+               if (!dev->useNANDECC && data) {
+                       yaffs_CalcECC(data, &spare);
+               }
+               yaffs_LoadTagsIntoSpare(&spare, &tags);
+
+       }
+
+       return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
+}
+
+int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
+                                                    int chunkInNAND,
+                                                    __u8 * data,
+                                                    yaffs_ExtendedTags * eTags)
+{
+
+       yaffs_Spare spare;
+       yaffs_Tags tags;
+       yaffs_ECCResult eccResult;
+
+       static yaffs_Spare spareFF;
+       static int init;
+
+       if (!init) {
+               memset(&spareFF, 0xFF, sizeof(spareFF));
+               init = 1;
+       }
+
+       if (yaffs_ReadChunkFromNAND
+           (dev, chunkInNAND, data, &spare, &eccResult, 1)) {
+               /* eTags may be NULL */
+               if (eTags) {
+
+                       int deleted =
+                           (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0;
+
+                       eTags->chunkDeleted = deleted;
+                       eTags->eccResult = eccResult;
+                       eTags->blockBad = 0;    /* We're reading it */
+                       /* therefore it is not a bad block */
+                       eTags->chunkUsed =
+                           (memcmp(&spareFF, &spare, sizeof(spareFF)) !=
+                            0) ? 1 : 0;
+
+                       if (eTags->chunkUsed) {
+                               yaffs_GetTagsFromSpare(dev, &spare, &tags);
+
+                               eTags->objectId = tags.objectId;
+                               eTags->chunkId = tags.chunkId;
+                               eTags->byteCount = tags.byteCount;
+                               eTags->serialNumber = tags.serialNumber;
+                       }
+               }
+
+               return YAFFS_OK;
+       } else {
+               return YAFFS_FAIL;
+       }
+}
+
+int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
+                                           int blockInNAND)
+{
+
+       yaffs_Spare spare;
+
+       memset(&spare, 0xff, sizeof(yaffs_Spare));
+
+       spare.blockStatus = 'Y';
+
+       yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL,
+                              &spare);
+       yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1,
+                              NULL, &spare);
+
+       return YAFFS_OK;
+
+}
+
+int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
+                                         int blockNo, yaffs_BlockState *
+                                         state,
+                                         int *sequenceNumber)
+{
+
+       yaffs_Spare spare0, spare1;
+       static yaffs_Spare spareFF;
+       static int init;
+       yaffs_ECCResult dummy;
+
+       if (!init) {
+               memset(&spareFF, 0xFF, sizeof(spareFF));
+               init = 1;
+       }
+
+       *sequenceNumber = 0;
+
+       yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL,
+                               &spare0, &dummy, 1);
+       yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL,
+                               &spare1, &dummy, 1);
+
+       if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7)
+               *state = YAFFS_BLOCK_STATE_DEAD;
+       else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0)
+               *state = YAFFS_BLOCK_STATE_EMPTY;
+       else
+               *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
+
+       return YAFFS_OK;
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagscompat.h
new file mode 100644 (file)
index 0000000..a61e3ba
--- /dev/null
@@ -0,0 +1,40 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFS_TAGSCOMPAT_H__
+#define __YAFFS_TAGSCOMPAT_H__
+
+#include "yaffs_guts.h"
+int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
+                                                   int chunkInNAND,
+                                                   const __u8 * data,
+                                                   const yaffs_ExtendedTags *
+                                                   tags);
+int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
+                                                    int chunkInNAND,
+                                                    __u8 * data,
+                                                    yaffs_ExtendedTags *
+                                                    tags);
+int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
+                                           int blockNo);
+int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
+                                         int blockNo, yaffs_BlockState *
+                                         state, int *sequenceNumber);
+
+void yaffs_CalcTagsECC(yaffs_Tags * tags);
+int yaffs_CheckECCOnTags(yaffs_Tags * tags);
+int yaffs_CountBits(__u8 byte);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.c b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.c
new file mode 100644 (file)
index 0000000..9e0bd1c
--- /dev/null
@@ -0,0 +1,28 @@
+/*
+ * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "yaffs_tagsvalidity.h"
+
+void yaffs_InitialiseTags(yaffs_ExtendedTags * tags)
+{
+       memset(tags, 0, sizeof(yaffs_ExtendedTags));
+       tags->validMarker0 = 0xAAAAAAAA;
+       tags->validMarker1 = 0x55555555;
+}
+
+int yaffs_ValidateTags(yaffs_ExtendedTags * tags)
+{
+       return (tags->validMarker0 == 0xAAAAAAAA &&
+               tags->validMarker1 == 0x55555555);
+
+}
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffs_tagsvalidity.h
new file mode 100644 (file)
index 0000000..2fd0c24
--- /dev/null
@@ -0,0 +1,24 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+
+#ifndef __YAFFS_TAGS_VALIDITY_H__
+#define __YAFFS_TAGS_VALIDITY_H__
+
+#include "yaffs_guts.h"
+
+void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
+int yaffs_ValidateTags(yaffs_ExtendedTags * tags);
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffsinterface.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yaffsinterface.h
new file mode 100644 (file)
index 0000000..810837a
--- /dev/null
@@ -0,0 +1,21 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+#ifndef __YAFFSINTERFACE_H__
+#define __YAFFSINTERFACE_H__
+
+int yaffs_Initialise(unsigned nBlocks);
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yportenv.h b/target/linux/generic-2.6/files-2.6.24/fs/yaffs2/yportenv.h
new file mode 100644 (file)
index 0000000..15ac281
--- /dev/null
@@ -0,0 +1,187 @@
+/*
+ * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
+ *
+ * Copyright (C) 2002-2007 Aleph One Ltd.
+ *   for Toby Churchill Ltd and Brightstar Engineering
+ *
+ * Created by Charles Manning <charles@aleph1.co.uk>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1 as
+ * published by the Free Software Foundation.
+ *
+ * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
+ */
+
+
+#ifndef __YPORTENV_H__
+#define __YPORTENV_H__
+
+#if defined CONFIG_YAFFS_WINCE
+
+#include "ywinceenv.h"
+
+#elif  defined __KERNEL__
+
+#include "moduleconfig.h"
+
+/* Linux kernel */
+#include <linux/version.h>
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
+#include <linux/config.h>
+#endif
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+
+#define YCHAR char
+#define YUCHAR unsigned char
+#define _Y(x)     x
+#define yaffs_strcpy(a,b)    strcpy(a,b)
+#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
+#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
+#define yaffs_strlen(s)             strlen(s)
+#define yaffs_sprintf       sprintf
+#define yaffs_toupper(a)     toupper(a)
+
+#define Y_INLINE inline
+
+#define YAFFS_LOSTNFOUND_NAME          "lost+found"
+#define YAFFS_LOSTNFOUND_PREFIX                "obj"
+
+/* #define YPRINTF(x) printk x */
+#define YMALLOC(x) kmalloc(x,GFP_KERNEL)
+#define YFREE(x)   kfree(x)
+#define YMALLOC_ALT(x) vmalloc(x)
+#define YFREE_ALT(x)   vfree(x)
+#define YMALLOC_DMA(x) YMALLOC(x)
+
+// KR - added for use in scan so processes aren't blocked indefinitely.
+#define YYIELD() schedule()
+
+#define YAFFS_ROOT_MODE                        0666
+#define YAFFS_LOSTNFOUND_MODE          0666
+
+#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
+#define Y_CURRENT_TIME CURRENT_TIME.tv_sec
+#define Y_TIME_CONVERT(x) (x).tv_sec
+#else
+#define Y_CURRENT_TIME CURRENT_TIME
+#define Y_TIME_CONVERT(x) (x)
+#endif
+
+#define yaffs_SumCompare(x,y) ((x) == (y))
+#define yaffs_strcmp(a,b) strcmp(a,b)
+
+#define TENDSTR "\n"
+#define TSTR(x) KERN_WARNING x
+#define TOUT(p) printk p
+
+#define yaffs_trace(mask, fmt, args...) \
+       do { if ((mask) & (yaffs_traceMask|YAFFS_TRACE_ERROR)) \
+               printk(KERN_WARNING "yaffs: " fmt, ## args); \
+       } while (0)
+
+#define compile_time_assertion(assertion) \
+       ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
+
+#elif defined CONFIG_YAFFS_DIRECT
+
+/* Direct interface */
+#include "ydirectenv.h"
+
+#elif defined CONFIG_YAFFS_UTIL
+
+/* Stuff for YAFFS utilities */
+
+#include "stdlib.h"
+#include "stdio.h"
+#include "string.h"
+
+#include "devextras.h"
+
+#define YMALLOC(x) malloc(x)
+#define YFREE(x)   free(x)
+#define YMALLOC_ALT(x) malloc(x)
+#define YFREE_ALT(x) free(x)
+
+#define YCHAR char
+#define YUCHAR unsigned char
+#define _Y(x)     x
+#define yaffs_strcpy(a,b)    strcpy(a,b)
+#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
+#define yaffs_strlen(s)             strlen(s)
+#define yaffs_sprintf       sprintf
+#define yaffs_toupper(a)     toupper(a)
+
+#define Y_INLINE inline
+
+/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
+/* #define YALERT(s) YINFO(s) */
+
+#define TENDSTR "\n"
+#define TSTR(x) x
+#define TOUT(p) printf p
+
+#define YAFFS_LOSTNFOUND_NAME          "lost+found"
+#define YAFFS_LOSTNFOUND_PREFIX                "obj"
+/* #define YPRINTF(x) printf x */
+
+#define YAFFS_ROOT_MODE                                0666
+#define YAFFS_LOSTNFOUND_MODE          0666
+
+#define yaffs_SumCompare(x,y) ((x) == (y))
+#define yaffs_strcmp(a,b) strcmp(a,b)
+
+#else
+/* Should have specified a configuration type */
+#error Unknown configuration
+
+#endif
+
+/* see yaffs_fs.c */
+extern unsigned int yaffs_traceMask;
+extern unsigned int yaffs_wr_attempts;
+
+/*
+ * Tracing flags.
+ * The flags masked in YAFFS_TRACE_ALWAYS are always traced.
+ */
+
+#define YAFFS_TRACE_OS                 0x00000002
+#define YAFFS_TRACE_ALLOCATE           0x00000004
+#define YAFFS_TRACE_SCAN               0x00000008
+#define YAFFS_TRACE_BAD_BLOCKS         0x00000010
+#define YAFFS_TRACE_ERASE              0x00000020
+#define YAFFS_TRACE_GC                 0x00000040
+#define YAFFS_TRACE_WRITE              0x00000080
+#define YAFFS_TRACE_TRACING            0x00000100
+#define YAFFS_TRACE_DELETION           0x00000200
+#define YAFFS_TRACE_BUFFERS            0x00000400
+#define YAFFS_TRACE_NANDACCESS         0x00000800
+#define YAFFS_TRACE_GC_DETAIL          0x00001000
+#define YAFFS_TRACE_SCAN_DEBUG         0x00002000
+#define YAFFS_TRACE_MTD                        0x00004000
+#define YAFFS_TRACE_CHECKPOINT         0x00008000
+
+#define YAFFS_TRACE_VERIFY             0x00010000
+#define YAFFS_TRACE_VERIFY_NAND                0x00020000
+#define YAFFS_TRACE_VERIFY_FULL                0x00040000
+#define YAFFS_TRACE_VERIFY_ALL         0x000F0000
+
+
+#define YAFFS_TRACE_ERROR              0x40000000
+#define YAFFS_TRACE_BUG                        0x80000000
+#define YAFFS_TRACE_ALWAYS             0xF0000000
+
+
+#define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0)
+
+#ifndef CONFIG_YAFFS_WINCE
+#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__))
+#endif
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/gpio_buttons.h b/target/linux/generic-2.6/files-2.6.24/include/linux/gpio_buttons.h
new file mode 100644 (file)
index 0000000..f5e6297
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ *  Definitions for the GPIO buttons interface driver
+ *
+ *  Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
+ *
+ *  This file was based on: /include/linux/gpio_keys.h
+ *     The original gpio_keys.h seems not to have a license.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ */
+
+#ifndef _GPIO_BUTTONS_H_
+#define _GPIO_BUTTONS_H_
+
+struct gpio_button {
+       int     gpio;           /* GPIO line number */
+       int     active_low;
+       char    *desc;          /* button description */
+       int     type;           /* input event type (EV_KEY, EV_SW) */
+       int     code;           /* input event code (KEY_*, SW_*) */
+       int     count;
+       int     threshold;      /* count threshold */
+};
+
+struct gpio_buttons_platform_data {
+       struct gpio_button *buttons;
+       int     nbuttons;               /* number of buttons */
+       int     poll_interval;          /* polling interval */
+};
+
+#endif /* _GPIO_BUTTONS_H_ */
+
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/gpio_dev.h b/target/linux/generic-2.6/files-2.6.24/include/linux/gpio_dev.h
new file mode 100644 (file)
index 0000000..3f3c9c7
--- /dev/null
@@ -0,0 +1,11 @@
+#ifndef _GPIODEV_H__
+#define _GPIODEV_H__
+
+#define IOC_GPIODEV_MAGIC  'B'
+#define GPIO_GET        _IO(IOC_GPIODEV_MAGIC, 10)
+#define GPIO_SET        _IO(IOC_GPIODEV_MAGIC, 11)
+#define GPIO_CLEAR      _IO(IOC_GPIODEV_MAGIC, 12)
+#define GPIO_DIR_IN     _IO(IOC_GPIODEV_MAGIC, 13)
+#define GPIO_DIR_OUT    _IO(IOC_GPIODEV_MAGIC, 14)
+
+#endif
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/spi/spi_gpio.h b/target/linux/generic-2.6/files-2.6.24/include/linux/spi/spi_gpio.h
new file mode 100644 (file)
index 0000000..8e7d4b1
--- /dev/null
@@ -0,0 +1,53 @@
+/*
+ * spi_gpio interface to platform code
+ *
+ * Copyright (c) 2008 Piotr Skamruk
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _LINUX_SPI_SPI_GPIO
+#define _LINUX_SPI_SPI_GPIO
+
+#include <linux/types.h>
+#include <linux/spi/spi.h>
+
+
+/** struct spi_gpio_platform_data - Data definitions for a SPI-GPIO device.
+ * This structure holds information about a GPIO-based SPI device.
+ *
+ * @pin_clk: The GPIO pin number of the CLOCK pin.
+ *
+ * @pin_miso: The GPIO pin number of the MISO pin.
+ *
+ * @pin_mosi: The GPIO pin number of the MOSI pin.
+ *
+ * @pin_cs: The GPIO pin number of the CHIPSELECT pin.
+ *
+ * @cs_activelow: If true, the chip is selected when the CS line is low.
+ *
+ * @no_spi_delay: If true, no delay is done in the lowlevel bitbanging.
+ *                Note that doing no delay is not standards compliant,
+ *                but it might be needed to speed up transfers on some
+ *                slow embedded machines.
+ *
+ * @boardinfo_setup: This callback is called after the
+ *                   SPI master device was registered, but before the
+ *                   device is registered.
+ * @boardinfo_setup_data: Data argument passed to boardinfo_setup().
+ */
+struct spi_gpio_platform_data {
+       unsigned int pin_clk;
+       unsigned int pin_miso;
+       unsigned int pin_mosi;
+       unsigned int pin_cs;
+       bool cs_activelow;
+       bool no_spi_delay;
+       int (*boardinfo_setup)(struct spi_board_info *bi,
+                              struct spi_master *master,
+                              void *data);
+       void *boardinfo_setup_data;
+};
+
+#endif /* _LINUX_SPI_SPI_GPIO */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb.h
new file mode 100644 (file)
index 0000000..9d5da8b
--- /dev/null
@@ -0,0 +1,404 @@
+#ifndef LINUX_SSB_H_
+#define LINUX_SSB_H_
+
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+#include <linux/pci.h>
+#include <linux/mod_devicetable.h>
+
+#include <linux/ssb/ssb_regs.h>
+
+
+struct pcmcia_device;
+struct ssb_bus;
+struct ssb_driver;
+
+struct ssb_sprom {
+       u8 revision;
+       u8 il0mac[6];           /* MAC address for 802.11b/g */
+       u8 et0mac[6];           /* MAC address for Ethernet */
+       u8 et1mac[6];           /* MAC address for 802.11a */
+       u8 et0phyaddr;          /* MII address for enet0 */
+       u8 et1phyaddr;          /* MII address for enet1 */
+       u8 et0mdcport;          /* MDIO for enet0 */
+       u8 et1mdcport;          /* MDIO for enet1 */
+       u8 board_rev;           /* Board revision number from SPROM. */
+       u8 country_code;        /* Country Code */
+       u8 ant_available_a;     /* A-PHY antenna available bits (up to 4) */
+       u8 ant_available_bg;    /* B/G-PHY antenna available bits (up to 4) */
+       u16 pa0b0;
+       u16 pa0b1;
+       u16 pa0b2;
+       u16 pa1b0;
+       u16 pa1b1;
+       u16 pa1b2;
+       u8 gpio0;               /* GPIO pin 0 */
+       u8 gpio1;               /* GPIO pin 1 */
+       u8 gpio2;               /* GPIO pin 2 */
+       u8 gpio3;               /* GPIO pin 3 */
+       u16 maxpwr_a;           /* A-PHY Amplifier Max Power (in dBm Q5.2) */
+       u16 maxpwr_bg;          /* B/G-PHY Amplifier Max Power (in dBm Q5.2) */
+       u8 itssi_a;             /* Idle TSSI Target for A-PHY */
+       u8 itssi_bg;            /* Idle TSSI Target for B/G-PHY */
+       u16 boardflags_lo;      /* Boardflags (low 16 bits) */
+       u16 boardflags_hi;      /* Boardflags (high 16 bits) */
+
+       /* Antenna gain values for up to 4 antennas
+        * on each band. Values in dBm/4 (Q5.2). Negative gain means the
+        * loss in the connectors is bigger than the gain. */
+       struct {
+               struct {
+                       s8 a0, a1, a2, a3;
+               } ghz24;        /* 2.4GHz band */
+               struct {
+                       s8 a0, a1, a2, a3;
+               } ghz5;         /* 5GHz band */
+       } antenna_gain;
+
+       /* TODO - add any parameters needed from rev 2, 3, or 4 SPROMs */
+};
+
+/* Information about the PCB the circuitry is soldered on. */
+struct ssb_boardinfo {
+       u16 vendor;
+       u16 type;
+       u16 rev;
+};
+
+
+struct ssb_device;
+/* Lowlevel read/write operations on the device MMIO.
+ * Internal, don't use that outside of ssb. */
+struct ssb_bus_ops {
+       u16 (*read16)(struct ssb_device *dev, u16 offset);
+       u32 (*read32)(struct ssb_device *dev, u16 offset);
+       void (*write16)(struct ssb_device *dev, u16 offset, u16 value);
+       void (*write32)(struct ssb_device *dev, u16 offset, u32 value);
+};
+
+
+/* Core-ID values. */
+#define SSB_DEV_CHIPCOMMON     0x800
+#define SSB_DEV_ILINE20                0x801
+#define SSB_DEV_SDRAM          0x803
+#define SSB_DEV_PCI            0x804
+#define SSB_DEV_MIPS           0x805
+#define SSB_DEV_ETHERNET       0x806
+#define SSB_DEV_V90            0x807
+#define SSB_DEV_USB11_HOSTDEV  0x808
+#define SSB_DEV_ADSL           0x809
+#define SSB_DEV_ILINE100       0x80A
+#define SSB_DEV_IPSEC          0x80B
+#define SSB_DEV_PCMCIA         0x80D
+#define SSB_DEV_INTERNAL_MEM   0x80E
+#define SSB_DEV_MEMC_SDRAM     0x80F
+#define SSB_DEV_EXTIF          0x811
+#define SSB_DEV_80211          0x812
+#define SSB_DEV_MIPS_3302      0x816
+#define SSB_DEV_USB11_HOST     0x817
+#define SSB_DEV_USB11_DEV      0x818
+#define SSB_DEV_USB20_HOST     0x819
+#define SSB_DEV_USB20_DEV      0x81A
+#define SSB_DEV_SDIO_HOST      0x81B
+#define SSB_DEV_ROBOSWITCH     0x81C
+#define SSB_DEV_PARA_ATA       0x81D
+#define SSB_DEV_SATA_XORDMA    0x81E
+#define SSB_DEV_ETHERNET_GBIT  0x81F
+#define SSB_DEV_PCIE           0x820
+#define SSB_DEV_MIMO_PHY       0x821
+#define SSB_DEV_SRAM_CTRLR     0x822
+#define SSB_DEV_MINI_MACPHY    0x823
+#define SSB_DEV_ARM_1176       0x824
+#define SSB_DEV_ARM_7TDMI      0x825
+
+/* Vendor-ID values */
+#define SSB_VENDOR_BROADCOM    0x4243
+
+/* Some kernel subsystems poke with dev->drvdata, so we must use the
+ * following ugly workaround to get from struct device to struct ssb_device */
+struct __ssb_dev_wrapper {
+       struct device dev;
+       struct ssb_device *sdev;
+};
+
+struct ssb_device {
+       /* Having a copy of the ops pointer in each dev struct
+        * is an optimization. */
+       const struct ssb_bus_ops *ops;
+
+       struct device *dev;
+       struct ssb_bus *bus;
+       struct ssb_device_id id;
+
+       u8 core_index;
+       unsigned int irq;
+
+       /* Internal-only stuff follows. */
+       void *drvdata;          /* Per-device data */
+       void *devtypedata;      /* Per-devicetype (eg 802.11) data */
+};
+
+/* Go from struct device to struct ssb_device. */
+static inline
+struct ssb_device * dev_to_ssb_dev(struct device *dev)
+{
+       struct __ssb_dev_wrapper *wrap;
+       wrap = container_of(dev, struct __ssb_dev_wrapper, dev);
+       return wrap->sdev;
+}
+
+/* Device specific user data */
+static inline
+void ssb_set_drvdata(struct ssb_device *dev, void *data)
+{
+       dev->drvdata = data;
+}
+static inline
+void * ssb_get_drvdata(struct ssb_device *dev)
+{
+       return dev->drvdata;
+}
+
+/* Devicetype specific user data. This is per device-type (not per device) */
+void ssb_set_devtypedata(struct ssb_device *dev, void *data);
+static inline
+void * ssb_get_devtypedata(struct ssb_device *dev)
+{
+       return dev->devtypedata;
+}
+
+
+struct ssb_driver {
+       const char *name;
+       const struct ssb_device_id *id_table;
+
+       int (*probe)(struct ssb_device *dev, const struct ssb_device_id *id);
+       void (*remove)(struct ssb_device *dev);
+       int (*suspend)(struct ssb_device *dev, pm_message_t state);
+       int (*resume)(struct ssb_device *dev);
+       void (*shutdown)(struct ssb_device *dev);
+
+       struct device_driver drv;
+};
+#define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv)
+
+extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner);
+static inline int ssb_driver_register(struct ssb_driver *drv)
+{
+       return __ssb_driver_register(drv, THIS_MODULE);
+}
+extern void ssb_driver_unregister(struct ssb_driver *drv);
+
+
+
+
+enum ssb_bustype {
+       SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */
+       SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */
+       SSB_BUSTYPE_PCMCIA,     /* SSB is connected to PCMCIA bus */
+};
+
+/* board_vendor */
+#define SSB_BOARDVENDOR_BCM    0x14E4  /* Broadcom */
+#define SSB_BOARDVENDOR_DELL   0x1028  /* Dell */
+#define SSB_BOARDVENDOR_HP     0x0E11  /* HP */
+/* board_type */
+#define SSB_BOARD_BCM94306MP   0x0418
+#define SSB_BOARD_BCM4309G     0x0421
+#define SSB_BOARD_BCM4306CB    0x0417
+#define SSB_BOARD_BCM4309MP    0x040C
+#define SSB_BOARD_MP4318       0x044A
+#define SSB_BOARD_BU4306       0x0416
+#define SSB_BOARD_BU4309       0x040A
+/* chip_package */
+#define SSB_CHIPPACK_BCM4712S  1       /* Small 200pin 4712 */
+#define SSB_CHIPPACK_BCM4712M  2       /* Medium 225pin 4712 */
+#define SSB_CHIPPACK_BCM4712L  0       /* Large 340pin 4712 */
+
+#include <linux/ssb/ssb_driver_chipcommon.h>
+#include <linux/ssb/ssb_driver_mips.h>
+#include <linux/ssb/ssb_driver_extif.h>
+#include <linux/ssb/ssb_driver_pci.h>
+
+struct ssb_bus {
+       /* The MMIO area. */
+       void __iomem *mmio;
+
+       const struct ssb_bus_ops *ops;
+
+       /* The core in the basic address register window. (PCI bus only) */
+       struct ssb_device *mapped_device;
+       /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */
+       u8 mapped_pcmcia_seg;
+       /* Lock for core and segment switching.
+        * On PCMCIA-host busses this is used to protect the whole MMIO access. */
+       spinlock_t bar_lock;
+
+       /* The bus this backplane is running on. */
+       enum ssb_bustype bustype;
+       /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */
+       struct pci_dev *host_pci;
+       /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */
+       struct pcmcia_device *host_pcmcia;
+
+#ifdef CONFIG_SSB_PCIHOST
+       /* Mutex to protect the SPROM writing. */
+       struct mutex pci_sprom_mutex;
+#endif
+
+       /* ID information about the Chip. */
+       u16 chip_id;
+       u16 chip_rev;
+       u16 sprom_size;         /* number of words in sprom */
+       u8 chip_package;
+
+       /* List of devices (cores) on the backplane. */
+       struct ssb_device devices[SSB_MAX_NR_CORES];
+       u8 nr_devices;
+
+       /* Reference count. Number of suspended devices. */
+       u8 suspend_cnt;
+
+       /* Software ID number for this bus. */
+       unsigned int busnumber;
+
+       /* The ChipCommon device (if available). */
+       struct ssb_chipcommon chipco;
+       /* The PCI-core device (if available). */
+       struct ssb_pcicore pcicore;
+       /* The MIPS-core device (if available). */
+       struct ssb_mipscore mipscore;
+       /* The EXTif-core device (if available). */
+       struct ssb_extif extif;
+
+       /* The following structure elements are not available in early
+        * SSB initialization. Though, they are available for regular
+        * registered drivers at any stage. So be careful when
+        * using them in the ssb core code. */
+
+       /* ID information about the PCB. */
+       struct ssb_boardinfo boardinfo;
+       /* Contents of the SPROM. */
+       struct ssb_sprom sprom;
+
+       /* Internal-only stuff follows. Do not touch. */
+       struct list_head list;
+#ifdef CONFIG_SSB_DEBUG
+       /* Is the bus already powered up? */
+       bool powered_up;
+       int power_warn_count;
+#endif /* DEBUG */
+};
+
+/* The initialization-invariants. */
+struct ssb_init_invariants {
+       struct ssb_boardinfo boardinfo;
+       struct ssb_sprom sprom;
+};
+/* Type of function to fetch the invariants. */
+typedef int (*ssb_invariants_func_t)(struct ssb_bus *bus,
+                                    struct ssb_init_invariants *iv);
+
+/* Register a SSB system bus. get_invariants() is called after the
+ * basic system devices are initialized.
+ * The invariants are usually fetched from some NVRAM.
+ * Put the invariants into the struct pointed to by iv. */
+extern int ssb_bus_ssbbus_register(struct ssb_bus *bus,
+                                  unsigned long baseaddr,
+                                  ssb_invariants_func_t get_invariants);
+#ifdef CONFIG_SSB_PCIHOST
+extern int ssb_bus_pcibus_register(struct ssb_bus *bus,
+                                  struct pci_dev *host_pci);
+#endif /* CONFIG_SSB_PCIHOST */
+#ifdef CONFIG_SSB_PCMCIAHOST
+extern int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
+                                     struct pcmcia_device *pcmcia_dev,
+                                     unsigned long baseaddr);
+#endif /* CONFIG_SSB_PCMCIAHOST */
+
+extern void ssb_bus_unregister(struct ssb_bus *bus);
+
+extern u32 ssb_clockspeed(struct ssb_bus *bus);
+
+/* Is the device enabled in hardware? */
+int ssb_device_is_enabled(struct ssb_device *dev);
+/* Enable a device and pass device-specific SSB_TMSLOW flags.
+ * If no device-specific flags are available, use 0. */
+void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags);
+/* Disable a device in hardware and pass SSB_TMSLOW flags (if any). */
+void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags);
+
+
+/* Device MMIO register read/write functions. */
+static inline u16 ssb_read16(struct ssb_device *dev, u16 offset)
+{
+       return dev->ops->read16(dev, offset);
+}
+static inline u32 ssb_read32(struct ssb_device *dev, u16 offset)
+{
+       return dev->ops->read32(dev, offset);
+}
+static inline void ssb_write16(struct ssb_device *dev, u16 offset, u16 value)
+{
+       dev->ops->write16(dev, offset, value);
+}
+static inline void ssb_write32(struct ssb_device *dev, u16 offset, u32 value)
+{
+       dev->ops->write32(dev, offset, value);
+}
+
+
+/* Translation (routing) bits that need to be ORed to DMA
+ * addresses before they are given to a device. */
+extern u32 ssb_dma_translation(struct ssb_device *dev);
+#define SSB_DMA_TRANSLATION_MASK       0xC0000000
+#define SSB_DMA_TRANSLATION_SHIFT      30
+
+extern int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask);
+
+
+#ifdef CONFIG_SSB_PCIHOST
+/* PCI-host wrapper driver */
+extern int ssb_pcihost_register(struct pci_driver *driver);
+static inline void ssb_pcihost_unregister(struct pci_driver *driver)
+{
+       pci_unregister_driver(driver);
+}
+
+static inline
+void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state)
+{
+       if (sdev->bus->bustype == SSB_BUSTYPE_PCI)
+               pci_set_power_state(sdev->bus->host_pci, state);
+}
+#else
+static inline void ssb_pcihost_unregister(struct pci_driver *driver)
+{
+}
+
+static inline
+void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state)
+{
+}
+#endif /* CONFIG_SSB_PCIHOST */
+
+
+/* If a driver is shutdown or suspended, call this to signal
+ * that the bus may be completely powered down. SSB will decide,
+ * if it's really time to power down the bus, based on if there
+ * are other devices that want to run. */
+extern int ssb_bus_may_powerdown(struct ssb_bus *bus);
+/* Before initializing and enabling a device, call this to power-up the bus.
+ * If you want to allow use of dynamic-power-control, pass the flag.
+ * Otherwise static always-on powercontrol will be used. */
+extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl);
+
+
+/* Various helper functions */
+extern u32 ssb_admatch_base(u32 adm);
+extern u32 ssb_admatch_size(u32 adm);
+
+
+#endif /* LINUX_SSB_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_chipcommon.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_chipcommon.h
new file mode 100644 (file)
index 0000000..4cb9954
--- /dev/null
@@ -0,0 +1,396 @@
+#ifndef LINUX_SSB_CHIPCO_H_
+#define LINUX_SSB_CHIPCO_H_
+
+/* SonicsSiliconBackplane CHIPCOMMON core hardware definitions
+ *
+ * The chipcommon core provides chip identification, SB control,
+ * jtag, 0/1/2 uarts, clock frequency control, a watchdog interrupt timer,
+ * gpio interface, extbus, and support for serial and parallel flashes.
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GPL version 2. See COPYING for details.
+ */
+
+/** ChipCommon core registers. **/
+
+#define SSB_CHIPCO_CHIPID              0x0000
+#define  SSB_CHIPCO_IDMASK             0x0000FFFF
+#define  SSB_CHIPCO_REVMASK            0x000F0000
+#define  SSB_CHIPCO_REVSHIFT           16
+#define  SSB_CHIPCO_PACKMASK           0x00F00000
+#define  SSB_CHIPCO_PACKSHIFT          20
+#define  SSB_CHIPCO_NRCORESMASK                0x0F000000
+#define  SSB_CHIPCO_NRCORESSHIFT       24
+#define SSB_CHIPCO_CAP                 0x0004          /* Capabilities */
+#define  SSB_CHIPCO_CAP_NRUART         0x00000003      /* # of UARTs */
+#define  SSB_CHIPCO_CAP_MIPSEB         0x00000004      /* MIPS in BigEndian Mode */
+#define  SSB_CHIPCO_CAP_UARTCLK                0x00000018      /* UART clock select */
+#define   SSB_CHIPCO_CAP_UARTCLK_INT   0x00000008      /* UARTs are driven by internal divided clock */
+#define  SSB_CHIPCO_CAP_UARTGPIO       0x00000020      /* UARTs on GPIO 15-12 */
+#define  SSB_CHIPCO_CAP_EXTBUS         0x000000C0      /* External buses present */
+#define  SSB_CHIPCO_CAP_FLASHT         0x00000700      /* Flash Type */
+#define   SSB_CHIPCO_FLASHT_NONE       0x00000000      /* No flash */
+#define   SSB_CHIPCO_FLASHT_STSER      0x00000100      /* ST serial flash */
+#define   SSB_CHIPCO_FLASHT_ATSER      0x00000200      /* Atmel serial flash */
+#define          SSB_CHIPCO_FLASHT_PARA        0x00000700      /* Parallel flash */
+#define  SSB_CHIPCO_CAP_PLLT           0x00038000      /* PLL Type */
+#define   SSB_PLLTYPE_NONE             0x00000000
+#define   SSB_PLLTYPE_1                        0x00010000      /* 48Mhz base, 3 dividers */
+#define   SSB_PLLTYPE_2                        0x00020000      /* 48Mhz, 4 dividers */
+#define   SSB_PLLTYPE_3                        0x00030000      /* 25Mhz, 2 dividers */
+#define   SSB_PLLTYPE_4                        0x00008000      /* 48Mhz, 4 dividers */
+#define   SSB_PLLTYPE_5                        0x00018000      /* 25Mhz, 4 dividers */
+#define   SSB_PLLTYPE_6                        0x00028000      /* 100/200 or 120/240 only */
+#define   SSB_PLLTYPE_7                        0x00038000      /* 25Mhz, 4 dividers */
+#define  SSB_CHIPCO_CAP_PCTL           0x00040000      /* Power Control */
+#define  SSB_CHIPCO_CAP_OTPS           0x00380000      /* OTP size */
+#define  SSB_CHIPCO_CAP_OTPS_SHIFT     19
+#define  SSB_CHIPCO_CAP_OTPS_BASE      5
+#define  SSB_CHIPCO_CAP_JTAGM          0x00400000      /* JTAG master present */
+#define  SSB_CHIPCO_CAP_BROM           0x00800000      /* Internal boot ROM active */
+#define  SSB_CHIPCO_CAP_64BIT          0x08000000      /* 64-bit Backplane */
+#define SSB_CHIPCO_CORECTL             0x0008
+#define  SSB_CHIPCO_CORECTL_UARTCLK0   0x00000001      /* Drive UART with internal clock */
+#define         SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */
+#define SSB_CHIPCO_BIST                        0x000C
+#define SSB_CHIPCO_OTPS                        0x0010          /* OTP status */
+#define         SSB_CHIPCO_OTPS_PROGFAIL       0x80000000
+#define         SSB_CHIPCO_OTPS_PROTECT        0x00000007
+#define         SSB_CHIPCO_OTPS_HW_PROTECT     0x00000001
+#define         SSB_CHIPCO_OTPS_SW_PROTECT     0x00000002
+#define         SSB_CHIPCO_OTPS_CID_PROTECT    0x00000004
+#define SSB_CHIPCO_OTPC                        0x0014          /* OTP control */
+#define         SSB_CHIPCO_OTPC_RECWAIT        0xFF000000
+#define         SSB_CHIPCO_OTPC_PROGWAIT       0x00FFFF00
+#define         SSB_CHIPCO_OTPC_PRW_SHIFT      8
+#define         SSB_CHIPCO_OTPC_MAXFAIL        0x00000038
+#define         SSB_CHIPCO_OTPC_VSEL           0x00000006
+#define         SSB_CHIPCO_OTPC_SELVL          0x00000001
+#define SSB_CHIPCO_OTPP                        0x0018          /* OTP prog */
+#define         SSB_CHIPCO_OTPP_COL            0x000000FF
+#define         SSB_CHIPCO_OTPP_ROW            0x0000FF00
+#define         SSB_CHIPCO_OTPP_ROW_SHIFT      8
+#define         SSB_CHIPCO_OTPP_READERR        0x10000000
+#define         SSB_CHIPCO_OTPP_VALUE          0x20000000
+#define         SSB_CHIPCO_OTPP_READ           0x40000000
+#define         SSB_CHIPCO_OTPP_START          0x80000000
+#define         SSB_CHIPCO_OTPP_BUSY           0x80000000
+#define SSB_CHIPCO_IRQSTAT             0x0020
+#define SSB_CHIPCO_IRQMASK             0x0024
+#define         SSB_CHIPCO_IRQ_GPIO            0x00000001      /* gpio intr */
+#define         SSB_CHIPCO_IRQ_EXT             0x00000002      /* ro: ext intr pin (corerev >= 3) */
+#define         SSB_CHIPCO_IRQ_WDRESET         0x80000000      /* watchdog reset occurred */
+#define SSB_CHIPCO_CHIPCTL             0x0028          /* Rev >= 11 only */
+#define SSB_CHIPCO_CHIPSTAT            0x002C          /* Rev >= 11 only */
+#define SSB_CHIPCO_JCMD                        0x0030          /* Rev >= 10 only */
+#define  SSB_CHIPCO_JCMD_START         0x80000000
+#define  SSB_CHIPCO_JCMD_BUSY          0x80000000
+#define  SSB_CHIPCO_JCMD_PAUSE         0x40000000
+#define  SSB_CHIPCO_JCMD0_ACC_MASK     0x0000F000
+#define  SSB_CHIPCO_JCMD0_ACC_IRDR     0x00000000
+#define  SSB_CHIPCO_JCMD0_ACC_DR       0x00001000
+#define  SSB_CHIPCO_JCMD0_ACC_IR       0x00002000
+#define  SSB_CHIPCO_JCMD0_ACC_RESET    0x00003000
+#define  SSB_CHIPCO_JCMD0_ACC_IRPDR    0x00004000
+#define  SSB_CHIPCO_JCMD0_ACC_PDR      0x00005000
+#define  SSB_CHIPCO_JCMD0_IRW_MASK     0x00000F00
+#define  SSB_CHIPCO_JCMD_ACC_MASK      0x000F0000      /* Changes for corerev 11 */
+#define  SSB_CHIPCO_JCMD_ACC_IRDR      0x00000000
+#define  SSB_CHIPCO_JCMD_ACC_DR                0x00010000
+#define  SSB_CHIPCO_JCMD_ACC_IR                0x00020000
+#define  SSB_CHIPCO_JCMD_ACC_RESET     0x00030000
+#define  SSB_CHIPCO_JCMD_ACC_IRPDR     0x00040000
+#define  SSB_CHIPCO_JCMD_ACC_PDR       0x00050000
+#define  SSB_CHIPCO_JCMD_IRW_MASK      0x00001F00
+#define  SSB_CHIPCO_JCMD_IRW_SHIFT     8
+#define  SSB_CHIPCO_JCMD_DRW_MASK      0x0000003F
+#define SSB_CHIPCO_JIR                 0x0034          /* Rev >= 10 only */
+#define SSB_CHIPCO_JDR                 0x0038          /* Rev >= 10 only */
+#define SSB_CHIPCO_JCTL                        0x003C          /* Rev >= 10 only */
+#define  SSB_CHIPCO_JCTL_FORCE_CLK     4               /* Force clock */
+#define  SSB_CHIPCO_JCTL_EXT_EN                2               /* Enable external targets */
+#define  SSB_CHIPCO_JCTL_EN            1               /* Enable Jtag master */
+#define SSB_CHIPCO_FLASHCTL            0x0040
+#define  SSB_CHIPCO_FLASHCTL_START     0x80000000
+#define  SSB_CHIPCO_FLASHCTL_BUSY      SSB_CHIPCO_FLASHCTL_START
+#define SSB_CHIPCO_FLASHADDR           0x0044
+#define SSB_CHIPCO_FLASHDATA           0x0048
+#define SSB_CHIPCO_BCAST_ADDR          0x0050
+#define SSB_CHIPCO_BCAST_DATA          0x0054
+#define SSB_CHIPCO_GPIOIN              0x0060
+#define SSB_CHIPCO_GPIOOUT             0x0064
+#define SSB_CHIPCO_GPIOOUTEN           0x0068
+#define SSB_CHIPCO_GPIOCTL             0x006C
+#define SSB_CHIPCO_GPIOPOL             0x0070
+#define SSB_CHIPCO_GPIOIRQ             0x0074
+#define SSB_CHIPCO_WATCHDOG            0x0080
+#define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */
+#define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16
+#define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */
+#define SSB_CHIPCO_CLOCK_N             0x0090
+#define SSB_CHIPCO_CLOCK_SB            0x0094
+#define SSB_CHIPCO_CLOCK_PCI           0x0098
+#define SSB_CHIPCO_CLOCK_M2            0x009C
+#define SSB_CHIPCO_CLOCK_MIPS          0x00A0
+#define SSB_CHIPCO_CLKDIV              0x00A4          /* Rev >= 3 only */
+#define         SSB_CHIPCO_CLKDIV_SFLASH       0x0F000000
+#define         SSB_CHIPCO_CLKDIV_SFLASH_SHIFT 24
+#define         SSB_CHIPCO_CLKDIV_OTP          0x000F0000
+#define         SSB_CHIPCO_CLKDIV_OTP_SHIFT    16
+#define         SSB_CHIPCO_CLKDIV_JTAG         0x00000F00
+#define         SSB_CHIPCO_CLKDIV_JTAG_SHIFT   8
+#define         SSB_CHIPCO_CLKDIV_UART         0x000000FF
+#define SSB_CHIPCO_PLLONDELAY          0x00B0          /* Rev >= 4 only */
+#define SSB_CHIPCO_FREFSELDELAY                0x00B4          /* Rev >= 4 only */
+#define SSB_CHIPCO_SLOWCLKCTL          0x00B8          /* 6 <= Rev <= 9 only */
+#define  SSB_CHIPCO_SLOWCLKCTL_SRC     0x00000007      /* slow clock source mask */
+#define          SSB_CHIPCO_SLOWCLKCTL_SRC_LPO         0x00000000      /* source of slow clock is LPO */
+#define   SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL       0x00000001      /* source of slow clock is crystal */
+#define          SSB_CHIPCO_SLOECLKCTL_SRC_PCI         0x00000002      /* source of slow clock is PCI */
+#define  SSB_CHIPCO_SLOWCLKCTL_LPOFREQ 0x00000200      /* LPOFreqSel, 1: 160Khz, 0: 32KHz */
+#define  SSB_CHIPCO_SLOWCLKCTL_LPOPD   0x00000400      /* LPOPowerDown, 1: LPO is disabled, 0: LPO is enabled */
+#define  SSB_CHIPCO_SLOWCLKCTL_FSLOW   0x00000800      /* ForceSlowClk, 1: sb/cores running on slow clock, 0: power logic control */
+#define  SSB_CHIPCO_SLOWCLKCTL_IPLL    0x00001000      /* IgnorePllOffReq, 1/0: power logic ignores/honors PLL clock disable requests from core */
+#define  SSB_CHIPCO_SLOWCLKCTL_ENXTAL  0x00002000      /* XtalControlEn, 1/0: power logic does/doesn't disable crystal when appropriate */
+#define  SSB_CHIPCO_SLOWCLKCTL_XTALPU  0x00004000      /* XtalPU (RO), 1/0: crystal running/disabled */
+#define  SSB_CHIPCO_SLOWCLKCTL_CLKDIV  0xFFFF0000      /* ClockDivider (SlowClk = 1/(4+divisor)) */
+#define  SSB_CHIPCO_SLOWCLKCTL_CLKDIV_SHIFT    16
+#define SSB_CHIPCO_SYSCLKCTL           0x00C0          /* Rev >= 3 only */
+#define         SSB_CHIPCO_SYSCLKCTL_IDLPEN    0x00000001      /* ILPen: Enable Idle Low Power */
+#define         SSB_CHIPCO_SYSCLKCTL_ALPEN     0x00000002      /* ALPen: Enable Active Low Power */
+#define         SSB_CHIPCO_SYSCLKCTL_PLLEN     0x00000004      /* ForcePLLOn */
+#define         SSB_CHIPCO_SYSCLKCTL_FORCEALP  0x00000008      /* Force ALP (or HT if ALPen is not set */
+#define         SSB_CHIPCO_SYSCLKCTL_FORCEHT   0x00000010      /* Force HT */
+#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV   0xFFFF0000      /* ClkDiv  (ILP = 1/(4+divisor)) */
+#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV_SHIFT     16
+#define SSB_CHIPCO_CLKSTSTR            0x00C4          /* Rev >= 3 only */
+#define SSB_CHIPCO_PCMCIA_CFG          0x0100
+#define SSB_CHIPCO_PCMCIA_MEMWAIT      0x0104
+#define SSB_CHIPCO_PCMCIA_ATTRWAIT     0x0108
+#define SSB_CHIPCO_PCMCIA_IOWAIT       0x010C
+#define SSB_CHIPCO_IDE_CFG             0x0110
+#define SSB_CHIPCO_IDE_MEMWAIT         0x0114
+#define SSB_CHIPCO_IDE_ATTRWAIT                0x0118
+#define SSB_CHIPCO_IDE_IOWAIT          0x011C
+#define SSB_CHIPCO_PROG_CFG            0x0120
+#define SSB_CHIPCO_PROG_WAITCNT                0x0124
+#define SSB_CHIPCO_FLASH_CFG           0x0128
+#define SSB_CHIPCO_FLASH_WAITCNT       0x012C
+#define SSB_CHIPCO_UART0_DATA          0x0300
+#define SSB_CHIPCO_UART0_IMR           0x0304
+#define SSB_CHIPCO_UART0_FCR           0x0308
+#define SSB_CHIPCO_UART0_LCR           0x030C
+#define SSB_CHIPCO_UART0_MCR           0x0310
+#define SSB_CHIPCO_UART0_LSR           0x0314
+#define SSB_CHIPCO_UART0_MSR           0x0318
+#define SSB_CHIPCO_UART0_SCRATCH       0x031C
+#define SSB_CHIPCO_UART1_DATA          0x0400
+#define SSB_CHIPCO_UART1_IMR           0x0404
+#define SSB_CHIPCO_UART1_FCR           0x0408
+#define SSB_CHIPCO_UART1_LCR           0x040C
+#define SSB_CHIPCO_UART1_MCR           0x0410
+#define SSB_CHIPCO_UART1_LSR           0x0414
+#define SSB_CHIPCO_UART1_MSR           0x0418
+#define SSB_CHIPCO_UART1_SCRATCH       0x041C
+
+
+
+/** Clockcontrol masks and values **/
+
+/* SSB_CHIPCO_CLOCK_N */
+#define        SSB_CHIPCO_CLK_N1               0x0000003F      /* n1 control */
+#define        SSB_CHIPCO_CLK_N2               0x00003F00      /* n2 control */
+#define        SSB_CHIPCO_CLK_N2_SHIFT         8
+#define        SSB_CHIPCO_CLK_PLLC             0x000F0000      /* pll control */
+#define        SSB_CHIPCO_CLK_PLLC_SHIFT       16
+
+/* SSB_CHIPCO_CLOCK_SB/PCI/UART */
+#define        SSB_CHIPCO_CLK_M1               0x0000003F      /* m1 control */
+#define        SSB_CHIPCO_CLK_M2               0x00003F00      /* m2 control */
+#define        SSB_CHIPCO_CLK_M2_SHIFT         8
+#define        SSB_CHIPCO_CLK_M3               0x003F0000      /* m3 control */
+#define        SSB_CHIPCO_CLK_M3_SHIFT         16
+#define        SSB_CHIPCO_CLK_MC               0x1F000000      /* mux control */
+#define        SSB_CHIPCO_CLK_MC_SHIFT         24
+
+/* N3M Clock control magic field values */
+#define        SSB_CHIPCO_CLK_F6_2             0x02            /* A factor of 2 in */
+#define        SSB_CHIPCO_CLK_F6_3             0x03            /* 6-bit fields like */
+#define        SSB_CHIPCO_CLK_F6_4             0x05            /* N1, M1 or M3 */
+#define        SSB_CHIPCO_CLK_F6_5             0x09
+#define        SSB_CHIPCO_CLK_F6_6             0x11
+#define        SSB_CHIPCO_CLK_F6_7             0x21
+
+#define        SSB_CHIPCO_CLK_F5_BIAS          5               /* 5-bit fields get this added */
+
+#define        SSB_CHIPCO_CLK_MC_BYPASS        0x08
+#define        SSB_CHIPCO_CLK_MC_M1            0x04
+#define        SSB_CHIPCO_CLK_MC_M1M2          0x02
+#define        SSB_CHIPCO_CLK_MC_M1M2M3        0x01
+#define        SSB_CHIPCO_CLK_MC_M1M3          0x11
+
+/* Type 2 Clock control magic field values */
+#define        SSB_CHIPCO_CLK_T2_BIAS          2               /* n1, n2, m1 & m3 bias */
+#define        SSB_CHIPCO_CLK_T2M2_BIAS        3               /* m2 bias */
+
+#define        SSB_CHIPCO_CLK_T2MC_M1BYP       1
+#define        SSB_CHIPCO_CLK_T2MC_M2BYP       2
+#define        SSB_CHIPCO_CLK_T2MC_M3BYP       4
+
+/* Type 6 Clock control magic field values */
+#define        SSB_CHIPCO_CLK_T6_MMASK         1               /* bits of interest in m */
+#define        SSB_CHIPCO_CLK_T6_M0            120000000       /* sb clock for m = 0 */
+#define        SSB_CHIPCO_CLK_T6_M1            100000000       /* sb clock for m = 1 */
+#define        SSB_CHIPCO_CLK_SB2MIPS_T6(sb)   (2 * (sb))
+
+/* Common clock base */
+#define        SSB_CHIPCO_CLK_BASE1            24000000        /* Half the clock freq */
+#define SSB_CHIPCO_CLK_BASE2           12500000        /* Alternate crystal on some PLL's */
+
+/* Clock control values for 200Mhz in 5350 */
+#define        SSB_CHIPCO_CLK_5350_N           0x0311
+#define        SSB_CHIPCO_CLK_5350_M           0x04020009
+
+
+/** Bits in the config registers **/
+
+#define        SSB_CHIPCO_CFG_EN               0x0001          /* Enable */
+#define        SSB_CHIPCO_CFG_EXTM             0x000E          /* Extif Mode */
+#define         SSB_CHIPCO_CFG_EXTM_ASYNC      0x0002          /* Async/Parallel flash */
+#define         SSB_CHIPCO_CFG_EXTM_SYNC       0x0004          /* Synchronous */
+#define         SSB_CHIPCO_CFG_EXTM_PCMCIA     0x0008          /* PCMCIA */
+#define         SSB_CHIPCO_CFG_EXTM_IDE        0x000A          /* IDE */
+#define        SSB_CHIPCO_CFG_DS16             0x0010          /* Data size, 0=8bit, 1=16bit */
+#define        SSB_CHIPCO_CFG_CLKDIV           0x0060          /* Sync: Clock divisor */
+#define        SSB_CHIPCO_CFG_CLKEN            0x0080          /* Sync: Clock enable */
+#define        SSB_CHIPCO_CFG_BSTRO            0x0100          /* Sync: Size/Bytestrobe */
+
+
+/** Flash-specific control/status values */
+
+/* flashcontrol opcodes for ST flashes */
+#define SSB_CHIPCO_FLASHCTL_ST_WREN    0x0006          /* Write Enable */
+#define SSB_CHIPCO_FLASHCTL_ST_WRDIS   0x0004          /* Write Disable */
+#define SSB_CHIPCO_FLASHCTL_ST_RDSR    0x0105          /* Read Status Register */
+#define SSB_CHIPCO_FLASHCTL_ST_WRSR    0x0101          /* Write Status Register */
+#define SSB_CHIPCO_FLASHCTL_ST_READ    0x0303          /* Read Data Bytes */
+#define SSB_CHIPCO_FLASHCTL_ST_PP      0x0302          /* Page Program */
+#define SSB_CHIPCO_FLASHCTL_ST_SE      0x02D8          /* Sector Erase */
+#define SSB_CHIPCO_FLASHCTL_ST_BE      0x00C7          /* Bulk Erase */
+#define SSB_CHIPCO_FLASHCTL_ST_DP      0x00B9          /* Deep Power-down */
+#define SSB_CHIPCO_FLASHCTL_ST_RSIG    0x03AB          /* Read Electronic Signature */
+
+/* Status register bits for ST flashes */
+#define SSB_CHIPCO_FLASHSTA_ST_WIP     0x01            /* Write In Progress */
+#define SSB_CHIPCO_FLASHSTA_ST_WEL     0x02            /* Write Enable Latch */
+#define SSB_CHIPCO_FLASHSTA_ST_BP      0x1C            /* Block Protect */
+#define SSB_CHIPCO_FLASHSTA_ST_BP_SHIFT        2
+#define SSB_CHIPCO_FLASHSTA_ST_SRWD    0x80            /* Status Register Write Disable */
+
+/* flashcontrol opcodes for Atmel flashes */
+#define SSB_CHIPCO_FLASHCTL_AT_READ            0x07E8
+#define SSB_CHIPCO_FLASHCTL_AT_PAGE_READ       0x07D2
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_READ       /* FIXME */
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_READ       /* FIXME */
+#define SSB_CHIPCO_FLASHCTL_AT_STATUS          0x01D7
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_WRITE      0x0384
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_WRITE      0x0387
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_ERASE_PRGM 0x0283  /* Erase program */
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_ERASE_PRGM 0x0286  /* Erase program */
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_PROGRAM    0x0288
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_PROGRAM    0x0289
+#define SSB_CHIPCO_FLASHCTL_AT_PAGE_ERASE      0x0281
+#define SSB_CHIPCO_FLASHCTL_AT_BLOCK_ERASE     0x0250
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_WRER_PRGM  0x0382  /* Write erase program */
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_WRER_PRGM  0x0385  /* Write erase program */
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_LOAD       0x0253
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_LOAD       0x0255
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_COMPARE    0x0260
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_COMPARE    0x0261
+#define SSB_CHIPCO_FLASHCTL_AT_BUF1_REPROGRAM  0x0258
+#define SSB_CHIPCO_FLASHCTL_AT_BUF2_REPROGRAM  0x0259
+
+/* Status register bits for Atmel flashes */
+#define SSB_CHIPCO_FLASHSTA_AT_READY   0x80
+#define SSB_CHIPCO_FLASHSTA_AT_MISMATCH        0x40
+#define SSB_CHIPCO_FLASHSTA_AT_ID      0x38
+#define SSB_CHIPCO_FLASHSTA_AT_ID_SHIFT        3
+
+
+/** OTP **/
+
+/* OTP regions */
+#define        SSB_CHIPCO_OTP_HW_REGION        SSB_CHIPCO_OTPS_HW_PROTECT
+#define        SSB_CHIPCO_OTP_SW_REGION        SSB_CHIPCO_OTPS_SW_PROTECT
+#define        SSB_CHIPCO_OTP_CID_REGION       SSB_CHIPCO_OTPS_CID_PROTECT
+
+/* OTP regions (Byte offsets from otp size) */
+#define        SSB_CHIPCO_OTP_SWLIM_OFF        (-8)
+#define        SSB_CHIPCO_OTP_CIDBASE_OFF      0
+#define        SSB_CHIPCO_OTP_CIDLIM_OFF       8
+
+/* Predefined OTP words (Word offset from otp size) */
+#define        SSB_CHIPCO_OTP_BOUNDARY_OFF     (-4)
+#define        SSB_CHIPCO_OTP_HWSIGN_OFF       (-3)
+#define        SSB_CHIPCO_OTP_SWSIGN_OFF       (-2)
+#define        SSB_CHIPCO_OTP_CIDSIGN_OFF      (-1)
+
+#define        SSB_CHIPCO_OTP_CID_OFF          0
+#define        SSB_CHIPCO_OTP_PKG_OFF          1
+#define        SSB_CHIPCO_OTP_FID_OFF          2
+#define        SSB_CHIPCO_OTP_RSV_OFF          3
+#define        SSB_CHIPCO_OTP_LIM_OFF          4
+
+#define        SSB_CHIPCO_OTP_SIGNATURE        0x578A
+#define        SSB_CHIPCO_OTP_MAGIC            0x4E56
+
+
+struct ssb_device;
+struct ssb_serial_port;
+
+struct ssb_chipcommon {
+       struct ssb_device *dev;
+       u32 capabilities;
+       /* Fast Powerup Delay constant */
+       u16 fast_pwrup_delay;
+};
+
+extern void ssb_chipcommon_init(struct ssb_chipcommon *cc);
+
+#include <linux/pm.h>
+extern void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state);
+extern void ssb_chipco_resume(struct ssb_chipcommon *cc);
+
+extern void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc,
+                                    u32 *plltype, u32 *n, u32 *m);
+extern void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc,
+                                       u32 *plltype, u32 *n, u32 *m);
+extern void ssb_chipco_timing_init(struct ssb_chipcommon *cc,
+                                  unsigned long ns_per_cycle);
+
+enum ssb_clkmode {
+       SSB_CLKMODE_SLOW,
+       SSB_CLKMODE_FAST,
+       SSB_CLKMODE_DYNAMIC,
+};
+
+extern void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc,
+                                    enum ssb_clkmode mode);
+
+extern void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc,
+                                         u32 ticks);
+
+u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask);
+
+void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value);
+
+void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value);
+
+#ifdef CONFIG_SSB_SERIAL
+extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
+                                 struct ssb_serial_port *ports);
+#endif /* CONFIG_SSB_SERIAL */
+
+#endif /* LINUX_SSB_CHIPCO_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_extif.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_extif.h
new file mode 100644 (file)
index 0000000..a916435
--- /dev/null
@@ -0,0 +1,204 @@
+/*
+ * Hardware-specific External Interface I/O core definitions
+ * for the BCM47xx family of SiliconBackplane-based chips.
+ *
+ * The External Interface core supports a total of three external chip selects
+ * supporting external interfaces. One of the external chip selects is
+ * used for Flash, one is used for PCMCIA, and the other may be
+ * programmed to support either a synchronous interface or an
+ * asynchronous interface. The asynchronous interface can be used to
+ * support external devices such as UARTs and the BCM2019 Bluetooth
+ * baseband processor.
+ * The external interface core also contains 2 on-chip 16550 UARTs, clock
+ * frequency control, a watchdog interrupt timer, and a GPIO interface.
+ *
+ * Copyright 2005, Broadcom Corporation
+ * Copyright 2006, Michael Buesch
+ *
+ * Licensed under the GPL version 2. See COPYING for details.
+ */
+#ifndef LINUX_SSB_EXTIFCORE_H_
+#define LINUX_SSB_EXTIFCORE_H_
+
+/* external interface address space */
+#define        SSB_EXTIF_PCMCIA_MEMBASE(x)     (x)
+#define        SSB_EXTIF_PCMCIA_IOBASE(x)      ((x) + 0x100000)
+#define        SSB_EXTIF_PCMCIA_CFGBASE(x)     ((x) + 0x200000)
+#define        SSB_EXTIF_CFGIF_BASE(x)         ((x) + 0x800000)
+#define        SSB_EXTIF_FLASH_BASE(x)         ((x) + 0xc00000)
+
+#define SSB_EXTIF_NR_GPIOOUT           5
+/* GPIO NOTE:
+ * The multiple instances of output and output enable registers
+ * are present to allow driver software for multiple cores to control
+ * gpio outputs without needing to share a single register pair.
+ * Use the following helper macro to get a register offset value.
+ */
+#define SSB_EXTIF_GPIO_OUT(index)      ({              \
+       BUILD_BUG_ON(index >= SSB_EXTIF_NR_GPIOOUT);    \
+       SSB_EXTIF_GPIO_OUT_BASE + ((index) * 8);        \
+                                       })
+#define SSB_EXTIF_GPIO_OUTEN(index)    ({              \
+       BUILD_BUG_ON(index >= SSB_EXTIF_NR_GPIOOUT);    \
+       SSB_EXTIF_GPIO_OUTEN_BASE + ((index) * 8);      \
+                                       })
+
+/** EXTIF core registers **/
+
+#define SSB_EXTIF_CTL                  0x0000
+#define  SSB_EXTIF_CTL_UARTEN          (1 << 0) /* UART enable */
+#define SSB_EXTIF_EXTSTAT              0x0004
+#define  SSB_EXTIF_EXTSTAT_EMODE       (1 << 0) /* Endian mode (ro) */
+#define  SSB_EXTIF_EXTSTAT_EIRQPIN     (1 << 1) /* External interrupt pin (ro) */
+#define  SSB_EXTIF_EXTSTAT_GPIOIRQPIN  (1 << 2) /* GPIO interrupt pin (ro) */
+#define SSB_EXTIF_PCMCIA_CFG           0x0010
+#define SSB_EXTIF_PCMCIA_MEMWAIT       0x0014
+#define SSB_EXTIF_PCMCIA_ATTRWAIT      0x0018
+#define SSB_EXTIF_PCMCIA_IOWAIT                0x001C
+#define SSB_EXTIF_PROG_CFG             0x0020
+#define SSB_EXTIF_PROG_WAITCNT         0x0024
+#define SSB_EXTIF_FLASH_CFG            0x0028
+#define SSB_EXTIF_FLASH_WAITCNT                0x002C
+#define SSB_EXTIF_WATCHDOG             0x0040
+#define SSB_EXTIF_CLOCK_N              0x0044
+#define SSB_EXTIF_CLOCK_SB             0x0048
+#define SSB_EXTIF_CLOCK_PCI            0x004C
+#define SSB_EXTIF_CLOCK_MII            0x0050
+#define SSB_EXTIF_GPIO_IN              0x0060
+#define SSB_EXTIF_GPIO_OUT_BASE                0x0064
+#define SSB_EXTIF_GPIO_OUTEN_BASE      0x0068
+#define SSB_EXTIF_EJTAG_OUTEN          0x0090
+#define SSB_EXTIF_GPIO_INTPOL          0x0094
+#define SSB_EXTIF_GPIO_INTMASK         0x0098
+#define SSB_EXTIF_UART_DATA            0x0300
+#define SSB_EXTIF_UART_TIMER           0x0310
+#define SSB_EXTIF_UART_FCR             0x0320
+#define SSB_EXTIF_UART_LCR             0x0330
+#define SSB_EXTIF_UART_MCR             0x0340
+#define SSB_EXTIF_UART_LSR             0x0350
+#define SSB_EXTIF_UART_MSR             0x0360
+#define SSB_EXTIF_UART_SCRATCH         0x0370
+
+
+
+
+/* pcmcia/prog/flash_config */
+#define        SSB_EXTCFG_EN                   (1 << 0)        /* enable */
+#define        SSB_EXTCFG_MODE                 0xE             /* mode */
+#define        SSB_EXTCFG_MODE_SHIFT           1
+#define         SSB_EXTCFG_MODE_FLASH          0x0             /* flash/asynchronous mode */
+#define         SSB_EXTCFG_MODE_SYNC           0x2             /* synchronous mode */
+#define         SSB_EXTCFG_MODE_PCMCIA         0x4             /* pcmcia mode */
+#define        SSB_EXTCFG_DS16                 (1 << 4)        /* destsize:  0=8bit, 1=16bit */
+#define        SSB_EXTCFG_BSWAP                (1 << 5)        /* byteswap */
+#define        SSB_EXTCFG_CLKDIV               0xC0            /* clock divider */
+#define        SSB_EXTCFG_CLKDIV_SHIFT         6
+#define         SSB_EXTCFG_CLKDIV_2            0x0             /* backplane/2 */
+#define         SSB_EXTCFG_CLKDIV_3            0x40            /* backplane/3 */
+#define         SSB_EXTCFG_CLKDIV_4            0x80            /* backplane/4 */
+#define        SSB_EXTCFG_CLKEN                (1 << 8)        /* clock enable */
+#define        SSB_EXTCFG_STROBE               (1 << 9)        /* size/bytestrobe (synch only) */
+
+/* pcmcia_memwait */
+#define        SSB_PCMCIA_MEMW_0               0x0000003F      /* waitcount0 */
+#define        SSB_PCMCIA_MEMW_1               0x00001F00      /* waitcount1 */
+#define        SSB_PCMCIA_MEMW_1_SHIFT         8
+#define        SSB_PCMCIA_MEMW_2               0x001F0000      /* waitcount2 */
+#define        SSB_PCMCIA_MEMW_2_SHIFT         16
+#define        SSB_PCMCIA_MEMW_3               0x1F000000      /* waitcount3 */
+#define        SSB_PCMCIA_MEMW_3_SHIFT         24
+
+/* pcmcia_attrwait */
+#define        SSB_PCMCIA_ATTW_0               0x0000003F      /* waitcount0 */
+#define        SSB_PCMCIA_ATTW_1               0x00001F00      /* waitcount1 */
+#define        SSB_PCMCIA_ATTW_1_SHIFT         8
+#define        SSB_PCMCIA_ATTW_2               0x001F0000      /* waitcount2 */
+#define        SSB_PCMCIA_ATTW_2_SHIFT         16
+#define        SSB_PCMCIA_ATTW_3               0x1F000000      /* waitcount3 */
+#define        SSB_PCMCIA_ATTW_3_SHIFT         24
+
+/* pcmcia_iowait */
+#define        SSB_PCMCIA_IOW_0                0x0000003F      /* waitcount0 */
+#define        SSB_PCMCIA_IOW_1                0x00001F00      /* waitcount1 */
+#define        SSB_PCMCIA_IOW_1_SHIFT          8
+#define        SSB_PCMCIA_IOW_2                0x001F0000      /* waitcount2 */
+#define        SSB_PCMCIA_IOW_2_SHIFT          16
+#define        SSB_PCMCIA_IOW_3                0x1F000000      /* waitcount3 */
+#define        SSB_PCMCIA_IOW_3_SHIFT          24
+
+/* prog_waitcount */
+#define        SSB_PROG_WCNT_0                 0x0000001F      /* waitcount0 */
+#define        SSB_PROG_WCNT_1                 0x00001F00      /* waitcount1 */
+#define        SSB_PROG_WCNT_1_SHIFT           8
+#define        SSB_PROG_WCNT_2                 0x001F0000      /* waitcount2 */
+#define        SSB_PROG_WCNT_2_SHIFT           16
+#define        SSB_PROG_WCNT_3                 0x1F000000      /* waitcount3 */
+#define        SSB_PROG_WCNT_3_SHIFT           24
+
+#define SSB_PROG_W0                    0x0000000C
+#define SSB_PROG_W1                    0x00000A00
+#define SSB_PROG_W2                    0x00020000
+#define SSB_PROG_W3                    0x01000000
+
+/* flash_waitcount */
+#define        SSB_FLASH_WCNT_0                0x0000001F      /* waitcount0 */
+#define        SSB_FLASH_WCNT_1                0x00001F00      /* waitcount1 */
+#define        SSB_FLASH_WCNT_1_SHIFT          8
+#define        SSB_FLASH_WCNT_2                0x001F0000      /* waitcount2 */
+#define        SSB_FLASH_WCNT_2_SHIFT          16
+#define        SSB_FLASH_WCNT_3                0x1F000000      /* waitcount3 */
+#define        SSB_FLASH_WCNT_3_SHIFT          24
+
+/* watchdog */
+#define SSB_EXTIF_WATCHDOG_CLK         48000000        /* Hz */
+
+
+
+#ifdef CONFIG_SSB_DRIVER_EXTIF
+
+struct ssb_extif {
+       struct ssb_device *dev;
+};
+
+static inline bool ssb_extif_available(struct ssb_extif *extif)
+{
+       return (extif->dev != NULL);
+}
+
+extern void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
+                                      u32 *plltype, u32 *n, u32 *m);
+
+extern void ssb_extif_timing_init(struct ssb_extif *extif,
+                                 unsigned long ns);
+
+u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask);
+
+void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value);
+
+void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value);
+
+#ifdef CONFIG_SSB_SERIAL
+extern int ssb_extif_serial_init(struct ssb_extif *extif,
+                                struct ssb_serial_port *ports);
+#endif /* CONFIG_SSB_SERIAL */
+
+
+#else /* CONFIG_SSB_DRIVER_EXTIF */
+/* extif disabled */
+
+struct ssb_extif {
+};
+
+static inline bool ssb_extif_available(struct ssb_extif *extif)
+{
+       return 0;
+}
+
+static inline
+void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
+                               u32 *plltype, u32 *n, u32 *m)
+{
+}
+
+#endif /* CONFIG_SSB_DRIVER_EXTIF */
+#endif /* LINUX_SSB_EXTIFCORE_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_mips.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_mips.h
new file mode 100644 (file)
index 0000000..5f44e97
--- /dev/null
@@ -0,0 +1,46 @@
+#ifndef LINUX_SSB_MIPSCORE_H_
+#define LINUX_SSB_MIPSCORE_H_
+
+#ifdef CONFIG_SSB_DRIVER_MIPS
+
+struct ssb_device;
+
+struct ssb_serial_port {
+       void *regs;
+       unsigned long clockspeed;
+       unsigned int irq;
+       unsigned int baud_base;
+       unsigned int reg_shift;
+};
+
+
+struct ssb_mipscore {
+       struct ssb_device *dev;
+
+       int nr_serial_ports;
+       struct ssb_serial_port serial_ports[4];
+
+       u8 flash_buswidth;
+       u32 flash_window;
+       u32 flash_window_size;
+};
+
+extern void ssb_mipscore_init(struct ssb_mipscore *mcore);
+extern u32 ssb_cpu_clock(struct ssb_mipscore *mcore);
+
+extern unsigned int ssb_mips_irq(struct ssb_device *dev);
+
+
+#else /* CONFIG_SSB_DRIVER_MIPS */
+
+struct ssb_mipscore {
+};
+
+static inline
+void ssb_mipscore_init(struct ssb_mipscore *mcore)
+{
+}
+
+#endif /* CONFIG_SSB_DRIVER_MIPS */
+
+#endif /* LINUX_SSB_MIPSCORE_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_pci.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_driver_pci.h
new file mode 100644 (file)
index 0000000..9cfffb7
--- /dev/null
@@ -0,0 +1,106 @@
+#ifndef LINUX_SSB_PCICORE_H_
+#define LINUX_SSB_PCICORE_H_
+
+#ifdef CONFIG_SSB_DRIVER_PCICORE
+
+/* PCI core registers. */
+#define SSB_PCICORE_CTL                        0x0000  /* PCI Control */
+#define  SSB_PCICORE_CTL_RST_OE                0x00000001 /* PCI_RESET Output Enable */
+#define  SSB_PCICORE_CTL_RST           0x00000002 /* PCI_RESET driven out to pin */
+#define  SSB_PCICORE_CTL_CLK_OE                0x00000004 /* Clock gate Output Enable */
+#define  SSB_PCICORE_CTL_CLK           0x00000008 /* Gate for clock driven out to pin */
+#define SSB_PCICORE_ARBCTL             0x0010  /* PCI Arbiter Control */
+#define  SSB_PCICORE_ARBCTL_INTERN     0x00000001 /* Use internal arbiter */
+#define  SSB_PCICORE_ARBCTL_EXTERN     0x00000002 /* Use external arbiter */
+#define  SSB_PCICORE_ARBCTL_PARKID     0x00000006 /* Mask, selects which agent is parked on an idle bus */
+#define   SSB_PCICORE_ARBCTL_PARKID_LAST       0x00000000 /* Last requestor */
+#define   SSB_PCICORE_ARBCTL_PARKID_4710       0x00000002 /* 4710 */
+#define   SSB_PCICORE_ARBCTL_PARKID_EXT0       0x00000004 /* External requestor 0 */
+#define   SSB_PCICORE_ARBCTL_PARKID_EXT1       0x00000006 /* External requestor 1 */
+#define SSB_PCICORE_ISTAT              0x0020  /* Interrupt status */
+#define  SSB_PCICORE_ISTAT_INTA                0x00000001 /* PCI INTA# */
+#define  SSB_PCICORE_ISTAT_INTB                0x00000002 /* PCI INTB# */
+#define  SSB_PCICORE_ISTAT_SERR                0x00000004 /* PCI SERR# (write to clear) */
+#define  SSB_PCICORE_ISTAT_PERR                0x00000008 /* PCI PERR# (write to clear) */
+#define  SSB_PCICORE_ISTAT_PME         0x00000010 /* PCI PME# */
+#define SSB_PCICORE_IMASK              0x0024  /* Interrupt mask */
+#define  SSB_PCICORE_IMASK_INTA                0x00000001 /* PCI INTA# */
+#define  SSB_PCICORE_IMASK_INTB                0x00000002 /* PCI INTB# */
+#define  SSB_PCICORE_IMASK_SERR                0x00000004 /* PCI SERR# */
+#define  SSB_PCICORE_IMASK_PERR                0x00000008 /* PCI PERR# */
+#define  SSB_PCICORE_IMASK_PME         0x00000010 /* PCI PME# */
+#define SSB_PCICORE_MBOX               0x0028  /* Backplane to PCI Mailbox */
+#define  SSB_PCICORE_MBOX_F0_0         0x00000100 /* PCI function 0, INT 0 */
+#define  SSB_PCICORE_MBOX_F0_1         0x00000200 /* PCI function 0, INT 1 */
+#define  SSB_PCICORE_MBOX_F1_0         0x00000400 /* PCI function 1, INT 0 */
+#define  SSB_PCICORE_MBOX_F1_1         0x00000800 /* PCI function 1, INT 1 */
+#define  SSB_PCICORE_MBOX_F2_0         0x00001000 /* PCI function 2, INT 0 */
+#define  SSB_PCICORE_MBOX_F2_1         0x00002000 /* PCI function 2, INT 1 */
+#define  SSB_PCICORE_MBOX_F3_0         0x00004000 /* PCI function 3, INT 0 */
+#define  SSB_PCICORE_MBOX_F3_1         0x00008000 /* PCI function 3, INT 1 */
+#define SSB_PCICORE_BCAST_ADDR         0x0050  /* Backplane Broadcast Address */
+#define  SSB_PCICORE_BCAST_ADDR_MASK   0x000000FF
+#define SSB_PCICORE_BCAST_DATA         0x0054  /* Backplane Broadcast Data */
+#define SSB_PCICORE_GPIO_IN            0x0060  /* rev >= 2 only */
+#define SSB_PCICORE_GPIO_OUT           0x0064  /* rev >= 2 only */
+#define SSB_PCICORE_GPIO_ENABLE                0x0068  /* rev >= 2 only */
+#define SSB_PCICORE_GPIO_CTL           0x006C  /* rev >= 2 only */
+#define SSB_PCICORE_SBTOPCI0           0x0100  /* Backplane to PCI translation 0 (sbtopci0) */
+#define  SSB_PCICORE_SBTOPCI0_MASK     0xFC000000
+#define SSB_PCICORE_SBTOPCI1           0x0104  /* Backplane to PCI translation 1 (sbtopci1) */
+#define  SSB_PCICORE_SBTOPCI1_MASK     0xFC000000
+#define SSB_PCICORE_SBTOPCI2           0x0108  /* Backplane to PCI translation 2 (sbtopci2) */
+#define  SSB_PCICORE_SBTOPCI2_MASK     0xC0000000
+
+/* SBtoPCIx */
+#define SSB_PCICORE_SBTOPCI_MEM                0x00000000
+#define SSB_PCICORE_SBTOPCI_IO         0x00000001
+#define SSB_PCICORE_SBTOPCI_CFG0       0x00000002
+#define SSB_PCICORE_SBTOPCI_CFG1       0x00000003
+#define SSB_PCICORE_SBTOPCI_PREF       0x00000004 /* Prefetch enable */
+#define SSB_PCICORE_SBTOPCI_BURST      0x00000008 /* Burst enable */
+#define SSB_PCICORE_SBTOPCI_MRM                0x00000020 /* Memory Read Multiple */
+#define SSB_PCICORE_SBTOPCI_RC         0x00000030 /* Read Command mask (rev >= 11) */
+#define  SSB_PCICORE_SBTOPCI_RC_READ   0x00000000 /* Memory read */
+#define  SSB_PCICORE_SBTOPCI_RC_READL  0x00000010 /* Memory read line */
+#define  SSB_PCICORE_SBTOPCI_RC_READM  0x00000020 /* Memory read multiple */
+
+
+/* PCIcore specific boardflags */
+#define SSB_PCICORE_BFL_NOPCI          0x00000400 /* Board leaves PCI floating */
+
+
+struct ssb_pcicore {
+       struct ssb_device *dev;
+       u8 setup_done:1;
+       u8 hostmode:1;
+       u8 cardbusmode:1;
+};
+
+extern void ssb_pcicore_init(struct ssb_pcicore *pc);
+
+/* Enable IRQ routing for a specific device */
+extern int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
+                                         struct ssb_device *dev);
+
+
+#else /* CONFIG_SSB_DRIVER_PCICORE */
+
+
+struct ssb_pcicore {
+};
+
+static inline
+void ssb_pcicore_init(struct ssb_pcicore *pc)
+{
+}
+
+static inline
+int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
+                                  struct ssb_device *dev)
+{
+       return 0;
+}
+
+#endif /* CONFIG_SSB_DRIVER_PCICORE */
+#endif /* LINUX_SSB_PCICORE_H_ */
diff --git a/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_regs.h b/target/linux/generic-2.6/files-2.6.24/include/linux/ssb/ssb_regs.h
new file mode 100644 (file)
index 0000000..ebad0ba
--- /dev/null
@@ -0,0 +1,357 @@
+#ifndef LINUX_SSB_REGS_H_
+#define LINUX_SSB_REGS_H_
+
+
+/* SiliconBackplane Address Map.
+ * All regions may not exist on all chips.
+ */
+#define SSB_SDRAM_BASE         0x00000000U     /* Physical SDRAM */
+#define SSB_PCI_MEM            0x08000000U     /* Host Mode sb2pcitranslation0 (64 MB) */
+#define SSB_PCI_CFG            0x0c000000U     /* Host Mode sb2pcitranslation1 (64 MB) */
+#define        SSB_SDRAM_SWAPPED       0x10000000U     /* Byteswapped Physical SDRAM */
+#define SSB_ENUM_BASE          0x18000000U     /* Enumeration space base */
+#define        SSB_ENUM_LIMIT          0x18010000U     /* Enumeration space limit */
+
+#define        SSB_FLASH2              0x1c000000U     /* Flash Region 2 (region 1 shadowed here) */
+#define        SSB_FLASH2_SZ           0x02000000U     /* Size of Flash Region 2 */
+
+#define        SSB_EXTIF_BASE          0x1f000000U     /* External Interface region base address */
+#define        SSB_FLASH1              0x1fc00000U     /* Flash Region 1 */
+#define        SSB_FLASH1_SZ           0x00400000U     /* Size of Flash Region 1 */
+
+#define SSB_PCI_DMA            0x40000000U     /* Client Mode sb2pcitranslation2 (1 GB) */
+#define SSB_PCI_DMA_SZ         0x40000000U     /* Client Mode sb2pcitranslation2 size in bytes */
+#define SSB_PCIE_DMA_L32       0x00000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), low 32 bits */
+#define SSB_PCIE_DMA_H32       0x80000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), high 32 bits */
+#define        SSB_EUART               (SSB_EXTIF_BASE + 0x00800000)
+#define        SSB_LED                 (SSB_EXTIF_BASE + 0x00900000)
+
+
+/* Enumeration space constants */
+#define SSB_CORE_SIZE          0x1000  /* Size of a core MMIO area */
+#define SSB_MAX_NR_CORES       ((SSB_ENUM_LIMIT - SSB_ENUM_BASE) / SSB_CORE_SIZE)
+
+
+/* mips address */
+#define        SSB_EJTAG               0xff200000      /* MIPS EJTAG space (2M) */
+
+
+/* SSB PCI config space registers. */
+#define SSB_PMCSR              0x44
+#define  SSB_PE                        0x100
+#define        SSB_BAR0_WIN            0x80    /* Backplane address space 0 */
+#define        SSB_BAR1_WIN            0x84    /* Backplane address space 1 */
+#define        SSB_SPROMCTL            0x88    /* SPROM control */
+#define  SSB_SPROMCTL_WE       0x10    /* SPROM write enable */
+#define        SSB_BAR1_CONTROL        0x8c    /* Address space 1 burst control */
+#define SSB_PCI_IRQS           0x90    /* PCI interrupts */
+#define SSB_PCI_IRQMASK                0x94    /* PCI IRQ control and mask (pcirev >= 6 only) */
+#define SSB_BACKPLANE_IRQS     0x98    /* Backplane Interrupts */
+#define SSB_GPIO_IN            0xB0    /* GPIO Input (pcirev >= 3 only) */
+#define SSB_GPIO_OUT           0xB4    /* GPIO Output (pcirev >= 3 only) */
+#define SSB_GPIO_OUT_ENABLE    0xB8    /* GPIO Output Enable/Disable (pcirev >= 3 only) */
+#define  SSB_GPIO_SCS          0x10    /* PCI config space bit 4 for 4306c0 slow clock source */
+#define  SSB_GPIO_HWRAD                0x20    /* PCI config space GPIO 13 for hw radio disable */
+#define  SSB_GPIO_XTAL         0x40    /* PCI config space GPIO 14 for Xtal powerup */
+#define  SSB_GPIO_PLL          0x80    /* PCI config space GPIO 15 for PLL powerdown */
+
+
+#define SSB_BAR0_MAX_RETRIES   50
+
+/* Silicon backplane configuration register definitions */
+#define SSB_IPSFLAG            0x0F08
+#define         SSB_IPSFLAG_IRQ1       0x0000003F /* which sbflags get routed to mips interrupt 1 */
+#define         SSB_IPSFLAG_IRQ1_SHIFT 0
+#define         SSB_IPSFLAG_IRQ2       0x00003F00 /* which sbflags get routed to mips interrupt 2 */
+#define         SSB_IPSFLAG_IRQ2_SHIFT 8
+#define         SSB_IPSFLAG_IRQ3       0x003F0000 /* which sbflags get routed to mips interrupt 3 */
+#define         SSB_IPSFLAG_IRQ3_SHIFT 16
+#define         SSB_IPSFLAG_IRQ4       0x3F000000 /* which sbflags get routed to mips interrupt 4 */
+#define         SSB_IPSFLAG_IRQ4_SHIFT 24
+#define SSB_TPSFLAG            0x0F18
+#define  SSB_TPSFLAG_BPFLAG    0x0000003F /* Backplane flag # */
+#define  SSB_TPSFLAG_ALWAYSIRQ 0x00000040 /* IRQ is always sent on the Backplane */
+#define SSB_TMERRLOGA          0x0F48
+#define SSB_TMERRLOG           0x0F50
+#define SSB_ADMATCH3           0x0F60
+#define SSB_ADMATCH2           0x0F68
+#define SSB_ADMATCH1           0x0F70
+#define SSB_IMSTATE            0x0F90     /* SB Initiator Agent State */
+#define  SSB_IMSTATE_PC                0x0000000f /* Pipe Count */
+#define  SSB_IMSTATE_AP_MASK   0x00000030 /* Arbitration Priority */
+#define  SSB_IMSTATE_AP_BOTH   0x00000000 /* Use both timeslices and token */
+#define  SSB_IMSTATE_AP_TS     0x00000010 /* Use timeslices only */
+#define  SSB_IMSTATE_AP_TK     0x00000020 /* Use token only */
+#define  SSB_IMSTATE_AP_RSV    0x00000030 /* Reserved */
+#define  SSB_IMSTATE_IBE       0x00020000 /* In Band Error */
+#define  SSB_IMSTATE_TO                0x00040000 /* Timeout */
+#define SSB_INTVEC             0x0F94     /* SB Interrupt Mask */
+#define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */
+#define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */
+#define  SSB_INTVEC_ILINE20    0x00000004 /* Enable interrupts for iline20 */
+#define  SSB_INTVEC_CODEC      0x00000008 /* Enable interrupts for v90 codec */
+#define  SSB_INTVEC_USB                0x00000010 /* Enable interrupts for usb */
+#define  SSB_INTVEC_EXTIF      0x00000020 /* Enable interrupts for external i/f */
+#define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */
+#define SSB_TMSLOW             0x0F98     /* SB Target State Low */
+#define  SSB_TMSLOW_RESET      0x00000001 /* Reset */
+#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */
+#define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */
+#define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */
+#define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */
+#define  SSB_TMSLOW_PE         0x40000000 /* Power Management Enable */
+#define  SSB_TMSLOW_BE         0x80000000 /* BIST Enable */
+#define SSB_TMSHIGH            0x0F9C     /* SB Target State High */
+#define  SSB_TMSHIGH_SERR      0x00000001 /* S-error */
+#define  SSB_TMSHIGH_INT       0x00000002 /* Interrupt */
+#define  SSB_TMSHIGH_BUSY      0x00000004 /* Busy */
+#define  SSB_TMSHIGH_TO                0x00000020 /* Timeout. Backplane rev >= 2.3 only */
+#define  SSB_TMSHIGH_COREFL    0x1FFF0000 /* Core specific flags */
+#define  SSB_TMSHIGH_COREFL_SHIFT      16
+#define  SSB_TMSHIGH_DMA64     0x10000000 /* 64bit DMA supported */
+#define  SSB_TMSHIGH_GCR       0x20000000 /* Gated Clock Request */
+#define  SSB_TMSHIGH_BISTF     0x40000000 /* BIST Failed */
+#define  SSB_TMSHIGH_BISTD     0x80000000 /* BIST Done */
+#define SSB_BWA0               0x0FA0
+#define SSB_IMCFGLO            0x0FA8
+#define  SSB_IMCFGLO_SERTO     0x00000007 /* Service timeout */
+#define  SSB_IMCFGLO_REQTO     0x00000070 /* Request timeout */
+#define  SSB_IMCFGLO_REQTO_SHIFT       4
+#define  SSB_IMCFGLO_CONNID    0x00FF0000 /* Connection ID */
+#define  SSB_IMCFGLO_CONNID_SHIFT      16
+#define SSB_IMCFGHI            0x0FAC
+#define SSB_ADMATCH0           0x0FB0
+#define SSB_TMCFGLO            0x0FB8
+#define SSB_TMCFGHI            0x0FBC
+#define SSB_BCONFIG            0x0FC0
+#define SSB_BSTATE             0x0FC8
+#define SSB_ACTCFG             0x0FD8
+#define SSB_FLAGST             0x0FE8
+#define SSB_IDLOW              0x0FF8
+#define  SSB_IDLOW_CFGSP       0x00000003 /* Config Space */
+#define  SSB_IDLOW_ADDRNGE     0x00000038 /* Address Ranges supported */
+#define  SSB_IDLOW_ADDRNGE_SHIFT       3
+#define  SSB_IDLOW_SYNC                0x00000040
+#define  SSB_IDLOW_INITIATOR   0x00000080
+#define  SSB_IDLOW_MIBL                0x00000F00 /* Minimum Backplane latency */
+#define  SSB_IDLOW_MIBL_SHIFT  8
+#define  SSB_IDLOW_MABL                0x0000F000 /* Maximum Backplane latency */
+#define  SSB_IDLOW_MABL_SHIFT  12
+#define  SSB_IDLOW_TIF         0x00010000 /* This Initiator is first */
+#define  SSB_IDLOW_CCW         0x000C0000 /* Cycle counter width */
+#define  SSB_IDLOW_CCW_SHIFT   18
+#define  SSB_IDLOW_TPT         0x00F00000 /* Target ports */
+#define  SSB_IDLOW_TPT_SHIFT   20
+#define  SSB_IDLOW_INITP       0x0F000000 /* Initiator ports */
+#define  SSB_IDLOW_INITP_SHIFT 24
+#define  SSB_IDLOW_SSBREV      0xF0000000 /* Sonics Backplane Revision code */
+#define  SSB_IDLOW_SSBREV_22   0x00000000 /* <= 2.2 */
+#define  SSB_IDLOW_SSBREV_23   0x10000000 /* 2.3 */
+#define  SSB_IDLOW_SSBREV_24   0x40000000 /* ?? Found in BCM4328 */
+#define  SSB_IDLOW_SSBREV_25   0x50000000 /* ?? Not Found yet */
+#define  SSB_IDLOW_SSBREV_26   0x60000000 /* ?? Found in some BCM4311/2 */
+#define  SSB_IDLOW_SSBREV_27   0x70000000 /* ?? Found in some BCM4311/2 */
+#define SSB_IDHIGH             0x0FFC     /* SB Identification High */
+#define  SSB_IDHIGH_RCLO       0x0000000F /* Revision Code (low part) */
+#define  SSB_IDHIGH_CC         0x00008FF0 /* Core Code */
+#define  SSB_IDHIGH_CC_SHIFT   4
+#define  SSB_IDHIGH_RCHI       0x00007000 /* Revision Code (high part) */
+#define  SSB_IDHIGH_RCHI_SHIFT 8          /* yes, shift 8 is right */
+#define  SSB_IDHIGH_VC         0xFFFF0000 /* Vendor Code */
+#define  SSB_IDHIGH_VC_SHIFT   16
+
+/* SPROM shadow area. If not otherwise noted, fields are
+ * two bytes wide. Note that the SPROM can _only_ be read
+ * in two-byte quantinies.
+ */
+#define SSB_SPROMSIZE_WORDS            64
+#define SSB_SPROMSIZE_BYTES            (SSB_SPROMSIZE_WORDS * sizeof(u16))
+#define SSB_SPROMSIZE_WORDS_R123       64
+#define SSB_SPROMSIZE_WORDS_R4         220
+#define SSB_SPROMSIZE_BYTES_R123       (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
+#define SSB_SPROMSIZE_BYTES_R4         (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
+#define SSB_SPROM_BASE                 0x1000
+#define SSB_SPROM_REVISION             0x107E
+#define  SSB_SPROM_REVISION_REV                0x00FF  /* SPROM Revision number */
+#define  SSB_SPROM_REVISION_CRC                0xFF00  /* SPROM CRC8 value */
+#define  SSB_SPROM_REVISION_CRC_SHIFT  8
+
+/* SPROM Revision 1 */
+#define SSB_SPROM1_SPID                        0x1004  /* Subsystem Product ID for PCI */
+#define SSB_SPROM1_SVID                        0x1006  /* Subsystem Vendor ID for PCI */
+#define SSB_SPROM1_PID                 0x1008  /* Product ID for PCI */
+#define SSB_SPROM1_IL0MAC              0x1048  /* 6 bytes MAC address for 802.11b/g */
+#define SSB_SPROM1_ET0MAC              0x104E  /* 6 bytes MAC address for Ethernet */
+#define SSB_SPROM1_ET1MAC              0x1054  /* 6 bytes MAC address for 802.11a */
+#define SSB_SPROM1_ETHPHY              0x105A  /* Ethernet PHY settings */
+#define  SSB_SPROM1_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */
+#define  SSB_SPROM1_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */
+#define  SSB_SPROM1_ETHPHY_ET1A_SHIFT  5
+#define  SSB_SPROM1_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */
+#define  SSB_SPROM1_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */
+#define SSB_SPROM1_BINF                        0x105C  /* Board info */
+#define  SSB_SPROM1_BINF_BREV          0x00FF  /* Board Revision */
+#define  SSB_SPROM1_BINF_CCODE         0x0F00  /* Country Code */
+#define  SSB_SPROM1_BINF_CCODE_SHIFT   8
+#define  SSB_SPROM1_BINF_ANTBG         0x3000  /* Available B-PHY and G-PHY antennas */
+#define  SSB_SPROM1_BINF_ANTBG_SHIFT   12
+#define  SSB_SPROM1_BINF_ANTA          0xC000  /* Available A-PHY antennas */
+#define  SSB_SPROM1_BINF_ANTA_SHIFT    14
+#define SSB_SPROM1_PA0B0               0x105E
+#define SSB_SPROM1_PA0B1               0x1060
+#define SSB_SPROM1_PA0B2               0x1062
+#define SSB_SPROM1_GPIOA               0x1064  /* General Purpose IO pins 0 and 1 */
+#define  SSB_SPROM1_GPIOA_P0           0x00FF  /* Pin 0 */
+#define  SSB_SPROM1_GPIOA_P1           0xFF00  /* Pin 1 */
+#define  SSB_SPROM1_GPIOA_P1_SHIFT     8
+#define SSB_SPROM1_GPIOB               0x1066  /* General Purpuse IO pins 2 and 3 */
+#define  SSB_SPROM1_GPIOB_P2           0x00FF  /* Pin 2 */
+#define  SSB_SPROM1_GPIOB_P3           0xFF00  /* Pin 3 */
+#define  SSB_SPROM1_GPIOB_P3_SHIFT     8
+#define SSB_SPROM1_MAXPWR              0x1068  /* Power Amplifier Max Power */
+#define  SSB_SPROM1_MAXPWR_BG          0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */
+#define  SSB_SPROM1_MAXPWR_A           0xFF00  /* A-PHY (in dBm Q5.2) */
+#define  SSB_SPROM1_MAXPWR_A_SHIFT     8
+#define SSB_SPROM1_PA1B0               0x106A
+#define SSB_SPROM1_PA1B1               0x106C
+#define SSB_SPROM1_PA1B2               0x106E
+#define SSB_SPROM1_ITSSI               0x1070  /* Idle TSSI Target */
+#define  SSB_SPROM1_ITSSI_BG           0x00FF  /* B-PHY and G-PHY*/
+#define  SSB_SPROM1_ITSSI_A            0xFF00  /* A-PHY */
+#define  SSB_SPROM1_ITSSI_A_SHIFT      8
+#define SSB_SPROM1_BFLLO               0x1072  /* Boardflags (low 16 bits) */
+#define SSB_SPROM1_AGAIN               0x1074  /* Antenna Gain (in dBm Q5.2) */
+#define  SSB_SPROM1_AGAIN_BG           0x00FF  /* B-PHY and G-PHY */
+#define  SSB_SPROM1_AGAIN_BG_SHIFT     0
+#define  SSB_SPROM1_AGAIN_A            0xFF00  /* A-PHY */
+#define  SSB_SPROM1_AGAIN_A_SHIFT      8
+
+/* SPROM Revision 2 (inherits from rev 1) */
+#define SSB_SPROM2_BFLHI               0x1038  /* Boardflags (high 16 bits) */
+#define SSB_SPROM2_MAXP_A              0x103A  /* A-PHY Max Power */
+#define  SSB_SPROM2_MAXP_A_HI          0x00FF  /* Max Power High */
+#define  SSB_SPROM2_MAXP_A_LO          0xFF00  /* Max Power Low */
+#define  SSB_SPROM2_MAXP_A_LO_SHIFT    8
+#define SSB_SPROM2_PA1LOB0             0x103C  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1LOB1             0x103E  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1LOB2             0x1040  /* A-PHY PowerAmplifier Low Settings */
+#define SSB_SPROM2_PA1HIB0             0x1042  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_PA1HIB1             0x1044  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_PA1HIB2             0x1046  /* A-PHY PowerAmplifier High Settings */
+#define SSB_SPROM2_OPO                 0x1078  /* OFDM Power Offset from CCK Level */
+#define  SSB_SPROM2_OPO_VALUE          0x00FF
+#define  SSB_SPROM2_OPO_UNUSED         0xFF00
+#define SSB_SPROM2_CCODE               0x107C  /* Two char Country Code */
+
+/* SPROM Revision 3 (inherits most data from rev 2) */
+#define SSB_SPROM3_IL0MAC              0x104A  /* 6 bytes MAC address for 802.11b/g */
+#define SSB_SPROM3_ET0MAC              0x1050  /* 6 bytes MAC address for Ethernet ?? */
+#define SSB_SPROM3_ET1MAC              0x1050  /* 6 bytes MAC address for 802.11a ?? */
+#define SSB_SPROM3_OFDMAPO             0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_OFDMALPO            0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_OFDMAHPO            0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */
+#define SSB_SPROM3_GPIOLDC             0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */
+#define  SSB_SPROM3_GPIOLDC_OFF                0x0000FF00      /* Off Count */
+#define  SSB_SPROM3_GPIOLDC_OFF_SHIFT  8
+#define  SSB_SPROM3_GPIOLDC_ON         0x00FF0000      /* On Count */
+#define  SSB_SPROM3_GPIOLDC_ON_SHIFT   16
+#define SSB_SPROM3_CCKPO               0x1078  /* CCK Power Offset */
+#define  SSB_SPROM3_CCKPO_1M           0x000F  /* 1M Rate PO */
+#define  SSB_SPROM3_CCKPO_2M           0x00F0  /* 2M Rate PO */
+#define  SSB_SPROM3_CCKPO_2M_SHIFT     4
+#define  SSB_SPROM3_CCKPO_55M          0x0F00  /* 5.5M Rate PO */
+#define  SSB_SPROM3_CCKPO_55M_SHIFT    8
+#define  SSB_SPROM3_CCKPO_11M          0xF000  /* 11M Rate PO */
+#define  SSB_SPROM3_CCKPO_11M_SHIFT    12
+#define  SSB_SPROM3_OFDMGPO            0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */
+
+/* SPROM Revision 4 */
+#define SSB_SPROM4_IL0MAC              0x104C  /* 6 byte MAC address for a/b/g/n */
+#define SSB_SPROM4_ET0MAC              0x1018  /* 6 bytes MAC address for Ethernet ?? */
+#define SSB_SPROM4_ET1MAC              0x1018  /* 6 bytes MAC address for 802.11a ?? */
+#define SSB_SPROM4_ETHPHY              0x105A  /* Ethernet PHY settings ?? */
+#define  SSB_SPROM4_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */
+#define  SSB_SPROM4_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */
+#define  SSB_SPROM4_ETHPHY_ET1A_SHIFT  5
+#define  SSB_SPROM4_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */
+#define  SSB_SPROM4_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */
+#define SSB_SPROM4_CCODE               0x1052  /* Country Code (2 bytes) */
+#define SSB_SPROM4_ANTAVAIL            0x105D  /* Antenna available bitfields */
+#define SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */
+#define SSB_SPROM4_ANTAVAIL_A_SHIFT    0
+#define SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */
+#define SSB_SPROM4_ANTAVAIL_BG_SHIFT   8
+#define SSB_SPROM4_BFLLO               0x1044  /* Boardflags (low 16 bits) */
+#define SSB_SPROM4_AGAIN01             0x105E  /* Antenna Gain (in dBm Q5.2) */
+#define  SSB_SPROM4_AGAIN0             0x00FF  /* Antenna 0 */
+#define  SSB_SPROM4_AGAIN0_SHIFT       0
+#define  SSB_SPROM4_AGAIN1             0xFF00  /* Antenna 1 */
+#define  SSB_SPROM4_AGAIN1_SHIFT       8
+#define SSB_SPROM4_AGAIN23             0x1060
+#define  SSB_SPROM4_AGAIN2             0x00FF  /* Antenna 2 */
+#define  SSB_SPROM4_AGAIN2_SHIFT       0
+#define  SSB_SPROM4_AGAIN3             0xFF00  /* Antenna 3 */
+#define  SSB_SPROM4_AGAIN3_SHIFT       8
+#define SSB_SPROM4_BFLHI               0x1046  /* Board Flags Hi */
+#define SSB_SPROM4_MAXP_BG             0x1080  /* Max Power BG in path 1 */
+#define  SSB_SPROM4_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */
+#define  SSB_SPROM4_ITSSI_BG           0xFF00  /* Mask for path 1 itssi_bg */
+#define  SSB_SPROM4_ITSSI_BG_SHIFT     8
+#define SSB_SPROM4_MAXP_A              0x108A  /* Max Power A in path 1 */
+#define  SSB_SPROM4_MAXP_A_MASK                0x00FF  /* Mask for Max Power A */
+#define  SSB_SPROM4_ITSSI_A            0xFF00  /* Mask for path 1 itssi_a */
+#define  SSB_SPROM4_ITSSI_A_SHIFT      8
+#define SSB_SPROM4_GPIOA               0x1056  /* Gen. Purpose IO # 0 and 1 */
+#define  SSB_SPROM4_GPIOA_P0           0x00FF  /* Pin 0 */
+#define  SSB_SPROM4_GPIOA_P1           0xFF00  /* Pin 1 */
+#define  SSB_SPROM4_GPIOA_P1_SHIFT     8
+#define SSB_SPROM4_GPIOB               0x1058  /* Gen. Purpose IO # 2 and 3 */
+#define  SSB_SPROM4_GPIOB_P2           0x00FF  /* Pin 2 */
+#define  SSB_SPROM4_GPIOB_P3           0xFF00  /* Pin 3 */
+#define  SSB_SPROM4_GPIOB_P3_SHIFT     8
+#define SSB_SPROM4_PA0B0               0x1082  /* The paXbY locations are */
+#define SSB_SPROM4_PA0B1               0x1084  /*   only guesses */
+#define SSB_SPROM4_PA0B2               0x1086
+#define SSB_SPROM4_PA1B0               0x108E
+#define SSB_SPROM4_PA1B1               0x1090
+#define SSB_SPROM4_PA1B2               0x1092
+
+/* Values for SSB_SPROM1_BINF_CCODE */
+enum {
+       SSB_SPROM1CCODE_WORLD = 0,
+       SSB_SPROM1CCODE_THAILAND,
+       SSB_SPROM1CCODE_ISRAEL,
+       SSB_SPROM1CCODE_JORDAN,
+       SSB_SPROM1CCODE_CHINA,
+       SSB_SPROM1CCODE_JAPAN,
+       SSB_SPROM1CCODE_USA_CANADA_ANZ,
+       SSB_SPROM1CCODE_EUROPE,
+       SSB_SPROM1CCODE_USA_LOW,
+       SSB_SPROM1CCODE_JAPAN_HIGH,
+       SSB_SPROM1CCODE_ALL,
+       SSB_SPROM1CCODE_NONE,
+};
+
+/* Address-Match values and masks (SSB_ADMATCHxxx) */
+#define SSB_ADM_TYPE                   0x00000003      /* Address type */
+#define  SSB_ADM_TYPE0                 0
+#define  SSB_ADM_TYPE1                 1
+#define  SSB_ADM_TYPE2                 2
+#define SSB_ADM_AD64                   0x00000004
+#define SSB_ADM_SZ0                    0x000000F8      /* Type0 size */
+#define SSB_ADM_SZ0_SHIFT              3
+#define SSB_ADM_SZ1                    0x000001F8      /* Type1 size */
+#define SSB_ADM_SZ1_SHIFT              3
+#define SSB_ADM_SZ2                    0x000001F8      /* Type2 size */
+#define SSB_ADM_SZ2_SHIFT              3
+#define SSB_ADM_EN                     0x00000400      /* Enable */
+#define SSB_ADM_NEG                    0x00000800      /* Negative decode */
+#define SSB_ADM_BASE0                  0xFFFFFF00      /* Type0 base address */
+#define SSB_ADM_BASE0_SHIFT            8
+#define SSB_ADM_BASE1                  0xFFFFF000      /* Type1 base address for the core */
+#define SSB_ADM_BASE1_SHIFT            12
+#define SSB_ADM_BASE2                  0xFFFF0000      /* Type2 base address for the core */
+#define SSB_ADM_BASE2_SHIFT            16
+
+
+#endif /* LINUX_SSB_REGS_H_ */
diff --git a/target/linux/generic-2.6/files/drivers/char/gpio_dev.c b/target/linux/generic-2.6/files/drivers/char/gpio_dev.c
deleted file mode 100644 (file)
index 4dc6374..0000000
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * character device wrapper for generic gpio layer
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA02111-1307USA
- *
- * Feedback, Bugs...  blogic@openwrt.org
- *
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <asm/uaccess.h>
-#include <asm/io.h>
-#include <asm/gpio.h>
-#include <asm/atomic.h>
-#include <linux/init.h>
-#include <linux/genhd.h>
-#include <linux/device.h>
-#include <linux/platform_device.h>
-#include <linux/gpio_dev.h>
-
-#define DRVNAME                "gpiodev"
-#define DEVNAME                "gpio"
-
-static int dev_major;
-static unsigned int gpio_access_mask;
-static struct class *gpiodev_class;
-
-/* Counter is 1, if the device is not opened and zero (or less) if opened. */
-static atomic_t gpio_open_cnt = ATOMIC_INIT(1);
-
-static int
-gpio_ioctl(struct inode * inode, struct file * file, unsigned int cmd, unsigned long arg)
-{
-       int retval = 0;
-
-       if (((1 << arg) & gpio_access_mask) != (1 << arg))
-       {
-               retval = -EINVAL;
-               goto out;
-       }
-
-       switch (cmd)
-       {
-       case GPIO_GET:
-               retval = gpio_get_value(arg);
-               break;
-
-       case GPIO_SET:
-               gpio_set_value(arg, 1);
-               break;
-
-       case GPIO_CLEAR:
-               gpio_set_value(arg, 0);
-               break;
-
-       case GPIO_DIR_IN:
-               gpio_direction_input(arg);
-               break;
-
-       case GPIO_DIR_OUT:
-               gpio_direction_output(arg, 0);
-               break;
-
-       default:
-               retval = -EINVAL;
-               break;
-       }
-
-out:
-       return retval;
-}
-
-static int
-gpio_open(struct inode *inode, struct file *file)
-{
-       int result = 0;
-       unsigned int dev_minor = MINOR(inode->i_rdev);
-
-       if (dev_minor != 0)
-       {
-               printk(KERN_ERR DRVNAME ": trying to access unknown minor device -> %d\n", dev_minor);
-               result = -ENODEV;
-               goto out;
-       }
-
-       /* FIXME: We should really allow multiple applications to open the device
-        *        at the same time, as long as the apps access different IO pins.
-        *        The generic gpio-registration functions can be used for that.
-        *        Two new IOCTLs have to be introduced for that. Need to check userspace
-        *        compatibility first. --mb */
-       if (!atomic_dec_and_test(&gpio_open_cnt)) {
-               atomic_inc(&gpio_open_cnt);
-               printk(KERN_ERR DRVNAME ": Device with minor ID %d already in use\n", dev_minor);
-               result = -EBUSY;
-               goto out;
-       }
-
-out:
-       return result;
-}
-
-static int
-gpio_close(struct inode * inode, struct file * file)
-{
-       smp_mb__before_atomic_inc();
-       atomic_inc(&gpio_open_cnt);
-
-       return 0;
-}
-
-struct file_operations gpio_fops = {
-       ioctl:          gpio_ioctl,
-       open:           gpio_open,
-       release:        gpio_close
-};
-
-static int
-gpio_probe(struct platform_device *dev)
-{
-       int result = 0;
-
-       dev_major = register_chrdev(0, DEVNAME, &gpio_fops);
-       if (!dev_major)
-       {
-               printk(KERN_ERR DRVNAME ": Error whilst opening %s \n", DEVNAME);
-               result = -ENODEV;
-               goto out;
-       }
-
-       gpiodev_class = class_create(THIS_MODULE, DRVNAME);
-       class_device_create(gpiodev_class, NULL, MKDEV(dev_major, 0), NULL, DEVNAME);
-
-       printk(KERN_INFO DRVNAME ": gpio device registered with major %d\n", dev_major);
-
-       if (dev->num_resources != 1)
-       {
-               printk(KERN_ERR DRVNAME ": device may only have 1 resource\n");
-               result = -ENODEV;
-               goto out;
-       }
-
-       gpio_access_mask = dev->resource[0].start;
-
-       printk(KERN_INFO DRVNAME ": gpio platform device registered with access mask %08X\n", gpio_access_mask);
-out:
-       return result;
-}
-
-static int
-gpio_remove(struct platform_device *dev)
-{
-       unregister_chrdev(dev_major, DEVNAME);
-       return 0;
-}
-
-static struct
-platform_driver gpio_driver = {
-       .probe = gpio_probe,
-       .remove = gpio_remove,
-       .driver = {
-               .name = "GPIODEV",
-               .owner = THIS_MODULE,
-       },
-};
-
-static int __init
-gpio_mod_init(void)
-{
-       int ret = platform_driver_register(&gpio_driver);
-       if (ret)
-               printk(KERN_INFO DRVNAME ": Error registering platfom driver!");
-
-       return ret;
-}
-
-static void __exit
-gpio_mod_exit(void)
-{
-       platform_driver_unregister(&gpio_driver);
-}
-
-module_init (gpio_mod_init);
-module_exit (gpio_mod_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("John Crispin / OpenWrt");
-MODULE_DESCRIPTION("Character device for for generic gpio api");
diff --git a/target/linux/generic-2.6/files/drivers/input/misc/gpio_buttons.c b/target/linux/generic-2.6/files/drivers/input/misc/gpio_buttons.c
deleted file mode 100644 (file)
index 83a8178..0000000
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- *  Driver for buttons on GPIO lines not capable of generating interrupts
- *
- *  Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
- *
- *  This file was based on: /drivers/input/misc/cobalt_btns.c
- *     Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
- *
- *  also was based on: /drivers/input/keyboard/gpio_keys.c
- *     Copyright 2005 Phil Blundell
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-
-#include <linux/input.h>
-#include <linux/input-polldev.h>
-#include <linux/ioport.h>
-#include <linux/platform_device.h>
-
-#include <linux/gpio_buttons.h>
-
-#include <asm/gpio.h>
-
-#define DRV_NAME       "gpio-buttons"
-#define DRV_VERSION    "0.1.1"
-#define PFX            DRV_NAME ": "
-
-struct gpio_buttons_dev {
-       struct input_polled_dev *poll_dev;
-       struct gpio_buttons_platform_data *pdata;
-};
-
-static void gpio_buttons_poll(struct input_polled_dev *dev)
-{
-       struct gpio_buttons_dev *bdev = dev->private;
-       struct gpio_buttons_platform_data *pdata = bdev->pdata;
-       struct input_dev *input = dev->input;
-       int i;
-
-       for (i = 0; i < bdev->pdata->nbuttons; i++) {
-               struct gpio_button *button = &pdata->buttons[i];
-               unsigned int type = button->type ?: EV_KEY;
-               int state;
-
-               state = gpio_get_value(button->gpio) ? 1 : 0;
-               state ^= button->active_low;
-
-               if (state) {
-                       button->count++;
-               } else {
-                       if (button->count >= button->threshold) {
-                               input_event(input, type, button->code, 1);
-                               input_sync(input);
-                       }
-                       button->count = 0;
-               }
-
-               if (button->count == button->threshold) {
-                       input_event(input, type, button->code, 0);
-                       input_sync(input);
-               }
-       }
-}
-
-static int __devinit gpio_buttons_probe(struct platform_device *pdev)
-{
-       struct gpio_buttons_platform_data *pdata = pdev->dev.platform_data;
-       struct gpio_buttons_dev *bdev;
-       struct input_polled_dev *poll_dev;
-       struct input_dev *input;
-       int error, i;
-
-
-       if (!pdata)
-               return -ENXIO;
-
-       bdev = kzalloc(sizeof(*bdev), GFP_KERNEL);
-       if (!bdev) {
-               printk(KERN_ERR DRV_NAME "no memory for device\n");
-               return -ENOMEM;
-       }
-
-       poll_dev = input_allocate_polled_device();
-       if (!poll_dev) {
-               printk(KERN_ERR DRV_NAME "no memory for polled device\n");
-               error = -ENOMEM;
-               goto err_free_bdev;
-       }
-
-       poll_dev->private = bdev;
-       poll_dev->poll = gpio_buttons_poll;
-       poll_dev->poll_interval = pdata->poll_interval;
-
-       input = poll_dev->input;
-
-       input->evbit[0] = BIT(EV_KEY);
-       input->name = pdev->name;
-       input->phys = "gpio-buttons/input0";
-       input->dev.parent = &pdev->dev;
-
-       input->id.bustype = BUS_HOST;
-       input->id.vendor = 0x0001;
-       input->id.product = 0x0001;
-       input->id.version = 0x0100;
-
-       for (i = 0; i < pdata->nbuttons; i++) {
-               struct gpio_button *button = &pdata->buttons[i];
-               unsigned int gpio = button->gpio;
-               unsigned int type = button->type ?: EV_KEY;
-
-               error = gpio_request(gpio, button->desc ?
-                               button->desc : DRV_NAME);
-               if (error) {
-                       printk(KERN_ERR PFX "unable to claim gpio %u, "
-                               "error %d\n", gpio, error);
-                       goto err_free_gpio;
-               }
-
-               error = gpio_direction_input(gpio);
-               if (error) {
-                       printk(KERN_ERR PFX "unable to set direction on "
-                               "gpio %u, error %d\n", gpio, error);
-                       goto err_free_gpio;
-               }
-
-               input_set_capability(input, type, button->code);
-               button->count = 0;
-       }
-
-       bdev->poll_dev = poll_dev;
-       bdev->pdata = pdata;
-       platform_set_drvdata(pdev, bdev);
-
-       error = input_register_polled_device(poll_dev);
-       if (error) {
-               printk(KERN_ERR PFX "unable to register polled device, "
-                       "error %d\n", error);
-               goto err_free_gpio;
-       }
-
-       return 0;
-
-err_free_gpio:
-       for (i = i - 1; i >= 0; i--)
-               gpio_free(pdata->buttons[i].gpio);
-
-       input_free_polled_device(poll_dev);
-
-err_free_bdev:
-       kfree(bdev);
-
-       platform_set_drvdata(pdev, NULL);
-       return error;
-}
-
-static int __devexit gpio_buttons_remove(struct platform_device *pdev)
-{
-       struct gpio_buttons_dev *bdev = platform_get_drvdata(pdev);
-       struct gpio_buttons_platform_data *pdata = bdev->pdata;
-       int i;
-
-       input_unregister_polled_device(bdev->poll_dev);
-
-       for (i = 0; i < pdata->nbuttons; i++)
-               gpio_free(pdata->buttons[i].gpio);
-
-       input_free_polled_device(bdev->poll_dev);
-
-       kfree(bdev);
-       platform_set_drvdata(pdev, NULL);
-
-       return 0;
-}
-
-static struct platform_driver gpio_buttons_driver = {
-       .probe  = gpio_buttons_probe,
-       .remove = __devexit_p(gpio_buttons_remove),
-       .driver = {
-               .name   = DRV_NAME,
-               .owner  = THIS_MODULE,
-       },
-};
-
-static int __init gpio_buttons_init(void)
-{
-       printk(KERN_INFO DRV_NAME " driver version " DRV_VERSION "\n");
-       return platform_driver_register(&gpio_buttons_driver);
-}
-
-static void __exit gpio_buttons_exit(void)
-{
-       platform_driver_unregister(&gpio_buttons_driver);
-}
-
-module_init(gpio_buttons_init);
-module_exit(gpio_buttons_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
-MODULE_VERSION(DRV_VERSION);
-MODULE_DESCRIPTION("Polled buttons driver for CPU GPIOs");
-
diff --git a/target/linux/generic-2.6/files/drivers/leds/leds-alix.c b/target/linux/generic-2.6/files/drivers/leds/leds-alix.c
deleted file mode 100644 (file)
index 103ca7d..0000000
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * LEDs driver for PCEngines ALIX 2/3 series
- *
- * Copyright (C) 2007 Petr Liebman
- *
- * Based on leds-wrap.c
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/platform_device.h>
-#include <linux/leds.h>
-#include <linux/err.h>
-#include <asm/io.h>
-
-#define DRVNAME "alix-led"
-
-#define ALIX_LED1_PORT         (0x6100)
-#define ALIX_LED1_ON           (1<<22)
-#define ALIX_LED1_OFF          (1<<6)
-
-#define ALIX_LED2_PORT         (0x6180)
-#define ALIX_LED2_ON           (1<<25)
-#define ALIX_LED2_OFF          (1<<9)
-
-#define ALIX_LED3_PORT         (0x6180)
-#define ALIX_LED3_ON           (1<<27)
-#define ALIX_LED3_OFF          (1<<11)
-
-
-static struct platform_device *pdev;
-
-static void alix_led_set_1(struct led_classdev *led_cdev,
-               enum led_brightness value)
-{
-       if (value)
-               outl(ALIX_LED1_ON, ALIX_LED1_PORT);
-       else
-               outl(ALIX_LED1_OFF, ALIX_LED1_PORT);
-}
-
-static void alix_led_set_2(struct led_classdev *led_cdev,
-               enum led_brightness value)
-{
-       if (value)
-               outl(ALIX_LED2_ON, ALIX_LED2_PORT);
-       else
-               outl(ALIX_LED2_OFF, ALIX_LED2_PORT);
-}
-
-static void alix_led_set_3(struct led_classdev *led_cdev,
-               enum led_brightness value)
-{
-       if (value)
-               outl(ALIX_LED3_ON, ALIX_LED3_PORT);
-       else
-               outl(ALIX_LED3_OFF, ALIX_LED3_PORT);
-}
-
-static struct led_classdev alix_led_1 = {
-       .name           = "alix:1",
-       .brightness_set = alix_led_set_1,
-};
-
-static struct led_classdev alix_led_2 = {
-       .name           = "alix:2",
-       .brightness_set = alix_led_set_2,
-};
-
-static struct led_classdev alix_led_3 = {
-       .name           = "alix:3",
-       .brightness_set = alix_led_set_3,
-};
-
-
-#ifdef CONFIG_PM
-static int alix_led_suspend(struct platform_device *dev,
-               pm_message_t state)
-{
-       led_classdev_suspend(&alix_led_1);
-       led_classdev_suspend(&alix_led_2);
-       led_classdev_suspend(&alix_led_3);
-       return 0;
-}
-
-static int alix_led_resume(struct platform_device *dev)
-{
-       led_classdev_resume(&alix_led_1);
-       led_classdev_resume(&alix_led_2);
-       led_classdev_resume(&alix_led_3);
-       return 0;
-}
-#else
-#define alix_led_suspend NULL
-#define alix_led_resume NULL
-#endif
-
-static int alix_led_probe(struct platform_device *pdev)
-{
-       int ret;
-
-       ret = led_classdev_register(&pdev->dev, &alix_led_1);
-       if (ret >= 0)
-       {
-               ret = led_classdev_register(&pdev->dev, &alix_led_2);
-               if (ret >= 0)
-               {
-                       ret = led_classdev_register(&pdev->dev, &alix_led_3);
-                       if (ret < 0)
-                               led_classdev_unregister(&alix_led_2);
-               }
-               if (ret < 0)
-                       led_classdev_unregister(&alix_led_1);
-       }
-       return ret;
-}
-
-static int alix_led_remove(struct platform_device *pdev)
-{
-       led_classdev_unregister(&alix_led_1);
-       led_classdev_unregister(&alix_led_2);
-       led_classdev_unregister(&alix_led_3);
-       return 0;
-}
-
-static struct platform_driver alix_led_driver = {
-       .probe          = alix_led_probe,
-       .remove         = alix_led_remove,
-       .suspend        = alix_led_suspend,
-       .resume         = alix_led_resume,
-       .driver         = {
-               .name           = DRVNAME,
-               .owner          = THIS_MODULE,
-       },
-};
-
-static int __init alix_led_init(void)
-{
-       int ret;
-
-       ret = platform_driver_register(&alix_led_driver);
-       if (ret < 0)
-               goto out;
-
-       pdev = platform_device_register_simple(DRVNAME, -1, NULL, 0);
-       if (IS_ERR(pdev)) {
-               ret = PTR_ERR(pdev);
-               platform_driver_unregister(&alix_led_driver);
-               goto out;
-       }
-
-out:
-       return ret;
-}
-
-static void __exit alix_led_exit(void)
-{
-       platform_device_unregister(pdev);
-       platform_driver_unregister(&alix_led_driver);
-}
-
-module_init(alix_led_init);
-module_exit(alix_led_exit);
-
-MODULE_AUTHOR("Petr Liebman");
-MODULE_DESCRIPTION("PCEngines ALIX LED driver");
-MODULE_LICENSE("GPL");
-
diff --git a/target/linux/generic-2.6/files/drivers/leds/ledtrig-default-on.c b/target/linux/generic-2.6/files/drivers/leds/ledtrig-default-on.c
deleted file mode 100644 (file)
index 92995e4..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * LED Kernel Default ON Trigger
- *
- * Copyright 2008 Nick Forbes <nick.forbes@incepta.com>
- *
- * Based on Richard Purdie's ledtrig-timer.c.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/leds.h>
-#include "leds.h"
-
-static void defon_trig_activate(struct led_classdev *led_cdev)
-{
-       led_set_brightness(led_cdev, LED_FULL);
-}
-
-static struct led_trigger defon_led_trigger = {
-       .name     = "default-on",
-       .activate = defon_trig_activate,
-};
-
-static int __init defon_trig_init(void)
-{
-       return led_trigger_register(&defon_led_trigger);
-}
-
-static void __exit defon_trig_exit(void)
-{
-       led_trigger_unregister(&defon_led_trigger);
-}
-
-module_init(defon_trig_init);
-module_exit(defon_trig_exit);
-
-MODULE_AUTHOR("Nick Forbes <nick.forbes@incepta.com>");
-MODULE_DESCRIPTION("Default-ON LED trigger");
-MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files/drivers/leds/ledtrig-morse.c b/target/linux/generic-2.6/files/drivers/leds/ledtrig-morse.c
deleted file mode 100644 (file)
index cb47480..0000000
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
- *  LED Morse Trigger
- *
- *  Copyright (C) 2007 Gabor Juhos <juhosg at openwrt.org>
- *
- *  This file was based on: drivers/led/ledtrig-timer.c
- *     Copyright 2005-2006 Openedhand Ltd.
- *     Author: Richard Purdie <rpurdie@openedhand.com>
- *
- *  also based on the patch '[PATCH] 2.5.59 morse code panics' posted
- *  in the LKML by Tomas Szepe at Thu, 30 Jan 2003
- *     Copyright (C) 2002 Andrew Rodland <arodland@noln.com>
- *     Copyright (C) 2003 Tomas Szepe <szepe@pinerecords.com>
- *
- *  This program is free software; you can redistribute it and/or modify it
- *  under the terms of the GNU General Public License version 2 as published
- *  by the Free Software Foundation.
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/version.h>
-#include <linux/module.h>
-#include <linux/jiffies.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/device.h>
-#include <linux/sysdev.h>
-#include <linux/timer.h>
-#include <linux/ctype.h>
-#include <linux/leds.h>
-
-#include "leds.h"
-
-#define MORSE_DELAY_BASE       (HZ/2)
-
-#define MORSE_STATE_BLINK_START        0
-#define MORSE_STATE_BLINK_STOP 1
-
-#define MORSE_DIT_LEN  1
-#define MORSE_DAH_LEN  3
-#define MORSE_SPACE_LEN        7
-
-struct morse_trig_data {
-       unsigned long delay;
-       char *msg;
-
-       unsigned char morse;
-       unsigned char state;
-       char *msgpos;
-       struct timer_list timer;
-};
-
-const unsigned char morsetable[] = {
-       0122, 0, 0310, 0, 0, 0163,                              /* "#$%&' */
-       055, 0155, 0, 0, 0163, 0141, 0152, 0051,                /* ()*+,-./ */
-       077, 076, 074, 070, 060, 040, 041, 043, 047, 057,       /* 0-9 */
-       0107, 0125, 0, 0061, 0, 0114, 0,                        /* :;<=>?@ */
-       006, 021, 025, 011, 002, 024, 013, 020, 004,            /* A-I */
-       036, 015, 022, 007, 005, 017, 026, 033, 012,            /* J-R */
-       010, 003, 014, 030, 016, 031, 035, 023,                 /* S-Z */
-       0, 0, 0, 0, 0154                                        /* [\]^_ */
-};
-
-static inline unsigned char tomorse(char c) {
-       if (c >= 'a' && c <= 'z')
-               c = c - 'a' + 'A';
-       if (c >= '"' && c <= '_') {
-               return morsetable[c - '"'];
-       } else
-               return 0;
-}
-
-static inline unsigned long dit_len(struct morse_trig_data *morse_data)
-{
-       return MORSE_DIT_LEN*morse_data->delay;
-}
-
-static inline unsigned long dah_len(struct morse_trig_data *morse_data)
-{
-       return MORSE_DAH_LEN*morse_data->delay;
-}
-
-static inline unsigned long space_len(struct morse_trig_data *morse_data)
-{
-       return MORSE_SPACE_LEN*morse_data->delay;
-}
-
-static void morse_timer_function(unsigned long data)
-{
-       struct led_classdev *led_cdev = (struct led_classdev *)data;
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-       unsigned long brightness = LED_OFF;
-       unsigned long delay = 0;
-
-       if (!morse_data->msg)
-               goto set_led;
-
-       switch (morse_data->state) {
-       case MORSE_STATE_BLINK_START:
-               /* Starting a new blink.  We have a valid code in morse. */
-               delay = (morse_data->morse & 001) ? dah_len(morse_data):
-                       dit_len(morse_data);
-               brightness = LED_FULL;
-               morse_data->state = MORSE_STATE_BLINK_STOP;
-               morse_data->morse >>= 1;
-               break;
-       case MORSE_STATE_BLINK_STOP:
-               /* Coming off of a blink. */
-               morse_data->state = MORSE_STATE_BLINK_START;
-
-               if (morse_data->morse > 1) {
-                       /* Not done yet, just a one-dit pause. */
-                       delay = dit_len(morse_data);
-                       break;
-               }
-
-               /* Get a new char, figure out how much space. */
-               /* First time through */
-               if (!morse_data->msgpos)
-                       morse_data->msgpos = (char *)morse_data->msg;
-
-               if (!*morse_data->msgpos) {
-                       /* Repeating */
-                       morse_data->msgpos = (char *)morse_data->msg;
-                       delay = space_len(morse_data);
-               } else {
-                       /* Inter-letter space */
-                       delay = dah_len(morse_data);
-               }
-
-               if (!(morse_data->morse = tomorse(*morse_data->msgpos))) {
-                       delay = space_len(morse_data);
-                       /* And get us back here */
-                       morse_data->state = MORSE_STATE_BLINK_STOP;
-               }
-               morse_data->msgpos++;
-               break;
-       }
-
-       mod_timer(&morse_data->timer, jiffies + msecs_to_jiffies(delay));
-
-set_led:
-       led_set_brightness(led_cdev, brightness);
-}
-
-static ssize_t _morse_delay_show(struct led_classdev *led_cdev, char *buf)
-{
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-
-       sprintf(buf, "%lu\n", morse_data->delay);
-
-       return strlen(buf) + 1;
-}
-
-static ssize_t _morse_delay_store(struct led_classdev *led_cdev,
-               const char *buf, size_t size)
-{
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-       char *after;
-       unsigned long state = simple_strtoul(buf, &after, 10);
-       size_t count = after - buf;
-       int ret = -EINVAL;
-
-       if (*after && isspace(*after))
-               count++;
-
-       if (count == size) {
-               morse_data->delay = state;
-               mod_timer(&morse_data->timer, jiffies + 1);
-               ret = count;
-       }
-
-       return ret;
-}
-
-static ssize_t _morse_msg_show(struct led_classdev *led_cdev, char *buf)
-{
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-
-       if (!morse_data->msg)
-               sprintf(buf, "<none>\n");
-       else
-               sprintf(buf, "%s\n", morse_data->msg);
-
-       return strlen(buf) + 1;
-}
-
-static ssize_t _morse_msg_store(struct led_classdev *led_cdev,
-               const char *buf, size_t size)
-{
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-       char *m;
-
-       m = kmalloc(size, GFP_KERNEL);
-       if (!m)
-               return -ENOMEM;
-
-       memcpy(m,buf,size);
-       m[size]='\0';
-
-       if (morse_data->msg)
-               kfree(morse_data->msg);
-
-       morse_data->msg = m;
-       morse_data->msgpos = NULL;
-       morse_data->state = MORSE_STATE_BLINK_STOP;
-
-       mod_timer(&morse_data->timer, jiffies + 1);
-
-       return size;
-}
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
-static ssize_t morse_delay_show(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-       return _morse_delay_show(led_cdev, buf);
-}
-
-static ssize_t morse_delay_store(struct device *dev,
-               struct device_attribute *attr, const char *buf, size_t size)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-       return _morse_delay_store(led_cdev, buf, size);
-}
-
-static ssize_t morse_msg_show(struct device *dev,
-               struct device_attribute *attr, char *buf)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-       return _morse_msg_show(led_cdev, buf);
-}
-
-static ssize_t morse_msg_store(struct device *dev,
-               struct device_attribute *attr, const char *buf, size_t size)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-
-       return _morse_msg_store(led_cdev, buf, size);
-}
-
-static DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
-static DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
-
-#define led_device_create_file(leddev, attr) \
-       device_create_file(leddev->dev, &dev_attr_ ## attr)
-#define led_device_remove_file(leddev, attr) \
-       device_remove_file(leddev->dev, &dev_attr_ ## attr)
-
-#else
-static ssize_t morse_delay_show(struct class_device *dev, char *buf)
-{
-       struct led_classdev *led_cdev = class_get_devdata(dev);
-
-       return _morse_delay_show(led_cdev, buf);
-}
-
-static ssize_t morse_delay_store(struct class_device *dev, const char *buf,
-               size_t size)
-{
-       struct led_classdev *led_cdev = class_get_devdata(dev);
-
-       return _morse_delay_store(led_cdev, buf, size);
-}
-
-static ssize_t morse_msg_show(struct class_device *dev, char *buf)
-{
-       struct led_classdev *led_cdev = class_get_devdata(dev);
-
-       return _morse_msg_show(led_cdev, buf);
-}
-
-static ssize_t morse_msg_store(struct class_device *dev, const char *buf,
-                               size_t size)
-{
-       struct led_classdev *led_cdev = class_get_devdata(dev);
-
-       return _morse_msg_store(led_cdev, buf, size);
-}
-
-static CLASS_DEVICE_ATTR(delay, 0644, morse_delay_show, morse_delay_store);
-static CLASS_DEVICE_ATTR(message, 0644, morse_msg_show, morse_msg_store);
-
-#define led_device_create_file(leddev, attr) \
-       class_device_create_file(leddev->class_dev, &class_device_attr_ ## attr)
-#define led_device_remove_file(leddev, attr) \
-       class_device_remove_file(leddev->class_dev, &class_device_attr_ ## attr)
-
-#endif
-
-static void morse_trig_activate(struct led_classdev *led_cdev)
-{
-       struct morse_trig_data *morse_data;
-       int rc;
-
-       morse_data = kzalloc(sizeof(*morse_data), GFP_KERNEL);
-       if (!morse_data)
-               return;
-
-       morse_data->delay = MORSE_DELAY_BASE;
-       init_timer(&morse_data->timer);
-       morse_data->timer.function = morse_timer_function;
-       morse_data->timer.data = (unsigned long)led_cdev;
-
-       rc = led_device_create_file(led_cdev, delay);
-       if (rc) goto err;
-
-       rc = led_device_create_file(led_cdev, message);
-       if (rc) goto err_delay;
-
-       led_cdev->trigger_data = morse_data;
-
-       return;
-
-err_delay:
-       led_device_remove_file(led_cdev, delay);
-err:
-       kfree(morse_data);
-}
-
-static void morse_trig_deactivate(struct led_classdev *led_cdev)
-{
-       struct morse_trig_data *morse_data = led_cdev->trigger_data;
-
-       if (!morse_data)
-               return;
-
-       led_device_remove_file(led_cdev, message);
-       led_device_remove_file(led_cdev, delay);
-
-       del_timer_sync(&morse_data->timer);
-       if (morse_data->msg)
-               kfree(morse_data->msg);
-
-       kfree(morse_data);
-}
-
-static struct led_trigger morse_led_trigger = {
-       .name           = "morse",
-       .activate       = morse_trig_activate,
-       .deactivate     = morse_trig_deactivate,
-};
-
-static int __init morse_trig_init(void)
-{
-       return led_trigger_register(&morse_led_trigger);
-}
-
-static void __exit morse_trig_exit(void)
-{
-       led_trigger_unregister(&morse_led_trigger);
-}
-
-module_init(morse_trig_init);
-module_exit(morse_trig_exit);
-
-MODULE_AUTHOR("Gabor Juhos <juhosg at openwrt.org>");
-MODULE_DESCRIPTION("Morse LED trigger");
-MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files/drivers/leds/ledtrig-netdev.c b/target/linux/generic-2.6/files/drivers/leds/ledtrig-netdev.c
deleted file mode 100644 (file)
index fac3571..0000000
+++ /dev/null
@@ -1,451 +0,0 @@
-/*
- * LED Kernel Netdev Trigger
- *
- * Toggles the LED to reflect the link and traffic state of a named net device
- *
- * Copyright 2007 Oliver Jowett <oliver@opencloud.com>
- *
- * Derived from ledtrig-timer.c which is:
- *  Copyright 2005-2006 Openedhand Ltd.
- *  Author: Richard Purdie <rpurdie@openedhand.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/module.h>
-#include <linux/jiffies.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/spinlock.h>
-#include <linux/device.h>
-#include <linux/sysdev.h>
-#include <linux/netdevice.h>
-#include <linux/timer.h>
-#include <linux/ctype.h>
-#include <linux/leds.h>
-#include <linux/version.h>
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
-#include <net/net_namespace.h>
-#endif
-
-#include "leds.h"
-
-/*
- * Configurable sysfs attributes:
- *
- * device_name - network device name to monitor
- *
- * interval - duration of LED blink, in milliseconds
- *
- * mode - either "none" (LED is off) or a space separated list of one or more of:
- *   link: LED's normal state reflects whether the link is up (has carrier) or not
- *   tx:   LED blinks on transmitted data
- *   rx:   LED blinks on receive data
- * 
- * Some suggestions:
- *
- *  Simple link status LED:
- *  $ echo netdev >someled/trigger
- *  $ echo eth0 >someled/device_name
- *  $ echo link >someled/mode
- *
- *  Ethernet-style link/activity LED:
- *  $ echo netdev >someled/trigger
- *  $ echo eth0 >someled/device_name
- *  $ echo "link tx rx" >someled/mode
- *
- *  Modem-style tx/rx LEDs:
- *  $ echo netdev >led1/trigger
- *  $ echo ppp0 >led1/device_name
- *  $ echo tx >led1/mode
- *  $ echo netdev >led2/trigger
- *  $ echo ppp0 >led2/device_name
- *  $ echo rx >led2/mode
- *
- */
-
-#define MODE_LINK 1
-#define MODE_TX   2
-#define MODE_RX   4
-
-struct led_netdev_data {
-       rwlock_t lock;
-
-       struct timer_list timer;
-       struct notifier_block notifier;
-
-       struct led_classdev *led_cdev;
-       struct net_device *net_dev;
-
-       char device_name[IFNAMSIZ];
-       unsigned interval;
-       unsigned mode;
-       unsigned link_up;
-       unsigned last_activity;
-};
-
-static void set_baseline_state(struct led_netdev_data *trigger_data)
-{
-       if ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up)
-               led_set_brightness(trigger_data->led_cdev, LED_FULL);
-       else
-               led_set_brightness(trigger_data->led_cdev, LED_OFF);
-
-       if ((trigger_data->mode & (MODE_TX | MODE_RX)) != 0 && trigger_data->link_up)
-               mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
-       else
-               del_timer(&trigger_data->timer);
-}
-
-static ssize_t led_device_name_show(struct device *dev,
-                                   struct device_attribute *attr, char *buf)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-
-       read_lock(&trigger_data->lock);
-       sprintf(buf, "%s\n", trigger_data->device_name);
-       read_unlock(&trigger_data->lock);
-
-       return strlen(buf) + 1;
-}
-
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
-extern struct net init_net;
-#endif
-
-static ssize_t led_device_name_store(struct device *dev,
-                                    struct device_attribute *attr, const char *buf, size_t size)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-
-       if (size < 0 || size >= IFNAMSIZ)
-               return -EINVAL;
-
-       write_lock(&trigger_data->lock);
-
-       strcpy(trigger_data->device_name, buf);
-       if (size > 0 && trigger_data->device_name[size-1] == '\n')
-               trigger_data->device_name[size-1] = 0;
-
-       if (trigger_data->device_name[0] != 0) {
-               /* check for existing device to update from */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
-               trigger_data->net_dev = dev_get_by_name(&init_net, trigger_data->device_name);
-#else
-               trigger_data->net_dev = dev_get_by_name(trigger_data->device_name);
-#endif
-               if (trigger_data->net_dev != NULL)
-                       trigger_data->link_up = (dev_get_flags(trigger_data->net_dev) & IFF_LOWER_UP) != 0;
-               set_baseline_state(trigger_data); /* updates LEDs, may start timers */
-       }
-
-       write_unlock(&trigger_data->lock);
-       return size;
-}
-
-static DEVICE_ATTR(device_name, 0644, led_device_name_show, led_device_name_store);
-
-static ssize_t led_mode_show(struct device *dev,
-                            struct device_attribute *attr, char *buf)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-
-       read_lock(&trigger_data->lock);
-
-       if (trigger_data->mode == 0) {
-               strcpy(buf, "none\n");
-       } else {
-               if (trigger_data->mode & MODE_LINK)
-                       strcat(buf, "link ");
-               if (trigger_data->mode & MODE_TX)
-                       strcat(buf, "tx ");
-               if (trigger_data->mode & MODE_RX)
-                       strcat(buf, "rx ");
-               strcat(buf, "\n");
-       }
-
-       read_unlock(&trigger_data->lock);
-
-       return strlen(buf)+1;
-}
-
-static ssize_t led_mode_store(struct device *dev,
-                             struct device_attribute *attr, const char *buf, size_t size)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-       char copybuf[1024];
-       int new_mode = -1;
-       char *p, *token;
-
-       /* take a copy since we don't want to trash the inbound buffer when using strsep */
-       strncpy(copybuf, buf, sizeof(copybuf));
-       copybuf[1023] = 0;
-       p = copybuf;
-
-       while ((token = strsep(&p, " \t\n")) != NULL) {
-               if (!*token)
-                       continue;
-
-               if (new_mode == -1)
-                       new_mode = 0;
-
-               if (!strcmp(token, "none"))
-                       new_mode = 0;
-               else if (!strcmp(token, "tx"))
-                       new_mode |= MODE_TX;
-               else if (!strcmp(token, "rx"))
-                       new_mode |= MODE_RX;
-               else if (!strcmp(token, "link"))
-                       new_mode |= MODE_LINK;
-               else
-                       return -EINVAL;
-       }
-
-       if (new_mode == -1)
-               return -EINVAL;
-
-       write_lock(&trigger_data->lock);
-       trigger_data->mode = new_mode;
-       set_baseline_state(trigger_data);
-       write_unlock(&trigger_data->lock);
-
-       return size;
-}
-
-static DEVICE_ATTR(mode, 0644, led_mode_show, led_mode_store);
-
-static ssize_t led_interval_show(struct device *dev,
-                                struct device_attribute *attr, char *buf)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-
-       read_lock(&trigger_data->lock);
-       sprintf(buf, "%u\n", jiffies_to_msecs(trigger_data->interval));
-       read_unlock(&trigger_data->lock);
-
-       return strlen(buf) + 1;
-}
-
-static ssize_t led_interval_store(struct device *dev,
-                                 struct device_attribute *attr, const char *buf, size_t size)
-{
-       struct led_classdev *led_cdev = dev_get_drvdata(dev);
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-       int ret = -EINVAL;
-       char *after;
-       unsigned long value = simple_strtoul(buf, &after, 10);
-       size_t count = after - buf;
-
-       if (*after && isspace(*after))
-               count++;
-
-       /* impose some basic bounds on the timer interval */
-       if (count == size && value >= 5 && value <= 10000) {
-               write_lock(&trigger_data->lock);
-               trigger_data->interval = msecs_to_jiffies(value);
-               set_baseline_state(trigger_data); // resets timer
-               write_unlock(&trigger_data->lock);
-               ret = count;
-       }
-
-       return ret;
-}
-
-static DEVICE_ATTR(interval, 0644, led_interval_show, led_interval_store);
-
-static int netdev_trig_notify(struct notifier_block *nb,
-                             unsigned long evt,
-                             void *dv)
-{
-       struct net_device *dev = dv;
-       struct led_netdev_data *trigger_data = container_of(nb, struct led_netdev_data, notifier);
-
-       if (evt != NETDEV_UP && evt != NETDEV_DOWN && evt != NETDEV_CHANGE && evt != NETDEV_REGISTER && evt != NETDEV_UNREGISTER)
-               return NOTIFY_DONE;
-
-       write_lock(&trigger_data->lock);
-
-       if (strcmp(dev->name, trigger_data->device_name))
-               goto done;
-
-       if (evt == NETDEV_REGISTER) {
-               if (trigger_data->net_dev != NULL)
-                       dev_put(trigger_data->net_dev);
-               dev_hold(dev);
-               trigger_data->net_dev = dev;
-               trigger_data->link_up = 0;
-               goto done;
-       }
-
-       if (evt == NETDEV_UNREGISTER && trigger_data->net_dev != NULL) {
-               dev_put(trigger_data->net_dev);
-               trigger_data->net_dev = NULL;
-               goto done;
-       }
-
-       /* UP / DOWN / CHANGE */
-
-       trigger_data->link_up = (evt != NETDEV_DOWN && netif_carrier_ok(dev));
-       set_baseline_state(trigger_data);
-
-done:
-       write_unlock(&trigger_data->lock);
-       return NOTIFY_DONE;
-}
-
-/* here's the real work! */
-static void netdev_trig_timer(unsigned long arg)
-{
-       struct led_netdev_data *trigger_data = (struct led_netdev_data *)arg;
-       struct net_device_stats *dev_stats;
-       unsigned new_activity;
-
-       write_lock(&trigger_data->lock);
-
-       if (!trigger_data->link_up || !trigger_data->net_dev || (trigger_data->mode & (MODE_TX | MODE_RX)) == 0) {
-               /* we don't need to do timer work, just reflect link state. */
-               led_set_brightness(trigger_data->led_cdev, ((trigger_data->mode & MODE_LINK) != 0 && trigger_data->link_up) ? LED_FULL : LED_OFF);
-               goto no_restart;
-       }
-
-       dev_stats = trigger_data->net_dev->get_stats(trigger_data->net_dev);
-       new_activity =
-               ((trigger_data->mode & MODE_TX) ? dev_stats->tx_packets : 0) +
-               ((trigger_data->mode & MODE_RX) ? dev_stats->rx_packets : 0);
-
-       if (trigger_data->mode & MODE_LINK) {
-               /* base state is ON (link present) */
-               /* if there's no link, we don't get this far and the LED is off */
-
-               /* OFF -> ON always */
-               /* ON -> OFF on activity */
-               if (trigger_data->led_cdev->brightness == LED_OFF) {
-                       led_set_brightness(trigger_data->led_cdev, LED_FULL);
-               } else if (trigger_data->last_activity != new_activity) {
-                       led_set_brightness(trigger_data->led_cdev, LED_OFF);
-               }
-       } else {
-               /* base state is OFF */
-               /* ON -> OFF always */
-               /* OFF -> ON on activity */
-               if (trigger_data->led_cdev->brightness == LED_FULL) {
-                       led_set_brightness(trigger_data->led_cdev, LED_OFF);
-               } else if (trigger_data->last_activity != new_activity) {
-                       led_set_brightness(trigger_data->led_cdev, LED_FULL);
-               }
-       }
-
-       trigger_data->last_activity = new_activity;
-       mod_timer(&trigger_data->timer, jiffies + trigger_data->interval);
-
-no_restart:
-       write_unlock(&trigger_data->lock);
-}
-
-static void netdev_trig_activate(struct led_classdev *led_cdev)
-{
-       struct led_netdev_data *trigger_data;
-       int rc;
-
-       trigger_data = kzalloc(sizeof(struct led_netdev_data), GFP_KERNEL);
-       if (!trigger_data)
-               return;
-
-       rwlock_init(&trigger_data->lock);
-
-       trigger_data->notifier.notifier_call = netdev_trig_notify;
-       trigger_data->notifier.priority = 10;
-
-       setup_timer(&trigger_data->timer, netdev_trig_timer, (unsigned long) trigger_data);
-
-       trigger_data->led_cdev = led_cdev;
-       trigger_data->net_dev = NULL;
-       trigger_data->device_name[0] = 0;
-
-       trigger_data->mode = 0;
-       trigger_data->interval = msecs_to_jiffies(50);
-       trigger_data->link_up = 0;
-       trigger_data->last_activity = 0;
-
-       led_cdev->trigger_data = trigger_data;
-
-       rc = device_create_file(led_cdev->dev, &dev_attr_device_name);
-       if (rc)
-               goto err_out;
-       rc = device_create_file(led_cdev->dev, &dev_attr_mode);
-       if (rc)
-               goto err_out_device_name;
-       rc = device_create_file(led_cdev->dev, &dev_attr_interval);
-       if (rc)
-               goto err_out_mode;
-
-       register_netdevice_notifier(&trigger_data->notifier);
-       return;
-
-err_out_mode:
-       device_remove_file(led_cdev->dev, &dev_attr_mode);
-err_out_device_name:
-       device_remove_file(led_cdev->dev, &dev_attr_device_name);
-err_out:
-       led_cdev->trigger_data = NULL;
-       kfree(trigger_data);
-}
-
-static void netdev_trig_deactivate(struct led_classdev *led_cdev)
-{
-       struct led_netdev_data *trigger_data = led_cdev->trigger_data;
-
-       if (trigger_data) {
-               unregister_netdevice_notifier(&trigger_data->notifier);
-
-               device_remove_file(led_cdev->dev, &dev_attr_device_name);
-               device_remove_file(led_cdev->dev, &dev_attr_mode);
-               device_remove_file(led_cdev->dev, &dev_attr_interval);
-
-               write_lock(&trigger_data->lock);
-
-               if (trigger_data->net_dev) {
-                       dev_put(trigger_data->net_dev);
-                       trigger_data->net_dev = NULL;
-               }
-
-               write_unlock(&trigger_data->lock);
-
-               del_timer_sync(&trigger_data->timer);
-
-               kfree(trigger_data);
-       }
-}
-
-static struct led_trigger netdev_led_trigger = {
-       .name     = "netdev",
-       .activate = netdev_trig_activate,
-       .deactivate = netdev_trig_deactivate,
-};
-
-static int __init netdev_trig_init(void)
-{
-       return led_trigger_register(&netdev_led_trigger);
-}
-
-static void __exit netdev_trig_exit(void)
-{
-       led_trigger_unregister(&netdev_led_trigger);
-}
-
-module_init(netdev_trig_init);
-module_exit(netdev_trig_exit);
-
-MODULE_AUTHOR("Oliver Jowett <oliver@opencloud.com>");
-MODULE_DESCRIPTION("Netdev LED trigger");
-MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files/drivers/net/phy/adm6996.c b/target/linux/generic-2.6/files/drivers/net/phy/adm6996.c
deleted file mode 100644 (file)
index 3033813..0000000
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * ADM6996 switch driver
- *
- * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of the GNU General Public License v2 as published by the
- * Free Software Foundation
- */
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/unistd.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/spinlock.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/mii.h>
-#include <linux/ethtool.h>
-#include <linux/phy.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/uaccess.h>
-#include "adm6996.h"
-
-MODULE_DESCRIPTION("Infineon ADM6996 Switch");
-MODULE_AUTHOR("Felix Fietkau");
-MODULE_LICENSE("GPL");
-
-struct adm6996_priv {
-       /* use abstraction for regops, we want to add gpio support in the future */
-       u16 (*read)(struct phy_device *phydev, enum admreg reg);
-       void (*write)(struct phy_device *phydev, enum admreg reg, u16 val);
-};
-
-#define to_adm(_phy) ((struct adm6996_priv *) (_phy)->priv)
-
-
-static inline u16
-r16(struct phy_device *pdev, enum admreg reg)
-{
-       return to_adm(pdev)->read(pdev, reg);
-}
-
-static inline void
-w16(struct phy_device *pdev, enum admreg reg, u16 val)
-{
-       to_adm(pdev)->write(pdev, reg, val);
-}
-
-
-static u16
-adm6996_read_mii_reg(struct phy_device *phydev, enum admreg reg)
-{
-       return phydev->bus->read(phydev->bus, PHYADDR(reg));
-}
-
-static void
-adm6996_write_mii_reg(struct phy_device *phydev, enum admreg reg, u16 val)
-{
-       phydev->bus->write(phydev->bus, PHYADDR(reg), val);
-}
-
-
-static int adm6996_config_init(struct phy_device *pdev)
-{
-       int i;
-
-       printk("%s: ADM6996 PHY driver attached.\n", pdev->attached_dev->name);
-       pdev->supported = ADVERTISED_100baseT_Full;
-       pdev->advertising = ADVERTISED_100baseT_Full;
-
-       /* initialize port and vlan settings */
-       for (i = 0; i < ADM_PHY_PORTS; i++) {
-               w16(pdev, adm_portcfg[i], ADM_PORTCFG_INIT |
-                       ADM_PORTCFG_PVID((i == ADM_WAN_PORT) ? 1 : 0));
-       }
-       w16(pdev, adm_portcfg[5], ADM_PORTCFG_CPU);
-
-       /* reset all ports */
-       for (i = 0; i < ADM_PHY_PORTS; i++) {
-               w16(pdev, ADM_PHY_PORT(i), ADM_PHYCFG_INIT);
-       }
-
-       return 0;
-}
-
-static int adm6996_read_status(struct phy_device *phydev)
-{
-       phydev->speed = SPEED_100;
-       phydev->duplex = DUPLEX_FULL;
-       phydev->state = PHY_UP;
-       return 0;
-}
-
-static int adm6996_config_aneg(struct phy_device *phydev)
-{
-       return 0;
-}
-
-static int adm6996_probe(struct phy_device *pdev)
-{
-       struct adm6996_priv *priv;
-
-       priv = kzalloc(sizeof(struct adm6996_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return -ENOMEM;
-
-       priv->read = adm6996_read_mii_reg;
-       priv->write = adm6996_write_mii_reg;
-       pdev->priv = priv;
-       return 0;
-}
-
-static void adm6996_remove(struct phy_device *pdev)
-{
-       kfree(pdev->priv);
-}
-
-static bool adm6996_detect(struct mii_bus *bus, int addr)
-{
-       u16 reg;
-
-       /* we only attach to phy id 0 */
-       if (addr != 0)
-               return false;
-
-       /* look for the switch on the bus */
-       reg = bus->read(bus, PHYADDR(ADM_SIG0)) & ADM_SIG0_MASK;
-       if (reg != ADM_SIG0_VAL)
-               return false;
-
-       reg = bus->read(bus, PHYADDR(ADM_SIG1)) & ADM_SIG1_MASK;
-       if (reg != ADM_SIG1_VAL)
-               return false;
-
-       return true;
-}
-
-static struct phy_driver adm6996_driver = {
-       .name           = "Infineon ADM6996",
-       .features       = PHY_BASIC_FEATURES,
-       .detect         = adm6996_detect,
-       .probe          = adm6996_probe,
-       .remove         = adm6996_remove,
-       .config_init    = &adm6996_config_init,
-       .config_aneg    = &adm6996_config_aneg,
-       .read_status    = &adm6996_read_status,
-       .driver         = { .owner = THIS_MODULE,},
-};
-
-static int __init adm6996_init(void)
-{
-       return phy_driver_register(&adm6996_driver);
-}
-
-static void __exit adm6996_exit(void)
-{
-       phy_driver_unregister(&adm6996_driver);
-}
-
-module_init(adm6996_init);
-module_exit(adm6996_exit);
diff --git a/target/linux/generic-2.6/files/drivers/net/phy/adm6996.h b/target/linux/generic-2.6/files/drivers/net/phy/adm6996.h
deleted file mode 100644 (file)
index e074901..0000000
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * ADM6996 switch driver
- *
- * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of the GNU General Public License v2 as published by the
- * Free Software Foundation
- */
-#ifndef __ADM6996_H
-#define __ADM6996_H
-
-#define ADM_PHY_PORTS  5
-#define ADM_CPU_PORT   5
-#define ADM_WAN_PORT   0 /* FIXME: dynamic ? */
-
-enum admreg {
-       ADM_EEPROM_BASE         = 0x0,
-               ADM_P0_CFG              = ADM_EEPROM_BASE + 1,
-               ADM_P1_CFG              = ADM_EEPROM_BASE + 3,
-               ADM_P2_CFG              = ADM_EEPROM_BASE + 5,
-               ADM_P3_CFG              = ADM_EEPROM_BASE + 7,
-               ADM_P4_CFG              = ADM_EEPROM_BASE + 8,
-               ADM_P5_CFG              = ADM_EEPROM_BASE + 9,
-       ADM_EEPROM_EXT_BASE     = 0x40,
-       ADM_COUNTER_BASE        = 0xa0,
-               ADM_SIG0                = ADM_COUNTER_BASE + 0,
-               ADM_SIG1                = ADM_COUNTER_BASE + 1,
-       ADM_PHY_BASE            = 0x200,
-#define ADM_PHY_PORT(n) (ADM_PHY_BASE + (0x20 * n))
-};
-
-/* Chip identification patterns */
-#define        ADM_SIG0_MASK   0xfff0
-#define ADM_SIG0_VAL   0x1020
-#define ADM_SIG1_MASK  0xffff
-#define ADM_SIG1_VAL   0x0007
-
-enum {
-       ADM_PHYCFG_COLTST     = (1 << 7),       /* Enable collision test */
-       ADM_PHYCFG_DPLX       = (1 << 8),       /* Enable full duplex */
-       ADM_PHYCFG_ANEN_RST   = (1 << 9),       /* Restart auto negotiation (self clear) */
-       ADM_PHYCFG_ISO        = (1 << 10),      /* Isolate PHY */
-       ADM_PHYCFG_PDN        = (1 << 11),      /* Power down PHY */
-       ADM_PHYCFG_ANEN       = (1 << 12),      /* Enable auto negotiation */
-       ADM_PHYCFG_SPEED_100  = (1 << 13),      /* Enable 100 Mbit/s */
-       ADM_PHYCFG_LPBK       = (1 << 14),      /* Enable loopback operation */
-       ADM_PHYCFG_RST        = (1 << 15),      /* Reset the port (self clear) */
-       ADM_PHYCFG_INIT = (
-               ADM_PHYCFG_RST |
-               ADM_PHYCFG_SPEED_100 |
-               ADM_PHYCFG_ANEN |
-               ADM_PHYCFG_ANEN_RST
-       )
-};
-
-enum {
-       ADM_PORTCFG_FC        = (1 << 0),       /* Enable 802.x flow control */
-       ADM_PORTCFG_AN        = (1 << 1),       /* Enable auto-negotiation */
-       ADM_PORTCFG_SPEED_100 = (1 << 2),       /* Enable 100 Mbit/s */
-       ADM_PORTCFG_DPLX      = (1 << 3),       /* Enable full duplex */
-       ADM_PORTCFG_OT        = (1 << 4),       /* Output tagged packets */
-       ADM_PORTCFG_PD        = (1 << 5),       /* Port disable */
-       ADM_PORTCFG_TV_PRIO   = (1 << 6),       /* 0 = VLAN based priority
-                                                * 1 = TOS based priority */
-       ADM_PORTCFG_PPE       = (1 << 7),       /* Port based priority enable */
-       ADM_PORTCFG_PP_S      = (1 << 8),       /* Port based priority, 2 bits */
-       ADM_PORTCFG_PVID_BASE = (1 << 10),      /* Primary VLAN id, 4 bits */
-       ADM_PORTCFG_FSE       = (1 << 14),      /* Fx select enable */
-       ADM_PORTCFG_CAM       = (1 << 15),      /* Crossover Auto MDIX */
-
-       ADM_PORTCFG_INIT = (
-               ADM_PORTCFG_FC |
-               ADM_PORTCFG_AN |
-               ADM_PORTCFG_SPEED_100 |
-               ADM_PORTCFG_DPLX |
-               ADM_PORTCFG_CAM
-       ),
-       ADM_PORTCFG_CPU = (
-               ADM_PORTCFG_FC |
-               ADM_PORTCFG_SPEED_100 |
-               ADM_PORTCFG_OT |
-               ADM_PORTCFG_DPLX
-       ),
-};
-
-#define ADM_PORTCFG_PPID(N) ((n & 0x3) << 8)
-#define ADM_PORTCFG_PVID(n) ((n & 0xf) << 10)
-
-static const u8 adm_portcfg[] = {
-       [0] = ADM_P0_CFG,
-       [1] = ADM_P1_CFG,
-       [2] = ADM_P2_CFG,
-       [3] = ADM_P3_CFG,
-       [4] = ADM_P4_CFG,
-       [5] = ADM_P5_CFG,
-};
-
-/*
- * Split the register address in phy id and register
- * it will get combined again by the mdio bus op
- */
-#define PHYADDR(_reg)  ((_reg >> 5) & 0xff), (_reg & 0x1f)
-
-#endif
diff --git a/target/linux/generic-2.6/files/drivers/net/phy/mvswitch.c b/target/linux/generic-2.6/files/drivers/net/phy/mvswitch.c
deleted file mode 100644 (file)
index 78e5afe..0000000
+++ /dev/null
@@ -1,474 +0,0 @@
-/*
- * Marvell 88E6060 switch driver
- * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of the GNU General Public License v2 as published by the
- * Free Software Foundation
- */
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/errno.h>
-#include <linux/unistd.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/skbuff.h>
-#include <linux/spinlock.h>
-#include <linux/mm.h>
-#include <linux/module.h>
-#include <linux/mii.h>
-#include <linux/ethtool.h>
-#include <linux/phy.h>
-#include <linux/if_vlan.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/uaccess.h>
-#include "mvswitch.h"
-
-/* Undefine this to use trailer mode instead.
- * I don't know if header mode works with all chips */
-#define HEADER_MODE    1
-
-MODULE_DESCRIPTION("Marvell 88E6060 Switch driver");
-MODULE_AUTHOR("Felix Fietkau");
-MODULE_LICENSE("GPL");
-
-struct mvswitch_priv {
-       /* the driver's tx function */
-       int (*hardstart)(struct sk_buff *skb, struct net_device *dev);
-       struct vlan_group *grp;
-       u8 vlans[16];
-};
-
-#define to_mvsw(_phy) ((struct mvswitch_priv *) (_phy)->priv)
-
-static inline u16
-r16(struct phy_device *phydev, int addr, int reg)
-{
-       return phydev->bus->read(phydev->bus, addr, reg);
-}
-
-static inline void
-w16(struct phy_device *phydev, int addr, int reg, u16 val)
-{
-       phydev->bus->write(phydev->bus, addr, reg, val);
-}
-
-
-static int
-mvswitch_mangle_tx(struct sk_buff *skb, struct net_device *dev)
-{
-       struct mvswitch_priv *priv;
-       char *buf = NULL;
-       u16 vid;
-
-       priv = dev->phy_ptr;
-       if (unlikely(!priv))
-               goto error;
-
-       if (unlikely(skb->len < 16))
-               goto error;
-
-#ifdef HEADER_MODE
-       if (__vlan_hwaccel_get_tag(skb, &vid))
-               goto error;
-
-       if (skb_cloned(skb) || (skb->len <= 62) || (skb_headroom(skb) < MV_HEADER_SIZE)) {
-               if (pskb_expand_head(skb, MV_HEADER_SIZE, (skb->len < 62 ? 62 - skb->len : 0), GFP_ATOMIC))
-                       goto error_expand;
-               if (skb->len < 62)
-                       skb->len = 62;
-       }
-       buf = skb_push(skb, MV_HEADER_SIZE);
-#else
-       if (__vlan_get_tag(skb, &vid))
-               goto error;
-
-       if (unlikely((vid > 15 || !priv->vlans[vid])))
-               goto error;
-
-       if (skb->len <= 64) {
-               if (pskb_expand_head(skb, 0, 64 + MV_TRAILER_SIZE - skb->len, GFP_ATOMIC))
-                       goto error_expand;
-
-               buf = skb->data + 64;
-               skb->len = 64 + MV_TRAILER_SIZE;
-       } else {
-               if (skb_cloned(skb) || unlikely(skb_tailroom(skb) < 4)) {
-                       if (pskb_expand_head(skb, 0, 4, GFP_ATOMIC))
-                               goto error_expand;
-               }
-               buf = skb_put(skb, 4);
-       }
-
-       /* move the ethernet header 4 bytes forward, overwriting the vlan tag */
-       memmove(skb->data + 4, skb->data, 12);
-       skb->data += 4;
-       skb->len -= 4;
-       skb->mac_header += 4;
-#endif
-
-       if (!buf)
-               goto error;
-
-
-#ifdef HEADER_MODE
-       /* prepend the tag */
-       *((__be16 *) buf) = cpu_to_be16(
-               ((vid << MV_HEADER_VLAN_S) & MV_HEADER_VLAN_M) |
-               ((priv->vlans[vid] << MV_HEADER_PORTS_S) & MV_HEADER_PORTS_M)
-       );
-#else
-       /* append the tag */
-       *((__be32 *) buf) = cpu_to_be32((
-               (MV_TRAILER_OVERRIDE << MV_TRAILER_FLAGS_S) |
-               ((priv->vlans[vid] & MV_TRAILER_PORTS_M) << MV_TRAILER_PORTS_S)
-       ));
-#endif
-
-       return priv->hardstart(skb, dev);
-
-error_expand:
-       if (net_ratelimit())
-               printk("%s: failed to expand/update skb for the switch\n", dev->name);
-
-error:
-       /* any errors? drop the packet! */
-       dev_kfree_skb_any(skb);
-       return 0;
-}
-
-static int
-mvswitch_mangle_rx(struct sk_buff *skb, int napi)
-{
-       struct mvswitch_priv *priv;
-       struct net_device *dev;
-       int vlan = -1;
-       unsigned char *buf;
-       int i;
-
-       dev = skb->dev;
-       if (!dev)
-               goto error;
-
-       priv = dev->phy_ptr;
-       if (!priv)
-               goto error;
-
-       if (!priv->grp)
-               goto error;
-
-#ifdef HEADER_MODE
-       buf = skb->data;
-       skb_pull(skb, MV_HEADER_SIZE);
-#else
-       buf = skb->data + skb->len - MV_TRAILER_SIZE;
-       if (buf[0] != 0x80)
-               goto error;
-#endif
-
-       /* look for the vlan matching the incoming port */
-       for (i = 0; i < ARRAY_SIZE(priv->vlans); i++) {
-               if ((1 << buf[1]) & priv->vlans[i])
-                       vlan = i;
-       }
-
-       if (vlan == -1)
-               goto error;
-
-       skb->protocol = eth_type_trans(skb, skb->dev);
-
-       if (napi)
-               return vlan_hwaccel_receive_skb(skb, priv->grp, vlan);
-       else
-               return vlan_hwaccel_rx(skb, priv->grp, vlan);
-
-error:
-       /* no vlan? eat the packet! */
-       dev_kfree_skb_any(skb);
-       return 0;
-}
-
-
-static int
-mvswitch_netif_rx(struct sk_buff *skb)
-{
-       return mvswitch_mangle_rx(skb, 0);
-}
-
-static int
-mvswitch_netif_receive_skb(struct sk_buff *skb)
-{
-       return mvswitch_mangle_rx(skb, 1);
-}
-
-
-static void
-mvswitch_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
-{
-       struct mvswitch_priv *priv = dev->phy_ptr;
-       priv->grp = grp;
-}
-
-
-static int
-mvswitch_wait_mask(struct phy_device *pdev, int addr, int reg, u16 mask, u16 val)
-{
-       int i = 100;
-       u16 r;
-
-       do {
-               r = r16(pdev, addr, reg) & mask;
-               if (r == val)
-                       return 0;
-       } while(--i > 0);
-       return -ETIMEDOUT;
-}
-
-static int
-mvswitch_config_init(struct phy_device *pdev)
-{
-       struct mvswitch_priv *priv = to_mvsw(pdev);
-       struct net_device *dev = pdev->attached_dev;
-       u8 vlmap = 0;
-       int i;
-
-       if (!dev)
-               return -EINVAL;
-
-       printk("%s: Marvell 88E6060 PHY driver attached.\n", dev->name);
-       pdev->supported = ADVERTISED_100baseT_Full;
-       pdev->advertising = ADVERTISED_100baseT_Full;
-       dev->phy_ptr = priv;
-       dev->irq = PHY_POLL;
-
-       /* initialize default vlans */
-       for (i = 0; i < MV_PORTS; i++)
-               priv->vlans[(i == MV_WANPORT ? 1 : 0)] |= (1 << i);
-
-       /* before entering reset, disable all ports */
-       for (i = 0; i < MV_PORTS; i++)
-               w16(pdev, MV_PORTREG(CONTROL, i), 0x00);
-
-       msleep(2); /* wait for the status change to settle in */
-
-       /* put the ATU in reset */
-       w16(pdev, MV_SWITCHREG(ATU_CTRL), MV_ATUCTL_RESET);
-
-       i = mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_CTRL), MV_ATUCTL_RESET, 0);
-       if (i < 0) {
-               printk("%s: Timeout waiting for the switch to reset.\n", dev->name);
-               return i;
-       }
-
-       /* set the ATU flags */
-       w16(pdev, MV_SWITCHREG(ATU_CTRL),
-               MV_ATUCTL_NO_LEARN |
-               MV_ATUCTL_ATU_1K |
-               MV_ATUCTL_AGETIME(MV_ATUCTL_AGETIME_MIN) /* minimum without disabling ageing */
-       );
-
-       /* initialize the cpu port */
-       w16(pdev, MV_PORTREG(CONTROL, MV_CPUPORT),
-#ifdef HEADER_MODE
-               MV_PORTCTRL_HEADER |
-#else
-               MV_PORTCTRL_RXTR |
-               MV_PORTCTRL_TXTR |
-#endif
-               MV_PORTCTRL_ENABLED
-       );
-       /* wait for the phy change to settle in */
-       msleep(2);
-       for (i = 0; i < MV_PORTS; i++) {
-               u8 pvid = 0;
-               int j;
-
-               vlmap = 0;
-
-               /* look for the matching vlan */
-               for (j = 0; j < ARRAY_SIZE(priv->vlans); j++) {
-                       if (priv->vlans[j] & (1 << i)) {
-                               vlmap = priv->vlans[j];
-                               pvid = j;
-                       }
-               }
-               /* leave port unconfigured if it's not part of a vlan */
-               if (!vlmap)
-                       continue;
-
-               /* add the cpu port to the allowed destinations list */
-               vlmap |= (1 << MV_CPUPORT);
-
-               /* take port out of its own vlan destination map */
-               vlmap &= ~(1 << i);
-
-               /* apply vlan settings */
-               w16(pdev, MV_PORTREG(VLANMAP, i),
-                       MV_PORTVLAN_PORTS(vlmap) |
-                       MV_PORTVLAN_ID(i)
-               );
-
-               /* re-enable port */
-               w16(pdev, MV_PORTREG(CONTROL, i),
-                       MV_PORTCTRL_ENABLED
-               );
-       }
-
-       w16(pdev, MV_PORTREG(VLANMAP, MV_CPUPORT),
-               MV_PORTVLAN_ID(MV_CPUPORT)
-       );
-
-       /* set the port association vector */
-       for (i = 0; i <= MV_PORTS; i++) {
-               w16(pdev, MV_PORTREG(ASSOC, i),
-                       MV_PORTASSOC_PORTS(1 << i)
-               );
-       }
-
-       /* init switch control */
-       w16(pdev, MV_SWITCHREG(CTRL),
-               MV_SWITCHCTL_MSIZE |
-               MV_SWITCHCTL_DROP
-       );
-
-       /* hook into the tx function */
-       priv->hardstart = dev->hard_start_xmit;
-       pdev->netif_receive_skb = mvswitch_netif_receive_skb;
-       pdev->netif_rx = mvswitch_netif_rx;
-       dev->hard_start_xmit = mvswitch_mangle_tx;
-       dev->vlan_rx_register = mvswitch_vlan_rx_register;
-#ifdef HEADER_MODE
-       dev->features |= NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_TX;
-#else
-       dev->features |= NETIF_F_HW_VLAN_RX;
-#endif
-
-       return 0;
-}
-
-static int
-mvswitch_read_status(struct phy_device *pdev)
-{
-       pdev->speed = SPEED_100;
-       pdev->duplex = DUPLEX_FULL;
-       pdev->state = PHY_UP;
-
-       /* XXX ugly workaround: we can't force the switch
-        * to gracefully handle hosts moving from one port to another,
-        * so we have to regularly clear the ATU database */
-
-       /* wait for the ATU to become available */
-       mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_OP), MV_ATUOP_INPROGRESS, 0);
-
-       /* flush the ATU */
-       w16(pdev, MV_SWITCHREG(ATU_OP),
-               MV_ATUOP_INPROGRESS |
-               MV_ATUOP_FLUSH_ALL
-       );
-
-       /* wait for operation to complete */
-       mvswitch_wait_mask(pdev, MV_SWITCHREG(ATU_OP), MV_ATUOP_INPROGRESS, 0);
-
-       return 0;
-}
-
-static int
-mvswitch_config_aneg(struct phy_device *phydev)
-{
-       return 0;
-}
-
-static void
-mvswitch_remove(struct phy_device *pdev)
-{
-       struct mvswitch_priv *priv = to_mvsw(pdev);
-       struct net_device *dev = pdev->attached_dev;
-
-       /* restore old xmit handler */
-       if (priv->hardstart && dev)
-               dev->hard_start_xmit = priv->hardstart;
-       dev->vlan_rx_register = NULL;
-       dev->vlan_rx_kill_vid = NULL;
-       dev->phy_ptr = NULL;
-       dev->features &= ~NETIF_F_HW_VLAN_RX;
-       kfree(priv);
-}
-
-static bool
-mvswitch_detect(struct mii_bus *bus, int addr)
-{
-       u16 reg;
-       int i;
-
-       /* we attach to phy id 31 to make sure that the late probe works */
-       if (addr != 31)
-               return false;
-
-       /* look for the switch on the bus */
-       reg = bus->read(bus, MV_PORTREG(IDENT, 0)) & MV_IDENT_MASK;
-       if (reg != MV_IDENT_VALUE)
-               return false;
-
-       /* 
-        * Now that we've established that the switch actually exists, let's 
-        * get rid of the competition :)
-        */
-       for (i = 0; i < 31; i++) {
-               if (!bus->phy_map[i])
-                       continue;
-
-               device_unregister(&bus->phy_map[i]->dev);
-               kfree(bus->phy_map[i]);
-               bus->phy_map[i] = NULL;
-       }
-
-       return true;
-}
-
-static int
-mvswitch_probe(struct phy_device *pdev)
-{
-       struct mvswitch_priv *priv;
-
-       priv = kzalloc(sizeof(struct mvswitch_priv), GFP_KERNEL);
-       if (priv == NULL)
-               return -ENOMEM;
-
-       pdev->priv = priv;
-
-       return 0;
-}
-
-
-static struct phy_driver mvswitch_driver = {
-       .name           = "Marvell 88E6060",
-       .features       = PHY_BASIC_FEATURES,
-       .detect         = &mvswitch_detect,
-       .probe          = &mvswitch_probe,
-       .remove         = &mvswitch_remove,
-       .config_init    = &mvswitch_config_init,
-       .config_aneg    = &mvswitch_config_aneg,
-       .read_status    = &mvswitch_read_status,
-       .driver         = { .owner = THIS_MODULE,},
-};
-
-static int __init
-mvswitch_init(void)
-{
-       return phy_driver_register(&mvswitch_driver);
-}
-
-static void __exit
-mvswitch_exit(void)
-{
-       phy_driver_unregister(&mvswitch_driver);
-}
-
-module_init(mvswitch_init);
-module_exit(mvswitch_exit);
diff --git a/target/linux/generic-2.6/files/drivers/net/phy/mvswitch.h b/target/linux/generic-2.6/files/drivers/net/phy/mvswitch.h
deleted file mode 100644 (file)
index 1563eec..0000000
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Marvell 88E6060 switch driver
- * Copyright (c) 2008 Felix Fietkau <nbd@openwrt.org>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of the GNU General Public License v2 as published by the
- * Free Software Foundation
- */
-#ifndef __MVSWITCH_H
-#define __MVSWITCH_H
-
-#define MV_HEADER_SIZE 2
-#define MV_HEADER_PORTS_M      0x001f
-#define MV_HEADER_PORTS_S      0
-#define MV_HEADER_VLAN_M       0xf000
-#define MV_HEADER_VLAN_S       12
-
-#define MV_TRAILER_SIZE        4
-#define MV_TRAILER_PORTS_M     0x1f
-#define MV_TRAILER_PORTS_S     16
-#define MV_TRAILER_FLAGS_S     24
-#define MV_TRAILER_OVERRIDE    0x80
-
-
-#define MV_PORTS       5
-#define MV_WANPORT     4
-#define MV_CPUPORT     5
-
-#define MV_BASE                0x10
-
-#define MV_PHYPORT_BASE                (MV_BASE + 0x0)
-#define MV_PHYPORT(_n)         (MV_PHYPORT_BASE + (_n))
-#define MV_SWITCHPORT_BASE     (MV_BASE + 0x8)
-#define MV_SWITCHPORT(_n)      (MV_SWITCHPORT_BASE + (_n))
-#define MV_SWITCHREGS          (MV_BASE + 0xf)
-
-enum {
-       MV_PHY_CONTROL      = 0x00,
-       MV_PHY_STATUS       = 0x01,
-       MV_PHY_IDENT0       = 0x02,
-       MV_PHY_IDENT1       = 0x03,
-       MV_PHY_ANEG         = 0x04,
-       MV_PHY_LINK_ABILITY = 0x05,
-       MV_PHY_ANEG_EXPAND  = 0x06,
-       MV_PHY_XMIT_NEXTP   = 0x07,
-       MV_PHY_LINK_NEXTP   = 0x08,
-       MV_PHY_CONTROL1     = 0x10,
-       MV_PHY_STATUS1      = 0x11,
-       MV_PHY_INTR_EN      = 0x12,
-       MV_PHY_INTR_STATUS  = 0x13,
-       MV_PHY_INTR_PORT    = 0x14,
-       MV_PHY_RECV_COUNTER = 0x16,
-       MV_PHY_LED_PARALLEL = 0x16,
-       MV_PHY_LED_STREAM   = 0x17,
-       MV_PHY_LED_CTRL     = 0x18,
-       MV_PHY_LED_OVERRIDE = 0x19,
-       MV_PHY_VCT_CTRL     = 0x1a,
-       MV_PHY_VCT_STATUS   = 0x1b,
-       MV_PHY_CONTROL2     = 0x1e
-};
-#define MV_PHYREG(_type, _port) MV_PHYPORT(_port), MV_PHY_##_type
-
-enum {
-       MV_PORT_STATUS      = 0x00,
-       MV_PORT_IDENT       = 0x03,
-       MV_PORT_CONTROL     = 0x04,
-       MV_PORT_VLANMAP     = 0x06,
-       MV_PORT_ASSOC       = 0x0b,
-       MV_PORT_RXCOUNT     = 0x10,
-       MV_PORT_TXCOUNT     = 0x11,
-};
-#define MV_PORTREG(_type, _port) MV_SWITCHPORT(_port), MV_PORT_##_type
-
-enum {
-       MV_PORTCTRL_BLOCK   =  (1 << 0),
-       MV_PORTCTRL_LEARN   =  (2 << 0),
-       MV_PORTCTRL_ENABLED =  (3 << 0),
-       MV_PORTCTRL_VLANTUN =  (1 << 7),        /* Enforce VLANs on packets */
-       MV_PORTCTRL_RXTR    =  (1 << 8),        /* Enable Marvell packet trailer for ingress */
-       MV_PORTCTRL_HEADER      = (1 << 11),    /* Enable Marvell packet header mode for port */
-       MV_PORTCTRL_TXTR    = (1 << 14),        /* Enable Marvell packet trailer for egress */
-       MV_PORTCTRL_FORCEFL = (1 << 15),        /* force flow control */
-};
-
-#define MV_PORTVLAN_ID(_n) (((_n) & 0xf) << 12)
-#define MV_PORTVLAN_PORTS(_n) ((_n) & 0x3f)
-
-#define MV_PORTASSOC_PORTS(_n) ((_n) & 0x1f)
-#define MV_PORTASSOC_MONITOR   (1 << 15)
-
-enum {
-       MV_SWITCH_MAC0      = 0x01,
-       MV_SWITCH_MAC1      = 0x02,
-       MV_SWITCH_MAC2      = 0x03,
-       MV_SWITCH_CTRL      = 0x04,
-       MV_SWITCH_ATU_CTRL  = 0x0a,
-       MV_SWITCH_ATU_OP    = 0x0b,
-       MV_SWITCH_ATU_DATA  = 0x0c,
-       MV_SWITCH_ATU_MAC0  = 0x0d,
-       MV_SWITCH_ATU_MAC1  = 0x0e,
-       MV_SWITCH_ATU_MAC2  = 0x0f,
-};
-#define MV_SWITCHREG(_type) MV_SWITCHREGS, MV_SWITCH_##_type
-
-enum {
-       MV_SWITCHCTL_EEIE   =  (1 << 0),        /* EEPROM interrupt enable */
-       MV_SWITCHCTL_PHYIE  =  (1 << 1),        /* PHY interrupt enable */
-       MV_SWITCHCTL_ATUDONE=  (1 << 2),        /* ATU done interrupt enable */
-       MV_SWITCHCTL_ATUIE  =  (1 << 3),        /* ATU interrupt enable */
-       MV_SWITCHCTL_CTRMODE=  (1 << 8),        /* statistics for rx and tx errors */
-       MV_SWITCHCTL_RELOAD =  (1 << 9),        /* reload registers from eeprom */
-       MV_SWITCHCTL_MSIZE  = (1 << 10),        /* increase maximum frame size */
-       MV_SWITCHCTL_DROP   = (1 << 13),        /* discard frames with excessive collisions */
-};
-
-enum {
-#define MV_ATUCTL_AGETIME_MIN  16
-#define MV_ATUCTL_AGETIME_MAX  4080
-#define MV_ATUCTL_AGETIME(_n)  ((((_n) / 16) & 0xff) << 4)
-       MV_ATUCTL_ATU_256   = (0 << 12),
-       MV_ATUCTL_ATU_512   = (1 << 12),
-       MV_ATUCTL_ATU_1K        = (2 << 12),
-       MV_ATUCTL_ATUMASK   = (3 << 12),
-       MV_ATUCTL_NO_LEARN  = (1 << 14),
-       MV_ATUCTL_RESET     = (1 << 15),
-};
-
-enum {
-#define MV_ATUOP_DBNUM(_n)     ((_n) & 0x0f)
-
-       MV_ATUOP_NOOP       = (0 << 12),
-       MV_ATUOP_FLUSH_ALL  = (1 << 12),
-       MV_ATUOP_FLUSH_U    = (2 << 12),
-       MV_ATUOP_LOAD_DB    = (3 << 12),
-       MV_ATUOP_GET_NEXT   = (4 << 12),
-       MV_ATUOP_FLUSH_DB   = (5 << 12),
-       MV_ATUOP_FLUSH_DB_UU= (6 << 12),
-
-       MV_ATUOP_INPROGRESS = (1 << 15),
-};
-
-#define MV_IDENT_MASK          0xfff0
-#define MV_IDENT_VALUE         0x0600
-
-#endif
diff --git a/target/linux/generic-2.6/files/drivers/spi/spi_gpio.c b/target/linux/generic-2.6/files/drivers/spi/spi_gpio.c
deleted file mode 100644 (file)
index 31048ac..0000000
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Bitbanging SPI bus driver using GPIO API
- *
- * Copyright (c) 2008 Piotr Skamruk
- * Copyright (c) 2008 Michael Buesch
- *
- * based on spi_s3c2410_gpio.c
- *   Copyright (c) 2006 Ben Dooks
- *   Copyright (c) 2006 Simtec Electronics
- * and on i2c-gpio.c
- *   Copyright (C) 2007 Atmel Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/spinlock.h>
-#include <linux/workqueue.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/spi_bitbang.h>
-#include "linux/spi/spi_gpio.h" //XXX
-#include <asm/gpio.h>
-
-
-struct spi_gpio {
-       struct spi_bitbang bitbang;
-       struct spi_gpio_platform_data *info;
-       struct platform_device *pdev;
-       struct spi_board_info bi;
-};
-
-
-static inline struct spi_gpio *spidev_to_sg(struct spi_device *dev)
-{
-       return dev->controller_data;
-}
-
-static inline void setsck(struct spi_device *dev, int val)
-{
-       struct spi_gpio *sp = spidev_to_sg(dev);
-       gpio_set_value(sp->info->pin_clk, val ? 1 : 0);
-}
-
-static inline void setmosi(struct spi_device *dev, int val )
-{
-       struct spi_gpio *sp = spidev_to_sg(dev);
-       gpio_set_value(sp->info->pin_mosi, val ? 1 : 0);
-}
-
-static inline u32 getmiso(struct spi_device *dev)
-{
-       struct spi_gpio *sp = spidev_to_sg(dev);
-       return gpio_get_value(sp->info->pin_miso) ? 1 : 0;
-}
-
-static inline void do_spidelay(struct spi_device *dev, unsigned nsecs)
-{
-       struct spi_gpio *sp = spidev_to_sg(dev);
-
-       if (!sp->info->no_spi_delay)
-               ndelay(nsecs);
-}
-
-#define spidelay(nsecs) do {                                   \
-       /* Steal the spi_device pointer from our caller.        \
-        * The bitbang-API should probably get fixed here... */ \
-       do_spidelay(spi, nsecs);                                \
-  } while (0)
-
-#define EXPAND_BITBANG_TXRX
-#include <linux/spi/spi_bitbang.h>
-
-static u32 spi_gpio_txrx_mode0(struct spi_device *spi,
-                              unsigned nsecs, u32 word, u8 bits)
-{
-        return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
-}
-
-static u32 spi_gpio_txrx_mode1(struct spi_device *spi,
-                              unsigned nsecs, u32 word, u8 bits)
-{
-        return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
-}
-
-static u32 spi_gpio_txrx_mode2(struct spi_device *spi,
-                              unsigned nsecs, u32 word, u8 bits)
-{
-        return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
-}
-
-static u32 spi_gpio_txrx_mode3(struct spi_device *spi,
-                              unsigned nsecs, u32 word, u8 bits)
-{
-        return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
-}
-
-static void spi_gpio_chipselect(struct spi_device *dev, int on)
-{
-       struct spi_gpio *sp = spidev_to_sg(dev);
-
-       if (sp->info->cs_activelow)
-               on = !on;
-       gpio_set_value(sp->info->pin_cs, on ? 1 : 0);
-}
-
-static int spi_gpio_probe(struct platform_device *pdev)
-{
-       struct spi_master *master;
-       struct spi_gpio_platform_data *pdata;
-       struct spi_gpio *sp;
-       struct spi_device *spidev;
-       int err;
-
-       pdata = pdev->dev.platform_data;
-       if (!pdata)
-               return -ENXIO;
-
-       err = -ENOMEM;
-       master = spi_alloc_master(&pdev->dev, sizeof(struct spi_gpio));
-       if (!master)
-               goto err_alloc_master;
-
-       sp = spi_master_get_devdata(master);
-       platform_set_drvdata(pdev, sp);
-       sp->info = pdata;
-
-       err = gpio_request(pdata->pin_clk, "spi_clock");
-       if (err)
-               goto err_request_clk;
-       err = gpio_request(pdata->pin_mosi, "spi_mosi");
-       if (err)
-               goto err_request_mosi;
-       err = gpio_request(pdata->pin_miso, "spi_miso");
-       if (err)
-               goto err_request_miso;
-       err = gpio_request(pdata->pin_cs, "spi_cs");
-       if (err)
-               goto err_request_cs;
-
-       sp->bitbang.master = spi_master_get(master);
-       sp->bitbang.master->bus_num = -1;
-       sp->bitbang.master->num_chipselect = 1;
-       sp->bitbang.chipselect = spi_gpio_chipselect;
-       sp->bitbang.txrx_word[SPI_MODE_0] = spi_gpio_txrx_mode0;
-       sp->bitbang.txrx_word[SPI_MODE_1] = spi_gpio_txrx_mode1;
-       sp->bitbang.txrx_word[SPI_MODE_2] = spi_gpio_txrx_mode2;
-       sp->bitbang.txrx_word[SPI_MODE_3] = spi_gpio_txrx_mode3;
-
-       gpio_direction_output(pdata->pin_clk, 0);
-       gpio_direction_output(pdata->pin_mosi, 0);
-       gpio_direction_output(pdata->pin_cs,
-                             pdata->cs_activelow ? 1 : 0);
-       gpio_direction_input(pdata->pin_miso);
-
-       err = spi_bitbang_start(&sp->bitbang);
-       if (err)
-               goto err_no_bitbang;
-       err = pdata->boardinfo_setup(&sp->bi, master,
-                                    pdata->boardinfo_setup_data);
-       if (err)
-               goto err_bi_setup;
-       sp->bi.controller_data = sp;
-       spidev = spi_new_device(master, &sp->bi);
-       if (!spidev)
-               goto err_new_dev;
-
-       return 0;
-
-err_new_dev:
-err_bi_setup:
-       spi_bitbang_stop(&sp->bitbang);
-err_no_bitbang:
-       spi_master_put(sp->bitbang.master);
-       gpio_free(pdata->pin_cs);
-err_request_cs:
-       gpio_free(pdata->pin_miso);
-err_request_miso:
-       gpio_free(pdata->pin_mosi);
-err_request_mosi:
-       gpio_free(pdata->pin_clk);
-err_request_clk:
-       kfree(master);
-
-err_alloc_master:
-       return err;
-}
-
-static int __devexit spi_gpio_remove(struct platform_device *pdev)
-{
-       struct spi_gpio *sp;
-       struct spi_gpio_platform_data *pdata;
-
-       pdata = pdev->dev.platform_data;
-       sp = platform_get_drvdata(pdev);
-
-       gpio_free(pdata->pin_clk);
-       gpio_free(pdata->pin_mosi);
-       gpio_free(pdata->pin_miso);
-       gpio_free(pdata->pin_cs);
-       spi_bitbang_stop(&sp->bitbang);
-       spi_master_put(sp->bitbang.master);
-
-       return 0;
-}
-
-static struct platform_driver spi_gpio_driver = {
-       .driver         = {
-               .name   = "spi-gpio",
-               .owner  = THIS_MODULE,
-       },
-       .probe          = spi_gpio_probe,
-       .remove         = __devexit_p(spi_gpio_remove),
-};
-
-static int __init spi_gpio_init(void)
-{
-       int err;
-
-       err = platform_driver_register(&spi_gpio_driver);
-       if (err)
-               printk(KERN_ERR "spi-gpio: register failed: %d\n", err);
-
-       return err;
-}
-module_init(spi_gpio_init);
-
-static void __exit spi_gpio_exit(void)
-{
-       platform_driver_unregister(&spi_gpio_driver);
-}
-module_exit(spi_gpio_exit);
-
-MODULE_AUTHOR("Piot Skamruk <piotr.skamruk at gmail.com>");
-MODULE_AUTHOR("Michael Buesch");
-MODULE_DESCRIPTION("Platform independent GPIO bitbangling SPI driver");
-MODULE_LICENSE("GPL v2");
diff --git a/target/linux/generic-2.6/files/drivers/ssb/Kconfig b/target/linux/generic-2.6/files/drivers/ssb/Kconfig
deleted file mode 100644 (file)
index d976660..0000000
+++ /dev/null
@@ -1,117 +0,0 @@
-menu "Sonics Silicon Backplane"
-
-config SSB_POSSIBLE
-       bool
-       depends on HAS_IOMEM
-       default y
-
-config SSB
-       tristate "Sonics Silicon Backplane support"
-       depends on SSB_POSSIBLE
-       help
-         Support for the Sonics Silicon Backplane bus.
-         You only need to enable this option, if you are
-         configuring a kernel for an embedded system with
-         this bus.
-         It will be auto-selected if needed in other
-         environments.
-
-         The module will be called ssb.
-
-         If unsure, say N.
-
-config SSB_PCIHOST_POSSIBLE
-       bool
-       depends on SSB && (PCI = y || PCI = SSB)
-       default y
-
-config SSB_PCIHOST
-       bool "Support for SSB on PCI-bus host"
-       depends on SSB_PCIHOST_POSSIBLE
-       default y
-       help
-         Support for a Sonics Silicon Backplane on top
-         of a PCI device.
-
-         If unsure, say Y
-
-config SSB_PCMCIAHOST_POSSIBLE
-       bool
-       depends on SSB && (PCMCIA = y || PCMCIA = SSB) && EXPERIMENTAL
-       default y
-
-config SSB_PCMCIAHOST
-       bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)"
-       depends on SSB_PCMCIAHOST_POSSIBLE
-       help
-         Support for a Sonics Silicon Backplane on top
-         of a PCMCIA device.
-
-         If unsure, say N
-
-config SSB_SILENT
-       bool "No SSB kernel messages"
-       depends on SSB && EMBEDDED
-       help
-         This option turns off all Sonics Silicon Backplane printks.
-         Note that you won't be able to identify problems, once
-         messages are turned off.
-         This might only be desired for production kernels on
-         embedded devices to reduce the kernel size.
-
-         Say N
-
-config SSB_DEBUG
-       bool "SSB debugging"
-       depends on SSB && !SSB_SILENT
-       help
-         This turns on additional runtime checks and debugging
-         messages. Turn this on for SSB troubleshooting.
-
-         If unsure, say N
-
-config SSB_SERIAL
-       bool
-       depends on SSB
-       # ChipCommon and ExtIf serial support routines.
-
-config SSB_DRIVER_PCICORE_POSSIBLE
-       bool
-       depends on SSB_PCIHOST
-       default y
-
-config SSB_DRIVER_PCICORE
-       bool "SSB PCI core driver"
-       depends on SSB_DRIVER_PCICORE_POSSIBLE
-       help
-         Driver for the Sonics Silicon Backplane attached
-         Broadcom PCI core.
-
-         If unsure, say Y
-
-config SSB_PCICORE_HOSTMODE
-       bool "Hostmode support for SSB PCI core (EXPERIMENTAL)"
-       depends on SSB_DRIVER_PCICORE && SSB_DRIVER_MIPS && EXPERIMENTAL
-       help
-         PCIcore hostmode operation (external PCI bus).
-
-config SSB_DRIVER_MIPS
-       bool "SSB Broadcom MIPS core driver (EXPERIMENTAL)"
-       depends on SSB && MIPS && EXPERIMENTAL
-       select SSB_SERIAL
-       help
-         Driver for the Sonics Silicon Backplane attached
-         Broadcom MIPS core.
-
-         If unsure, say N
-
-config SSB_DRIVER_EXTIF
-       bool "SSB Broadcom EXTIF core driver (EXPERIMENTAL)"
-       depends on SSB_DRIVER_MIPS && EXPERIMENTAL
-       help
-         Driver for the Sonics Silicon Backplane attached
-         Broadcom EXTIF core.
-
-         If unsure, say N
-
-endmenu
diff --git a/target/linux/generic-2.6/files/drivers/ssb/Makefile b/target/linux/generic-2.6/files/drivers/ssb/Makefile
deleted file mode 100644 (file)
index 7be3975..0000000
+++ /dev/null
@@ -1,18 +0,0 @@
-# core
-ssb-y                                  += main.o scan.o
-
-# host support
-ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o
-ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o
-
-# built-in drivers
-ssb-y                                  += driver_chipcommon.o
-ssb-$(CONFIG_SSB_DRIVER_MIPS)          += driver_mipscore.o
-ssb-$(CONFIG_SSB_DRIVER_EXTIF)         += driver_extif.o
-ssb-$(CONFIG_SSB_DRIVER_PCICORE)       += driver_pcicore.o
-
-# b43 pci-ssb-bridge driver
-# Not strictly a part of SSB, but kept here for convenience
-ssb-$(CONFIG_SSB_PCIHOST)              += b43_pci_bridge.o
-
-obj-$(CONFIG_SSB)                      += ssb.o
diff --git a/target/linux/generic-2.6/files/drivers/ssb/b43_pci_bridge.c b/target/linux/generic-2.6/files/drivers/ssb/b43_pci_bridge.c
deleted file mode 100644 (file)
index 2d27d6d..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Broadcom 43xx PCI-SSB bridge module
- *
- * This technically is a separate PCI driver module, but
- * because of its small size we include it in the SSB core
- * instead of creating a standalone module.
- *
- * Copyright 2007  Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/pci.h>
-#include <linux/ssb/ssb.h>
-
-#include "ssb_private.h"
-
-
-static const struct pci_device_id b43_pci_bridge_tbl[] = {
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4301) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4307) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4311) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4328) },
-       { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4329) },
-       { 0, },
-};
-MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl);
-
-static struct pci_driver b43_pci_bridge_driver = {
-       .name = "b43-pci-bridge",
-       .id_table = b43_pci_bridge_tbl,
-};
-
-
-int __init b43_pci_ssb_bridge_init(void)
-{
-       return ssb_pcihost_register(&b43_pci_bridge_driver);
-}
-
-void __exit b43_pci_ssb_bridge_exit(void)
-{
-       ssb_pcihost_unregister(&b43_pci_bridge_driver);
-}
diff --git a/target/linux/generic-2.6/files/drivers/ssb/driver_chipcommon.c b/target/linux/generic-2.6/files/drivers/ssb/driver_chipcommon.c
deleted file mode 100644 (file)
index 6fbf1c5..0000000
+++ /dev/null
@@ -1,445 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom ChipCommon core driver
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-#include <linux/ssb/ssb_regs.h>
-#include <linux/pci.h>
-
-#include "ssb_private.h"
-
-
-/* Clock sources */
-enum ssb_clksrc {
-       /* PCI clock */
-       SSB_CHIPCO_CLKSRC_PCI,
-       /* Crystal slow clock oscillator */
-       SSB_CHIPCO_CLKSRC_XTALOS,
-       /* Low power oscillator */
-       SSB_CHIPCO_CLKSRC_LOPWROS,
-};
-
-
-static inline u32 chipco_read32(struct ssb_chipcommon *cc,
-                               u16 offset)
-{
-       return ssb_read32(cc->dev, offset);
-}
-
-static inline void chipco_write32(struct ssb_chipcommon *cc,
-                                 u16 offset,
-                                 u32 value)
-{
-       ssb_write32(cc->dev, offset, value);
-}
-
-static inline void chipco_write32_masked(struct ssb_chipcommon *cc, u16 offset,
-                                        u32 mask, u32 value)
-{
-       value &= mask;
-       value |= chipco_read32(cc, offset) & ~mask;
-       chipco_write32(cc, offset, value);
-}
-
-void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc,
-                             enum ssb_clkmode mode)
-{
-       struct ssb_device *ccdev = cc->dev;
-       struct ssb_bus *bus;
-       u32 tmp;
-
-       if (!ccdev)
-               return;
-       bus = ccdev->bus;
-       /* chipcommon cores prior to rev6 don't support dynamic clock control */
-       if (ccdev->id.revision < 6)
-               return;
-       /* chipcommon cores rev10 are a whole new ball game */
-       if (ccdev->id.revision >= 10)
-               return;
-       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
-               return;
-
-       switch (mode) {
-       case SSB_CLKMODE_SLOW:
-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
-               tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW;
-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
-               break;
-       case SSB_CLKMODE_FAST:
-               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */
-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
-               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL;
-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
-               break;
-       case SSB_CLKMODE_DYNAMIC:
-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW;
-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL;
-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
-               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL)
-                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL;
-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp);
-
-               /* for dynamic control, we have to release our xtal_pu "force on" */
-               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL)
-                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0);
-               break;
-       default:
-               SSB_WARN_ON(1);
-       }
-}
-
-/* Get the Slow Clock Source */
-static enum ssb_clksrc chipco_pctl_get_slowclksrc(struct ssb_chipcommon *cc)
-{
-       struct ssb_bus *bus = cc->dev->bus;
-       u32 uninitialized_var(tmp);
-
-       if (cc->dev->id.revision < 6) {
-               if (bus->bustype == SSB_BUSTYPE_SSB ||
-                   bus->bustype == SSB_BUSTYPE_PCMCIA)
-                       return SSB_CHIPCO_CLKSRC_XTALOS;
-               if (bus->bustype == SSB_BUSTYPE_PCI) {
-                       pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT, &tmp);
-                       if (tmp & 0x10)
-                               return SSB_CHIPCO_CLKSRC_PCI;
-                       return SSB_CHIPCO_CLKSRC_XTALOS;
-               }
-       }
-       if (cc->dev->id.revision < 10) {
-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
-               tmp &= 0x7;
-               if (tmp == 0)
-                       return SSB_CHIPCO_CLKSRC_LOPWROS;
-               if (tmp == 1)
-                       return SSB_CHIPCO_CLKSRC_XTALOS;
-               if (tmp == 2)
-                       return SSB_CHIPCO_CLKSRC_PCI;
-       }
-
-       return SSB_CHIPCO_CLKSRC_XTALOS;
-}
-
-/* Get maximum or minimum (depending on get_max flag) slowclock frequency. */
-static int chipco_pctl_clockfreqlimit(struct ssb_chipcommon *cc, int get_max)
-{
-       int uninitialized_var(limit);
-       enum ssb_clksrc clocksrc;
-       int divisor = 1;
-       u32 tmp;
-
-       clocksrc = chipco_pctl_get_slowclksrc(cc);
-       if (cc->dev->id.revision < 6) {
-               switch (clocksrc) {
-               case SSB_CHIPCO_CLKSRC_PCI:
-                       divisor = 64;
-                       break;
-               case SSB_CHIPCO_CLKSRC_XTALOS:
-                       divisor = 32;
-                       break;
-               default:
-                       SSB_WARN_ON(1);
-               }
-       } else if (cc->dev->id.revision < 10) {
-               switch (clocksrc) {
-               case SSB_CHIPCO_CLKSRC_LOPWROS:
-                       break;
-               case SSB_CHIPCO_CLKSRC_XTALOS:
-               case SSB_CHIPCO_CLKSRC_PCI:
-                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL);
-                       divisor = (tmp >> 16) + 1;
-                       divisor *= 4;
-                       break;
-               }
-       } else {
-               tmp = chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL);
-               divisor = (tmp >> 16) + 1;
-               divisor *= 4;
-       }
-
-       switch (clocksrc) {
-       case SSB_CHIPCO_CLKSRC_LOPWROS:
-               if (get_max)
-                       limit = 43000;
-               else
-                       limit = 25000;
-               break;
-       case SSB_CHIPCO_CLKSRC_XTALOS:
-               if (get_max)
-                       limit = 20200000;
-               else
-                       limit = 19800000;
-               break;
-       case SSB_CHIPCO_CLKSRC_PCI:
-               if (get_max)
-                       limit = 34000000;
-               else
-                       limit = 25000000;
-               break;
-       }
-       limit /= divisor;
-
-       return limit;
-}
-
-static void chipco_powercontrol_init(struct ssb_chipcommon *cc)
-{
-       struct ssb_bus *bus = cc->dev->bus;
-
-       if (bus->chip_id == 0x4321) {
-               if (bus->chip_rev == 0)
-                       chipco_write32(cc, SSB_CHIPCO_CHIPCTL, 0x3A4);
-               else if (bus->chip_rev == 1)
-                       chipco_write32(cc, SSB_CHIPCO_CHIPCTL, 0xA4);
-       }
-
-       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
-               return;
-
-       if (cc->dev->id.revision >= 10) {
-               /* Set Idle Power clock rate to 1Mhz */
-               chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL,
-                              (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) &
-                               0x0000FFFF) | 0x00040000);
-       } else {
-               int maxfreq;
-
-               maxfreq = chipco_pctl_clockfreqlimit(cc, 1);
-               chipco_write32(cc, SSB_CHIPCO_PLLONDELAY,
-                              (maxfreq * 150 + 999999) / 1000000);
-               chipco_write32(cc, SSB_CHIPCO_FREFSELDELAY,
-                              (maxfreq * 15 + 999999) / 1000000);
-       }
-}
-
-static void calc_fast_powerup_delay(struct ssb_chipcommon *cc)
-{
-       struct ssb_bus *bus = cc->dev->bus;
-       int minfreq;
-       unsigned int tmp;
-       u32 pll_on_delay;
-
-       if (bus->bustype != SSB_BUSTYPE_PCI)
-               return;
-       if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL))
-               return;
-
-       minfreq = chipco_pctl_clockfreqlimit(cc, 0);
-       pll_on_delay = chipco_read32(cc, SSB_CHIPCO_PLLONDELAY);
-       tmp = (((pll_on_delay + 2) * 1000000) + (minfreq - 1)) / minfreq;
-       SSB_WARN_ON(tmp & ~0xFFFF);
-
-       cc->fast_pwrup_delay = tmp;
-}
-
-void ssb_chipcommon_init(struct ssb_chipcommon *cc)
-{
-       if (!cc->dev)
-               return; /* We don't have a ChipCommon */
-       chipco_powercontrol_init(cc);
-       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
-       calc_fast_powerup_delay(cc);
-}
-
-void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state)
-{
-       if (!cc->dev)
-               return;
-       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW);
-}
-
-void ssb_chipco_resume(struct ssb_chipcommon *cc)
-{
-       if (!cc->dev)
-               return;
-       chipco_powercontrol_init(cc);
-       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST);
-}
-
-/* Get the processor clock */
-void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc,
-                             u32 *plltype, u32 *n, u32 *m)
-{
-       *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N);
-       *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
-       switch (*plltype) {
-       case SSB_PLLTYPE_2:
-       case SSB_PLLTYPE_4:
-       case SSB_PLLTYPE_6:
-       case SSB_PLLTYPE_7:
-               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS);
-               break;
-       case SSB_PLLTYPE_3:
-               /* 5350 uses m2 to control mips */
-               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2);
-               break;
-       default:
-               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB);
-               break;
-       }
-}
-
-/* Get the bus clock */
-void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc,
-                                u32 *plltype, u32 *n, u32 *m)
-{
-       *n = chipco_read32(cc, SSB_CHIPCO_CLOCK_N);
-       *plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
-       switch (*plltype) {
-       case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */
-               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_MIPS);
-               break;
-       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
-               if (cc->dev->bus->chip_id != 0x5365) {
-                       *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_M2);
-                       break;
-               }
-               /* Fallthough */
-       default:
-               *m = chipco_read32(cc, SSB_CHIPCO_CLOCK_SB);
-       }
-}
-
-void ssb_chipco_timing_init(struct ssb_chipcommon *cc,
-                           unsigned long ns)
-{
-       struct ssb_device *dev = cc->dev;
-       struct ssb_bus *bus = dev->bus;
-       u32 tmp;
-
-       /* set register for external IO to control LED. */
-       chipco_write32(cc, SSB_CHIPCO_PROG_CFG, 0x11);
-       tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;            /* Waitcount-3 = 10ns */
-       tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT;   /* Waitcount-1 = 40ns */
-       tmp |= DIV_ROUND_UP(240, ns);                           /* Waitcount-0 = 240ns */
-       chipco_write32(cc, SSB_CHIPCO_PROG_WAITCNT, tmp);       /* 0x01020a0c for a 100Mhz clock */
-
-       /* Set timing for the flash */
-       tmp = DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_3_SHIFT;   /* Waitcount-3 = 10nS */
-       tmp |= DIV_ROUND_UP(10, ns) << SSB_FLASH_WCNT_1_SHIFT;  /* Waitcount-1 = 10nS */
-       tmp |= DIV_ROUND_UP(120, ns);                           /* Waitcount-0 = 120nS */
-       if ((bus->chip_id == 0x5365) ||
-           (dev->id.revision < 9))
-               chipco_write32(cc, SSB_CHIPCO_FLASH_WAITCNT, tmp);
-       if ((bus->chip_id == 0x5365) ||
-           (dev->id.revision < 9) ||
-           ((bus->chip_id == 0x5350) && (bus->chip_rev == 0)))
-               chipco_write32(cc, SSB_CHIPCO_PCMCIA_MEMWAIT, tmp);
-
-       if (bus->chip_id == 0x5350) {
-               /* Enable EXTIF */
-               tmp = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;      /* Waitcount-3 = 10ns */
-               tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT;  /* Waitcount-2 = 20ns */
-               tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT; /* Waitcount-1 = 100ns */
-               tmp |= DIV_ROUND_UP(120, ns);                     /* Waitcount-0 = 120ns */
-               chipco_write32(cc, SSB_CHIPCO_PROG_WAITCNT, tmp); /* 0x01020a0c for a 100Mhz clock */
-       }
-}
-
-/* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
-void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc, u32 ticks)
-{
-       /* instant NMI */
-       chipco_write32(cc, SSB_CHIPCO_WATCHDOG, ticks);
-}
-
-u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask)
-{
-       return chipco_read32(cc, SSB_CHIPCO_GPIOIN) & mask;
-}
-
-void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value)
-{
-       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUT, mask, value);
-}
-
-void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value)
-{
-       chipco_write32_masked(cc, SSB_CHIPCO_GPIOOUTEN, mask, value);
-}
-
-#ifdef CONFIG_SSB_SERIAL
-int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
-                          struct ssb_serial_port *ports)
-{
-       struct ssb_bus *bus = cc->dev->bus;
-       int nr_ports = 0;
-       u32 plltype;
-       unsigned int irq;
-       u32 baud_base, div;
-       u32 i, n;
-
-       plltype = (cc->capabilities & SSB_CHIPCO_CAP_PLLT);
-       irq = ssb_mips_irq(cc->dev);
-
-       if (plltype == SSB_PLLTYPE_1) {
-               /* PLL clock */
-               baud_base = ssb_calc_clock_rate(plltype,
-                                               chipco_read32(cc, SSB_CHIPCO_CLOCK_N),
-                                               chipco_read32(cc, SSB_CHIPCO_CLOCK_M2));
-               div = 1;
-       } else {
-               if (cc->dev->id.revision >= 11) {
-                       /* Fixed ALP clock */
-                       baud_base = 20000000;
-                       div = 1;
-                       /* Set the override bit so we don't divide it */
-                       chipco_write32(cc, SSB_CHIPCO_CORECTL,
-                                      SSB_CHIPCO_CORECTL_UARTCLK0);
-               } else if (cc->dev->id.revision >= 3) {
-                       /* Internal backplane clock */
-                       baud_base = ssb_clockspeed(bus);
-                       div = chipco_read32(cc, SSB_CHIPCO_CLKDIV)
-                             & SSB_CHIPCO_CLKDIV_UART;
-               } else {
-                       /* Fixed internal backplane clock */
-                       baud_base = 88000000;
-                       div = 48;
-               }
-
-               /* Clock source depends on strapping if UartClkOverride is unset */
-               if ((cc->dev->id.revision > 0) &&
-                   !(chipco_read32(cc, SSB_CHIPCO_CORECTL) & SSB_CHIPCO_CORECTL_UARTCLK0)) {
-                       if ((cc->capabilities & SSB_CHIPCO_CAP_UARTCLK) ==
-                           SSB_CHIPCO_CAP_UARTCLK_INT) {
-                               /* Internal divided backplane clock */
-                               baud_base /= div;
-                       } else {
-                               /* Assume external clock of 1.8432 MHz */
-                               baud_base = 1843200;
-                       }
-               }
-       }
-
-       /* Determine the registers of the UARTs */
-       n = (cc->capabilities & SSB_CHIPCO_CAP_NRUART);
-       for (i = 0; i < n; i++) {
-               void __iomem *cc_mmio;
-               void __iomem *uart_regs;
-
-               cc_mmio = cc->dev->bus->mmio + (cc->dev->core_index * SSB_CORE_SIZE);
-               uart_regs = cc_mmio + SSB_CHIPCO_UART0_DATA;
-               /* Offset changed at after rev 0 */
-               if (cc->dev->id.revision == 0)
-                       uart_regs += (i * 8);
-               else
-                       uart_regs += (i * 256);
-
-               nr_ports++;
-               ports[i].regs = uart_regs;
-               ports[i].irq = irq;
-               ports[i].baud_base = baud_base;
-               ports[i].reg_shift = 0;
-       }
-
-       return nr_ports;
-}
-#endif /* CONFIG_SSB_SERIAL */
diff --git a/target/linux/generic-2.6/files/drivers/ssb/driver_extif.c b/target/linux/generic-2.6/files/drivers/ssb/driver_extif.c
deleted file mode 100644 (file)
index fe55eb8..0000000
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom EXTIF core driver
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
- * Copyright 2006, 2007, Felix Fietkau <nbd@openwrt.org>
- * Copyright 2007, Aurelien Jarno <aurelien@aurel32.net>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/serial.h>
-#include <linux/serial_core.h>
-#include <linux/serial_reg.h>
-
-#include "ssb_private.h"
-
-
-static inline u32 extif_read32(struct ssb_extif *extif, u16 offset)
-{
-       return ssb_read32(extif->dev, offset);
-}
-
-static inline void extif_write32(struct ssb_extif *extif, u16 offset, u32 value)
-{
-       ssb_write32(extif->dev, offset, value);
-}
-
-static inline void extif_write32_masked(struct ssb_extif *extif, u16 offset,
-                                       u32 mask, u32 value)
-{
-       value &= mask;
-       value |= extif_read32(extif, offset) & ~mask;
-       extif_write32(extif, offset, value);
-}
-
-#ifdef CONFIG_SSB_SERIAL
-static bool serial_exists(u8 *regs)
-{
-       u8 save_mcr, msr = 0;
-
-       if (regs) {
-               save_mcr = regs[UART_MCR];
-               regs[UART_MCR] = (UART_MCR_LOOP | UART_MCR_OUT2 | UART_MCR_RTS);
-               msr = regs[UART_MSR] & (UART_MSR_DCD | UART_MSR_RI
-                                       | UART_MSR_CTS | UART_MSR_DSR);
-               regs[UART_MCR] = save_mcr;
-       }
-       return (msr == (UART_MSR_DCD | UART_MSR_CTS));
-}
-
-int ssb_extif_serial_init(struct ssb_extif *extif, struct ssb_serial_port *ports)
-{
-       u32 i, nr_ports = 0;
-
-       /* Disable GPIO interrupt initially */
-       extif_write32(extif, SSB_EXTIF_GPIO_INTPOL, 0);
-       extif_write32(extif, SSB_EXTIF_GPIO_INTMASK, 0);
-
-       for (i = 0; i < 2; i++) {
-               void __iomem *uart_regs;
-
-               uart_regs = ioremap_nocache(SSB_EUART, 16);
-               if (uart_regs) {
-                       uart_regs += (i * 8);
-
-                       if (serial_exists(uart_regs) && ports) {
-                               extif_write32(extif, SSB_EXTIF_GPIO_INTMASK, 2);
-
-                               nr_ports++;
-                               ports[i].regs = uart_regs;
-                               ports[i].irq = 2;
-                               ports[i].baud_base = 13500000;
-                               ports[i].reg_shift = 0;
-                       }
-                       iounmap(uart_regs);
-               }
-       }
-       return nr_ports;
-}
-#endif /* CONFIG_SSB_SERIAL */
-
-void ssb_extif_timing_init(struct ssb_extif *extif, unsigned long ns)
-{
-       u32 tmp;
-
-       /* Initialize extif so we can get to the LEDs and external UART */
-       extif_write32(extif, SSB_EXTIF_PROG_CFG, SSB_EXTCFG_EN);
-
-       /* Set timing for the flash */
-       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;
-       tmp |= DIV_ROUND_UP(40, ns) << SSB_PROG_WCNT_1_SHIFT;
-       tmp |= DIV_ROUND_UP(120, ns);
-       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp);
-
-       /* Set programmable interface timing for external uart */
-       tmp  = DIV_ROUND_UP(10, ns) << SSB_PROG_WCNT_3_SHIFT;
-       tmp |= DIV_ROUND_UP(20, ns) << SSB_PROG_WCNT_2_SHIFT;
-       tmp |= DIV_ROUND_UP(100, ns) << SSB_PROG_WCNT_1_SHIFT;
-       tmp |= DIV_ROUND_UP(120, ns);
-       extif_write32(extif, SSB_EXTIF_PROG_WAITCNT, tmp);
-}
-
-void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
-                               u32 *pll_type, u32 *n, u32 *m)
-{
-       *pll_type = SSB_PLLTYPE_1;
-       *n = extif_read32(extif, SSB_EXTIF_CLOCK_N);
-       *m = extif_read32(extif, SSB_EXTIF_CLOCK_SB);
-}
-
-u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask)
-{
-       return extif_read32(extif, SSB_EXTIF_GPIO_IN) & mask;
-}
-
-void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value)
-{
-       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUT(0),
-                                  mask, value);
-}
-
-void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value)
-{
-       return extif_write32_masked(extif, SSB_EXTIF_GPIO_OUTEN(0),
-                                  mask, value);
-}
-
diff --git a/target/linux/generic-2.6/files/drivers/ssb/driver_mipscore.c b/target/linux/generic-2.6/files/drivers/ssb/driver_mipscore.c
deleted file mode 100644 (file)
index a9e7eb4..0000000
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom MIPS core driver
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-
-#include <linux/serial.h>
-#include <linux/serial_core.h>
-#include <linux/serial_reg.h>
-#include <linux/time.h>
-
-#include "ssb_private.h"
-
-
-static inline u32 mips_read32(struct ssb_mipscore *mcore,
-                             u16 offset)
-{
-       return ssb_read32(mcore->dev, offset);
-}
-
-static inline void mips_write32(struct ssb_mipscore *mcore,
-                               u16 offset,
-                               u32 value)
-{
-       ssb_write32(mcore->dev, offset, value);
-}
-
-static const u32 ipsflag_irq_mask[] = {
-       0,
-       SSB_IPSFLAG_IRQ1,
-       SSB_IPSFLAG_IRQ2,
-       SSB_IPSFLAG_IRQ3,
-       SSB_IPSFLAG_IRQ4,
-};
-
-static const u32 ipsflag_irq_shift[] = {
-       0,
-       SSB_IPSFLAG_IRQ1_SHIFT,
-       SSB_IPSFLAG_IRQ2_SHIFT,
-       SSB_IPSFLAG_IRQ3_SHIFT,
-       SSB_IPSFLAG_IRQ4_SHIFT,
-};
-
-static inline u32 ssb_irqflag(struct ssb_device *dev)
-{
-       return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG;
-}
-
-/* Get the MIPS IRQ assignment for a specified device.
- * If unassigned, 0 is returned.
- */
-unsigned int ssb_mips_irq(struct ssb_device *dev)
-{
-       struct ssb_bus *bus = dev->bus;
-       u32 irqflag;
-       u32 ipsflag;
-       u32 tmp;
-       unsigned int irq;
-
-       irqflag = ssb_irqflag(dev);
-       ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG);
-       for (irq = 1; irq <= 4; irq++) {
-               tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]);
-               if (tmp == irqflag)
-                       break;
-       }
-       if (irq == 5)
-               irq = 0;
-
-       return irq;
-}
-
-static void clear_irq(struct ssb_bus *bus, unsigned int irq)
-{
-       struct ssb_device *dev = bus->mipscore.dev;
-
-       /* Clear the IRQ in the MIPScore backplane registers */
-       if (irq == 0) {
-               ssb_write32(dev, SSB_INTVEC, 0);
-       } else {
-               ssb_write32(dev, SSB_IPSFLAG,
-                           ssb_read32(dev, SSB_IPSFLAG) |
-                           ipsflag_irq_mask[irq]);
-       }
-}
-
-static void set_irq(struct ssb_device *dev, unsigned int irq)
-{
-       unsigned int oldirq = ssb_mips_irq(dev);
-       struct ssb_bus *bus = dev->bus;
-       struct ssb_device *mdev = bus->mipscore.dev;
-       u32 irqflag = ssb_irqflag(dev);
-
-       dev->irq = irq + 2;
-
-       ssb_dprintk(KERN_INFO PFX
-                   "set_irq: core 0x%04x, irq %d => %d\n",
-                   dev->id.coreid, oldirq, irq);
-       /* clear the old irq */
-       if (oldirq == 0)
-               ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)));
-       else
-               clear_irq(bus, oldirq);
-
-       /* assign the new one */
-       if (irq == 0) {
-               ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC)));
-       } else {
-               irqflag <<= ipsflag_irq_shift[irq];
-               irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]);
-               ssb_write32(mdev, SSB_IPSFLAG, irqflag);
-       }
-}
-
-static void ssb_mips_serial_init(struct ssb_mipscore *mcore)
-{
-       struct ssb_bus *bus = mcore->dev->bus;
-
-       if (bus->extif.dev)
-               mcore->nr_serial_ports = ssb_extif_serial_init(&bus->extif, mcore->serial_ports);
-       else if (bus->chipco.dev)
-               mcore->nr_serial_ports = ssb_chipco_serial_init(&bus->chipco, mcore->serial_ports);
-       else
-               mcore->nr_serial_ports = 0;
-}
-
-static void ssb_mips_flash_detect(struct ssb_mipscore *mcore)
-{
-       struct ssb_bus *bus = mcore->dev->bus;
-
-       mcore->flash_buswidth = 2;
-       if (bus->chipco.dev) {
-               mcore->flash_window = 0x1c000000;
-               mcore->flash_window_size = 0x02000000;
-               if ((ssb_read32(bus->chipco.dev, SSB_CHIPCO_FLASH_CFG)
-                              & SSB_CHIPCO_CFG_DS16) == 0)
-                       mcore->flash_buswidth = 1;
-       } else {
-               mcore->flash_window = 0x1fc00000;
-               mcore->flash_window_size = 0x00400000;
-       }
-}
-
-u32 ssb_cpu_clock(struct ssb_mipscore *mcore)
-{
-       struct ssb_bus *bus = mcore->dev->bus;
-       u32 pll_type, n, m, rate = 0;
-
-       if (bus->extif.dev) {
-               ssb_extif_get_clockcontrol(&bus->extif, &pll_type, &n, &m);
-       } else if (bus->chipco.dev) {
-               ssb_chipco_get_clockcpu(&bus->chipco, &pll_type, &n, &m);
-       } else
-               return 0;
-
-       if ((pll_type == SSB_PLLTYPE_5) || (bus->chip_id == 0x5365)) {
-               rate = 200000000;
-       } else {
-               rate = ssb_calc_clock_rate(pll_type, n, m);
-       }
-
-       if (pll_type == SSB_PLLTYPE_6) {
-               rate *= 2;
-       }
-
-       return rate;
-}
-
-void ssb_mipscore_init(struct ssb_mipscore *mcore)
-{
-       struct ssb_bus *bus;
-       struct ssb_device *dev;
-       unsigned long hz, ns;
-       unsigned int irq, i;
-
-       if (!mcore->dev)
-               return; /* We don't have a MIPS core */
-
-       ssb_dprintk(KERN_INFO PFX "Initializing MIPS core...\n");
-
-       bus = mcore->dev->bus;
-       hz = ssb_clockspeed(bus);
-       if (!hz)
-               hz = 100000000;
-       ns = 1000000000 / hz;
-
-       if (bus->extif.dev)
-               ssb_extif_timing_init(&bus->extif, ns);
-       else if (bus->chipco.dev)
-               ssb_chipco_timing_init(&bus->chipco, ns);
-
-       /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */
-       for (irq = 2, i = 0; i < bus->nr_devices; i++) {
-               dev = &(bus->devices[i]);
-               dev->irq = ssb_mips_irq(dev) + 2;
-               switch (dev->id.coreid) {
-               case SSB_DEV_USB11_HOST:
-                       /* shouldn't need a separate irq line for non-4710, most of them have a proper
-                        * external usb controller on the pci */
-                       if ((bus->chip_id == 0x4710) && (irq <= 4)) {
-                               set_irq(dev, irq++);
-                               break;
-                       }
-                       /* fallthrough */
-               case SSB_DEV_PCI:
-               case SSB_DEV_ETHERNET:
-               case SSB_DEV_80211:
-               case SSB_DEV_USB20_HOST:
-                       /* These devices get their own IRQ line if available, the rest goes on IRQ0 */
-                       if (irq <= 4) {
-                               set_irq(dev, irq++);
-                               break;
-                       }
-               }
-       }
-
-       ssb_mips_serial_init(mcore);
-       ssb_mips_flash_detect(mcore);
-}
diff --git a/target/linux/generic-2.6/files/drivers/ssb/driver_pcicore.c b/target/linux/generic-2.6/files/drivers/ssb/driver_pcicore.c
deleted file mode 100644 (file)
index 2faaa90..0000000
+++ /dev/null
@@ -1,576 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Broadcom PCI-core driver
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-
-#include "ssb_private.h"
-
-
-static inline
-u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset)
-{
-       return ssb_read32(pc->dev, offset);
-}
-
-static inline
-void pcicore_write32(struct ssb_pcicore *pc, u16 offset, u32 value)
-{
-       ssb_write32(pc->dev, offset, value);
-}
-
-/**************************************************
- * Code for hostmode operation.
- **************************************************/
-
-#ifdef CONFIG_SSB_PCICORE_HOSTMODE
-
-#include <asm/paccess.h>
-/* Probe a 32bit value on the bus and catch bus exceptions.
- * Returns nonzero on a bus exception.
- * This is MIPS specific */
-#define mips_busprobe32(val, addr)     get_dbe((val), ((u32 *)(addr)))
-
-/* Assume one-hot slot wiring */
-#define SSB_PCI_SLOT_MAX       16
-
-/* Global lock is OK, as we won't have more than one extpci anyway. */
-static DEFINE_SPINLOCK(cfgspace_lock);
-/* Core to access the external PCI config space. Can only have one. */
-static struct ssb_pcicore *extpci_core;
-
-static u32 ssb_pcicore_pcibus_iobase = 0x100;
-static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA;
-
-int pcibios_plat_dev_init(struct pci_dev *d)
-{
-       struct resource *res;
-       int pos, size;
-       u32 *base;
-
-       ssb_printk(KERN_INFO "PCI: Fixing up device %s\n",
-                  pci_name(d));
-
-       /* Fix up resource bases */
-       for (pos = 0; pos < 6; pos++) {
-               res = &d->resource[pos];
-               if (res->flags & IORESOURCE_IO)
-                       base = &ssb_pcicore_pcibus_iobase;
-               else
-                       base = &ssb_pcicore_pcibus_membase;
-               if (res->end) {
-                       size = res->end - res->start + 1;
-                       if (*base & (size - 1))
-                               *base = (*base + size) & ~(size - 1);
-                       res->start = *base;
-                       res->end = res->start + size - 1;
-                       *base += size;
-                       pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start);
-               }
-               /* Fix up PCI bridge BAR0 only */
-               if (d->bus->number == 0 && PCI_SLOT(d->devfn) == 0)
-                       break;
-       }
-       /* Fix up interrupt lines */
-       d->irq = ssb_mips_irq(extpci_core->dev) + 2;
-       pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq);
-
-       return 0;
-}
-
-static void __init ssb_fixup_pcibridge(struct pci_dev *dev)
-{
-       if (dev->bus->number != 0 || PCI_SLOT(dev->devfn) != 0)
-               return;
-
-       ssb_printk(KERN_INFO "PCI: fixing up bridge\n");
-
-       /* Enable PCI bridge bus mastering and memory space */
-       pci_set_master(dev);
-       pcibios_enable_device(dev, ~0);
-
-       /* Enable PCI bridge BAR1 prefetch and burst */
-       pci_write_config_dword(dev, SSB_BAR1_CONTROL, 3);
-
-       /* Make sure our latency is high enough to handle the devices behind us */
-       pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0xa8);
-}
-DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, ssb_fixup_pcibridge);
-
-int __init pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
-{
-       return ssb_mips_irq(extpci_core->dev) + 2;
-}
-
-static u32 get_cfgspace_addr(struct ssb_pcicore *pc,
-                            unsigned int bus, unsigned int dev,
-                            unsigned int func, unsigned int off)
-{
-       u32 addr = 0;
-       u32 tmp;
-
-       if (unlikely(pc->cardbusmode && dev > 1))
-               goto out;
-       if (bus == 0) {
-               /* Type 0 transaction */
-               if (unlikely(dev >= SSB_PCI_SLOT_MAX))
-                       goto out;
-               /* Slide the window */
-               tmp = SSB_PCICORE_SBTOPCI_CFG0;
-               tmp |= ((1 << (dev + 16)) & SSB_PCICORE_SBTOPCI1_MASK);
-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI1, tmp);
-               /* Calculate the address */
-               addr = SSB_PCI_CFG;
-               addr |= ((1 << (dev + 16)) & ~SSB_PCICORE_SBTOPCI1_MASK);
-               addr |= (func << 8);
-               addr |= (off & ~3);
-       } else {
-               /* Type 1 transaction */
-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI1,
-                               SSB_PCICORE_SBTOPCI_CFG1);
-               /* Calculate the address */
-               addr = SSB_PCI_CFG;
-               addr |= (bus << 16);
-               addr |= (dev << 11);
-               addr |= (func << 8);
-               addr |= (off & ~3);
-       }
-out:
-       return addr;
-}
-
-static int ssb_extpci_read_config(struct ssb_pcicore *pc,
-                                 unsigned int bus, unsigned int dev,
-                                 unsigned int func, unsigned int off,
-                                 void *buf, int len)
-{
-       int err = -EINVAL;
-       u32 addr, val;
-       void __iomem *mmio;
-
-       SSB_WARN_ON(!pc->hostmode);
-       if (unlikely(len != 1 && len != 2 && len != 4))
-               goto out;
-       addr = get_cfgspace_addr(pc, bus, dev, func, off);
-       if (unlikely(!addr))
-               goto out;
-       err = -ENOMEM;
-       mmio = ioremap_nocache(addr, len);
-       if (!mmio)
-               goto out;
-
-       if (mips_busprobe32(val, mmio)) {
-               val = 0xffffffff;
-               goto unmap;
-       }
-
-       val = readl(mmio);
-       val >>= (8 * (off & 3));
-
-       switch (len) {
-       case 1:
-               *((u8 *)buf) = (u8)val;
-               break;
-       case 2:
-               *((u16 *)buf) = (u16)val;
-               break;
-       case 4:
-               *((u32 *)buf) = (u32)val;
-               break;
-       }
-       err = 0;
-unmap:
-       iounmap(mmio);
-out:
-       return err;
-}
-
-static int ssb_extpci_write_config(struct ssb_pcicore *pc,
-                                  unsigned int bus, unsigned int dev,
-                                  unsigned int func, unsigned int off,
-                                  const void *buf, int len)
-{
-       int err = -EINVAL;
-       u32 addr, val = 0;
-       void __iomem *mmio;
-
-       SSB_WARN_ON(!pc->hostmode);
-       if (unlikely(len != 1 && len != 2 && len != 4))
-               goto out;
-       addr = get_cfgspace_addr(pc, bus, dev, func, off);
-       if (unlikely(!addr))
-               goto out;
-       err = -ENOMEM;
-       mmio = ioremap_nocache(addr, len);
-       if (!mmio)
-               goto out;
-
-       if (mips_busprobe32(val, mmio)) {
-               val = 0xffffffff;
-               goto unmap;
-       }
-
-       switch (len) {
-       case 1:
-               val = readl(mmio);
-               val &= ~(0xFF << (8 * (off & 3)));
-               val |= *((const u8 *)buf) << (8 * (off & 3));
-               break;
-       case 2:
-               val = readl(mmio);
-               val &= ~(0xFFFF << (8 * (off & 3)));
-               val |= *((const u16 *)buf) << (8 * (off & 3));
-               break;
-       case 4:
-               val = *((const u32 *)buf);
-               break;
-       }
-       writel(val, mmio);
-
-       err = 0;
-unmap:
-       iounmap(mmio);
-out:
-       return err;
-}
-
-static int ssb_pcicore_read_config(struct pci_bus *bus, unsigned int devfn,
-                                  int reg, int size, u32 *val)
-{
-       unsigned long flags;
-       int err;
-
-       spin_lock_irqsave(&cfgspace_lock, flags);
-       err = ssb_extpci_read_config(extpci_core, bus->number, PCI_SLOT(devfn),
-                                    PCI_FUNC(devfn), reg, val, size);
-       spin_unlock_irqrestore(&cfgspace_lock, flags);
-
-       return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
-}
-
-static int ssb_pcicore_write_config(struct pci_bus *bus, unsigned int devfn,
-                                   int reg, int size, u32 val)
-{
-       unsigned long flags;
-       int err;
-
-       spin_lock_irqsave(&cfgspace_lock, flags);
-       err = ssb_extpci_write_config(extpci_core, bus->number, PCI_SLOT(devfn),
-                                     PCI_FUNC(devfn), reg, &val, size);
-       spin_unlock_irqrestore(&cfgspace_lock, flags);
-
-       return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
-}
-
-static struct pci_ops ssb_pcicore_pciops = {
-       .read   = ssb_pcicore_read_config,
-       .write  = ssb_pcicore_write_config,
-};
-
-static struct resource ssb_pcicore_mem_resource = {
-       .name   = "SSB PCIcore external memory",
-       .start  = SSB_PCI_DMA,
-       .end    = SSB_PCI_DMA + SSB_PCI_DMA_SZ - 1,
-       .flags  = IORESOURCE_MEM,
-};
-
-static struct resource ssb_pcicore_io_resource = {
-       .name   = "SSB PCIcore external I/O",
-       .start  = 0x100,
-       .end    = 0x7FF,
-       .flags  = IORESOURCE_IO,
-};
-
-static struct pci_controller ssb_pcicore_controller = {
-       .pci_ops        = &ssb_pcicore_pciops,
-       .io_resource    = &ssb_pcicore_io_resource,
-       .mem_resource   = &ssb_pcicore_mem_resource,
-       .mem_offset     = 0x24000000,
-};
-
-static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc)
-{
-       u32 val;
-
-       if (WARN_ON(extpci_core))
-               return;
-       extpci_core = pc;
-
-       ssb_dprintk(KERN_INFO PFX "PCIcore in host mode found\n");
-       /* Reset devices on the external PCI bus */
-       val = SSB_PCICORE_CTL_RST_OE;
-       val |= SSB_PCICORE_CTL_CLK_OE;
-       pcicore_write32(pc, SSB_PCICORE_CTL, val);
-       val |= SSB_PCICORE_CTL_CLK; /* Clock on */
-       pcicore_write32(pc, SSB_PCICORE_CTL, val);
-       udelay(150); /* Assertion time demanded by the PCI standard */
-       val |= SSB_PCICORE_CTL_RST; /* Deassert RST# */
-       pcicore_write32(pc, SSB_PCICORE_CTL, val);
-       val = SSB_PCICORE_ARBCTL_INTERN;
-       pcicore_write32(pc, SSB_PCICORE_ARBCTL, val);
-       udelay(1); /* Assertion time demanded by the PCI standard */
-
-       /*TODO cardbus mode */
-
-       /* 64MB I/O window */
-       pcicore_write32(pc, SSB_PCICORE_SBTOPCI0,
-                       SSB_PCICORE_SBTOPCI_IO);
-       /* 64MB config space */
-       pcicore_write32(pc, SSB_PCICORE_SBTOPCI1,
-                       SSB_PCICORE_SBTOPCI_CFG0);
-       /* 1GB memory window */
-       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2,
-                       SSB_PCICORE_SBTOPCI_MEM | SSB_PCI_DMA);
-
-       /* Enable PCI bridge BAR0 prefetch and burst */
-       val = PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
-       ssb_extpci_write_config(pc, 0, 0, 0, PCI_COMMAND, &val, 2);
-       /* Clear error conditions */
-       val = 0;
-       ssb_extpci_write_config(pc, 0, 0, 0, PCI_STATUS, &val, 2);
-
-       /* Enable PCI interrupts */
-       pcicore_write32(pc, SSB_PCICORE_IMASK,
-                       SSB_PCICORE_IMASK_INTA);
-
-       /* Ok, ready to run, register it to the system.
-        * The following needs change, if we want to port hostmode
-        * to non-MIPS platform. */
-       set_io_port_base((unsigned long)ioremap_nocache(SSB_PCI_MEM, 0x04000000));
-       /* Give some time to the PCI controller to configure itself with the new
-        * values. Not waiting at this point causes crashes of the machine. */
-       mdelay(10);
-       register_pci_controller(&ssb_pcicore_controller);
-}
-
-static int pcicore_is_in_hostmode(struct ssb_pcicore *pc)
-{
-       struct ssb_bus *bus = pc->dev->bus;
-       u16 chipid_top;
-       u32 tmp;
-
-       chipid_top = (bus->chip_id & 0xFF00);
-       if (chipid_top != 0x4700 &&
-           chipid_top != 0x5300)
-               return 0;
-
-       if (bus->sprom.r1.boardflags_lo & SSB_PCICORE_BFL_NOPCI)
-               return 0;
-
-       /* The 200-pin BCM4712 package does not bond out PCI. Even when
-        * PCI is bonded out, some boards may leave the pins floating. */
-       if (bus->chip_id == 0x4712) {
-               if (bus->chip_package == SSB_CHIPPACK_BCM4712S)
-                       return 0;
-               if (bus->chip_package == SSB_CHIPPACK_BCM4712M)
-                       return 0;
-       }
-       if (bus->chip_id == 0x5350)
-               return 0;
-
-       return !mips_busprobe32(tmp, (bus->mmio + (pc->dev->core_index * SSB_CORE_SIZE)));
-}
-#endif /* CONFIG_SSB_PCICORE_HOSTMODE */
-
-
-/**************************************************
- * Generic and Clientmode operation code.
- **************************************************/
-
-static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc)
-{
-       /* Disable PCI interrupts. */
-       ssb_write32(pc->dev, SSB_INTVEC, 0);
-}
-
-void ssb_pcicore_init(struct ssb_pcicore *pc)
-{
-       struct ssb_device *dev = pc->dev;
-       struct ssb_bus *bus;
-
-       if (!dev)
-               return;
-       bus = dev->bus;
-       if (!ssb_device_is_enabled(dev))
-               ssb_device_enable(dev, 0);
-
-#ifdef CONFIG_SSB_PCICORE_HOSTMODE
-       pc->hostmode = pcicore_is_in_hostmode(pc);
-       if (pc->hostmode)
-               ssb_pcicore_init_hostmode(pc);
-#endif /* CONFIG_SSB_PCICORE_HOSTMODE */
-       if (!pc->hostmode)
-               ssb_pcicore_init_clientmode(pc);
-}
-
-static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address)
-{
-       pcicore_write32(pc, 0x130, address);
-       return pcicore_read32(pc, 0x134);
-}
-
-static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data)
-{
-       pcicore_write32(pc, 0x130, address);
-       pcicore_write32(pc, 0x134, data);
-}
-
-static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device,
-                               u8 address, u16 data)
-{
-       const u16 mdio_control = 0x128;
-       const u16 mdio_data = 0x12C;
-       u32 v;
-       int i;
-
-       v = 0x80; /* Enable Preamble Sequence */
-       v |= 0x2; /* MDIO Clock Divisor */
-       pcicore_write32(pc, mdio_control, v);
-
-       v = (1 << 30); /* Start of Transaction */
-       v |= (1 << 28); /* Write Transaction */
-       v |= (1 << 17); /* Turnaround */
-       v |= (u32)device << 22;
-       v |= (u32)address << 18;
-       v |= data;
-       pcicore_write32(pc, mdio_data, v);
-       /* Wait for the device to complete the transaction */
-       udelay(10);
-       for (i = 0; i < 10; i++) {
-               v = pcicore_read32(pc, mdio_control);
-               if (v & 0x100 /* Trans complete */)
-                       break;
-               msleep(1);
-       }
-       pcicore_write32(pc, mdio_control, 0);
-}
-
-static void ssb_broadcast_value(struct ssb_device *dev,
-                               u32 address, u32 data)
-{
-       /* This is used for both, PCI and ChipCommon core, so be careful. */
-       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR);
-       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA);
-
-       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address);
-       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */
-       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data);
-       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */
-}
-
-static void ssb_commit_settings(struct ssb_bus *bus)
-{
-       struct ssb_device *dev;
-
-       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev;
-       if (WARN_ON(!dev))
-               return;
-       /* This forces an update of the cached registers. */
-       ssb_broadcast_value(dev, 0xFD8, 0);
-}
-
-int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
-                                  struct ssb_device *dev)
-{
-       struct ssb_device *pdev = pc->dev;
-       struct ssb_bus *bus;
-       int err = 0;
-       u32 tmp;
-
-       might_sleep();
-
-       if (!pdev)
-               goto out;
-       bus = pdev->bus;
-
-       /* Enable interrupts for this device. */
-       if (bus->host_pci &&
-           ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) {
-               u32 coremask;
-
-               /* Calculate the "coremask" for the device. */
-               coremask = (1 << dev->core_index);
-
-               err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp);
-               if (err)
-                       goto out;
-               tmp |= coremask << 8;
-               err = pci_write_config_dword(bus->host_pci, SSB_PCI_IRQMASK, tmp);
-               if (err)
-                       goto out;
-       } else {
-               u32 intvec;
-
-               intvec = ssb_read32(pdev, SSB_INTVEC);
-               if ((bus->chip_id & 0xFF00) == 0x4400) {
-                       /* Workaround: On the BCM44XX the BPFLAG routing
-                        * bit is wrong. Use a hardcoded constant. */
-                       intvec |= 0x00000002;
-               } else {
-                       tmp = ssb_read32(dev, SSB_TPSFLAG);
-                       tmp &= SSB_TPSFLAG_BPFLAG;
-                       intvec |= tmp;
-               }
-               ssb_write32(pdev, SSB_INTVEC, intvec);
-       }
-
-       /* Setup PCIcore operation. */
-       if (pc->setup_done)
-               goto out;
-       if (pdev->id.coreid == SSB_DEV_PCI) {
-               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
-               tmp |= SSB_PCICORE_SBTOPCI_PREF;
-               tmp |= SSB_PCICORE_SBTOPCI_BURST;
-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
-
-               if (pdev->id.revision < 5) {
-                       tmp = ssb_read32(pdev, SSB_IMCFGLO);
-                       tmp &= ~SSB_IMCFGLO_SERTO;
-                       tmp |= 2;
-                       tmp &= ~SSB_IMCFGLO_REQTO;
-                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT;
-                       ssb_write32(pdev, SSB_IMCFGLO, tmp);
-                       ssb_commit_settings(bus);
-               } else if (pdev->id.revision >= 11) {
-                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2);
-                       tmp |= SSB_PCICORE_SBTOPCI_MRM;
-                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp);
-               }
-       } else {
-               WARN_ON(pdev->id.coreid != SSB_DEV_PCIE);
-               //TODO: Better make defines for all these magic PCIE values.
-               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) {
-                       /* TLP Workaround register. */
-                       tmp = ssb_pcie_read(pc, 0x4);
-                       tmp |= 0x8;
-                       ssb_pcie_write(pc, 0x4, tmp);
-               }
-               if (pdev->id.revision == 0) {
-                       const u8 serdes_rx_device = 0x1F;
-
-                       ssb_pcie_mdio_write(pc, serdes_rx_device,
-                                           2 /* Timer */, 0x8128);
-                       ssb_pcie_mdio_write(pc, serdes_rx_device,
-                                           6 /* CDR */, 0x0100);
-                       ssb_pcie_mdio_write(pc, serdes_rx_device,
-                                           7 /* CDR BW */, 0x1466);
-               } else if (pdev->id.revision == 1) {
-                       /* DLLP Link Control register. */
-                       tmp = ssb_pcie_read(pc, 0x100);
-                       tmp |= 0x40;
-                       ssb_pcie_write(pc, 0x100, tmp);
-               }
-       }
-       pc->setup_done = 1;
-out:
-       return err;
-}
-EXPORT_SYMBOL(ssb_pcicore_dev_irqvecs_enable);
diff --git a/target/linux/generic-2.6/files/drivers/ssb/main.c b/target/linux/generic-2.6/files/drivers/ssb/main.c
deleted file mode 100644 (file)
index 9028ed5..0000000
+++ /dev/null
@@ -1,1169 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Subsystem core
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include "ssb_private.h"
-
-#include <linux/delay.h>
-#include <linux/io.h>
-#include <linux/ssb/ssb.h>
-#include <linux/ssb/ssb_regs.h>
-#include <linux/dma-mapping.h>
-#include <linux/pci.h>
-
-#include <pcmcia/cs_types.h>
-#include <pcmcia/cs.h>
-#include <pcmcia/cistpl.h>
-#include <pcmcia/ds.h>
-
-
-MODULE_DESCRIPTION("Sonics Silicon Backplane driver");
-MODULE_LICENSE("GPL");
-
-
-/* Temporary list of yet-to-be-attached buses */
-static LIST_HEAD(attach_queue);
-/* List if running buses */
-static LIST_HEAD(buses);
-/* Software ID counter */
-static unsigned int next_busnumber;
-/* buses_mutes locks the two buslists and the next_busnumber.
- * Don't lock this directly, but use ssb_buses_[un]lock() below. */
-static DEFINE_MUTEX(buses_mutex);
-
-/* There are differences in the codeflow, if the bus is
- * initialized from early boot, as various needed services
- * are not available early. This is a mechanism to delay
- * these initializations to after early boot has finished.
- * It's also used to avoid mutex locking, as that's not
- * available and needed early. */
-static bool ssb_is_early_boot = 1;
-
-static void ssb_buses_lock(void);
-static void ssb_buses_unlock(void);
-
-
-#ifdef CONFIG_SSB_PCIHOST
-struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev)
-{
-       struct ssb_bus *bus;
-
-       ssb_buses_lock();
-       list_for_each_entry(bus, &buses, list) {
-               if (bus->bustype == SSB_BUSTYPE_PCI &&
-                   bus->host_pci == pdev)
-                       goto found;
-       }
-       bus = NULL;
-found:
-       ssb_buses_unlock();
-
-       return bus;
-}
-#endif /* CONFIG_SSB_PCIHOST */
-
-static struct ssb_device *ssb_device_get(struct ssb_device *dev)
-{
-       if (dev)
-               get_device(dev->dev);
-       return dev;
-}
-
-static void ssb_device_put(struct ssb_device *dev)
-{
-       if (dev)
-               put_device(dev->dev);
-}
-
-static int ssb_bus_resume(struct ssb_bus *bus)
-{
-       int err;
-
-       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
-       err = ssb_pcmcia_init(bus);
-       if (err) {
-               /* No need to disable XTAL, as we don't have one on PCMCIA. */
-               return err;
-       }
-       ssb_chipco_resume(&bus->chipco);
-
-       return 0;
-}
-
-static int ssb_device_resume(struct device *dev)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv;
-       struct ssb_bus *bus;
-       int err = 0;
-
-       bus = ssb_dev->bus;
-       if (bus->suspend_cnt == bus->nr_devices) {
-               err = ssb_bus_resume(bus);
-               if (err)
-                       return err;
-       }
-       bus->suspend_cnt--;
-       if (dev->driver) {
-               ssb_drv = drv_to_ssb_drv(dev->driver);
-               if (ssb_drv && ssb_drv->resume)
-                       err = ssb_drv->resume(ssb_dev);
-               if (err)
-                       goto out;
-       }
-out:
-       return err;
-}
-
-static void ssb_bus_suspend(struct ssb_bus *bus, pm_message_t state)
-{
-       ssb_chipco_suspend(&bus->chipco, state);
-       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
-
-       /* Reset HW state information in memory, so that HW is
-        * completely reinitialized on resume. */
-       bus->mapped_device = NULL;
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-       bus->pcicore.setup_done = 0;
-#endif
-#ifdef CONFIG_SSB_DEBUG
-       bus->powered_up = 0;
-#endif
-}
-
-static int ssb_device_suspend(struct device *dev, pm_message_t state)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv;
-       struct ssb_bus *bus;
-       int err = 0;
-
-       if (dev->driver) {
-               ssb_drv = drv_to_ssb_drv(dev->driver);
-               if (ssb_drv && ssb_drv->suspend)
-                       err = ssb_drv->suspend(ssb_dev, state);
-               if (err)
-                       goto out;
-       }
-
-       bus = ssb_dev->bus;
-       bus->suspend_cnt++;
-       if (bus->suspend_cnt == bus->nr_devices) {
-               /* All devices suspended. Shutdown the bus. */
-               ssb_bus_suspend(bus, state);
-       }
-
-out:
-       return err;
-}
-
-#ifdef CONFIG_SSB_PCIHOST
-int ssb_devices_freeze(struct ssb_bus *bus)
-{
-       struct ssb_device *dev;
-       struct ssb_driver *drv;
-       int err = 0;
-       int i;
-       pm_message_t state = PMSG_FREEZE;
-
-       /* First check that we are capable to freeze all devices. */
-       for (i = 0; i < bus->nr_devices; i++) {
-               dev = &(bus->devices[i]);
-               if (!dev->dev ||
-                   !dev->dev->driver ||
-                   !device_is_registered(dev->dev))
-                       continue;
-               drv = drv_to_ssb_drv(dev->dev->driver);
-               if (!drv)
-                       continue;
-               if (!drv->suspend) {
-                       /* Nope, can't suspend this one. */
-                       return -EOPNOTSUPP;
-               }
-       }
-       /* Now suspend all devices */
-       for (i = 0; i < bus->nr_devices; i++) {
-               dev = &(bus->devices[i]);
-               if (!dev->dev ||
-                   !dev->dev->driver ||
-                   !device_is_registered(dev->dev))
-                       continue;
-               drv = drv_to_ssb_drv(dev->dev->driver);
-               if (!drv)
-                       continue;
-               err = drv->suspend(dev, state);
-               if (err) {
-                       ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n",
-                                  dev->dev->bus_id);
-                       goto err_unwind;
-               }
-       }
-
-       return 0;
-err_unwind:
-       for (i--; i >= 0; i--) {
-               dev = &(bus->devices[i]);
-               if (!dev->dev ||
-                   !dev->dev->driver ||
-                   !device_is_registered(dev->dev))
-                       continue;
-               drv = drv_to_ssb_drv(dev->dev->driver);
-               if (!drv)
-                       continue;
-               if (drv->resume)
-                       drv->resume(dev);
-       }
-       return err;
-}
-
-int ssb_devices_thaw(struct ssb_bus *bus)
-{
-       struct ssb_device *dev;
-       struct ssb_driver *drv;
-       int err;
-       int i;
-
-       for (i = 0; i < bus->nr_devices; i++) {
-               dev = &(bus->devices[i]);
-               if (!dev->dev ||
-                   !dev->dev->driver ||
-                   !device_is_registered(dev->dev))
-                       continue;
-               drv = drv_to_ssb_drv(dev->dev->driver);
-               if (!drv)
-                       continue;
-               if (SSB_WARN_ON(!drv->resume))
-                       continue;
-               err = drv->resume(dev);
-               if (err) {
-                       ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n",
-                                  dev->dev->bus_id);
-               }
-       }
-
-       return 0;
-}
-#endif /* CONFIG_SSB_PCIHOST */
-
-static void ssb_device_shutdown(struct device *dev)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv;
-
-       if (!dev->driver)
-               return;
-       ssb_drv = drv_to_ssb_drv(dev->driver);
-       if (ssb_drv && ssb_drv->shutdown)
-               ssb_drv->shutdown(ssb_dev);
-}
-
-static int ssb_device_remove(struct device *dev)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv = drv_to_ssb_drv(dev->driver);
-
-       if (ssb_drv && ssb_drv->remove)
-               ssb_drv->remove(ssb_dev);
-       ssb_device_put(ssb_dev);
-
-       return 0;
-}
-
-static int ssb_device_probe(struct device *dev)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv = drv_to_ssb_drv(dev->driver);
-       int err = 0;
-
-       ssb_device_get(ssb_dev);
-       if (ssb_drv && ssb_drv->probe)
-               err = ssb_drv->probe(ssb_dev, &ssb_dev->id);
-       if (err)
-               ssb_device_put(ssb_dev);
-
-       return err;
-}
-
-static int ssb_match_devid(const struct ssb_device_id *tabid,
-                          const struct ssb_device_id *devid)
-{
-       if ((tabid->vendor != devid->vendor) &&
-           tabid->vendor != SSB_ANY_VENDOR)
-               return 0;
-       if ((tabid->coreid != devid->coreid) &&
-           tabid->coreid != SSB_ANY_ID)
-               return 0;
-       if ((tabid->revision != devid->revision) &&
-           tabid->revision != SSB_ANY_REV)
-               return 0;
-       return 1;
-}
-
-static int ssb_bus_match(struct device *dev, struct device_driver *drv)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-       struct ssb_driver *ssb_drv = drv_to_ssb_drv(drv);
-       const struct ssb_device_id *id;
-
-       for (id = ssb_drv->id_table;
-            id->vendor || id->coreid || id->revision;
-            id++) {
-               if (ssb_match_devid(id, &ssb_dev->id))
-                       return 1; /* found */
-       }
-
-       return 0;
-}
-
-static int ssb_device_uevent(struct device *dev, struct kobj_uevent_env *env)
-{
-       struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
-
-       if (!dev)
-               return -ENODEV;
-
-       return add_uevent_var(env,
-                            "MODALIAS=ssb:v%04Xid%04Xrev%02X",
-                            ssb_dev->id.vendor, ssb_dev->id.coreid,
-                            ssb_dev->id.revision);
-}
-
-static struct bus_type ssb_bustype = {
-       .name           = "ssb",
-       .match          = ssb_bus_match,
-       .probe          = ssb_device_probe,
-       .remove         = ssb_device_remove,
-       .shutdown       = ssb_device_shutdown,
-       .suspend        = ssb_device_suspend,
-       .resume         = ssb_device_resume,
-       .uevent         = ssb_device_uevent,
-};
-
-static void ssb_buses_lock(void)
-{
-       /* See the comment at the ssb_is_early_boot definition */
-       if (!ssb_is_early_boot)
-               mutex_lock(&buses_mutex);
-}
-
-static void ssb_buses_unlock(void)
-{
-       /* See the comment at the ssb_is_early_boot definition */
-       if (!ssb_is_early_boot)
-               mutex_unlock(&buses_mutex);
-}
-
-static void ssb_devices_unregister(struct ssb_bus *bus)
-{
-       struct ssb_device *sdev;
-       int i;
-
-       for (i = bus->nr_devices - 1; i >= 0; i--) {
-               sdev = &(bus->devices[i]);
-               if (sdev->dev)
-                       device_unregister(sdev->dev);
-       }
-}
-
-void ssb_bus_unregister(struct ssb_bus *bus)
-{
-       ssb_buses_lock();
-       ssb_devices_unregister(bus);
-       list_del(&bus->list);
-       ssb_buses_unlock();
-
-       /* ssb_pcmcia_exit(bus); */
-       ssb_pci_exit(bus);
-       ssb_iounmap(bus);
-}
-EXPORT_SYMBOL(ssb_bus_unregister);
-
-static void ssb_release_dev(struct device *dev)
-{
-       struct __ssb_dev_wrapper *devwrap;
-
-       devwrap = container_of(dev, struct __ssb_dev_wrapper, dev);
-       kfree(devwrap);
-}
-
-static int ssb_devices_register(struct ssb_bus *bus)
-{
-       struct ssb_device *sdev;
-       struct device *dev;
-       struct __ssb_dev_wrapper *devwrap;
-       int i, err = 0;
-       int dev_idx = 0;
-
-       for (i = 0; i < bus->nr_devices; i++) {
-               sdev = &(bus->devices[i]);
-
-               /* We don't register SSB-system devices to the kernel,
-                * as the drivers for them are built into SSB. */
-               switch (sdev->id.coreid) {
-               case SSB_DEV_CHIPCOMMON:
-               case SSB_DEV_PCI:
-               case SSB_DEV_PCIE:
-               case SSB_DEV_PCMCIA:
-               case SSB_DEV_MIPS:
-               case SSB_DEV_MIPS_3302:
-               case SSB_DEV_EXTIF:
-                       continue;
-               }
-
-               devwrap = kzalloc(sizeof(*devwrap), GFP_KERNEL);
-               if (!devwrap) {
-                       ssb_printk(KERN_ERR PFX
-                                  "Could not allocate device\n");
-                       err = -ENOMEM;
-                       goto error;
-               }
-               dev = &devwrap->dev;
-               devwrap->sdev = sdev;
-
-               dev->release = ssb_release_dev;
-               dev->bus = &ssb_bustype;
-               snprintf(dev->bus_id, sizeof(dev->bus_id),
-                        "ssb%u:%d", bus->busnumber, dev_idx);
-
-               switch (bus->bustype) {
-               case SSB_BUSTYPE_PCI:
-#ifdef CONFIG_SSB_PCIHOST
-                       sdev->irq = bus->host_pci->irq;
-                       dev->parent = &bus->host_pci->dev;
-#endif
-                       break;
-               case SSB_BUSTYPE_PCMCIA:
-#ifdef CONFIG_SSB_PCMCIAHOST
-                       sdev->irq = bus->host_pcmcia->irq.AssignedIRQ;
-                       dev->parent = &bus->host_pcmcia->dev;
-#endif
-                       break;
-               case SSB_BUSTYPE_SSB:
-                       break;
-               }
-
-               sdev->dev = dev;
-               err = device_register(dev);
-               if (err) {
-                       ssb_printk(KERN_ERR PFX
-                                  "Could not register %s\n",
-                                  dev->bus_id);
-                       /* Set dev to NULL to not unregister
-                        * dev on error unwinding. */
-                       sdev->dev = NULL;
-                       kfree(devwrap);
-                       goto error;
-               }
-               dev_idx++;
-       }
-
-       return 0;
-error:
-       /* Unwind the already registered devices. */
-       ssb_devices_unregister(bus);
-       return err;
-}
-
-/* Needs ssb_buses_lock() */
-static int ssb_attach_queued_buses(void)
-{
-       struct ssb_bus *bus, *n;
-       int err = 0;
-       int drop_them_all = 0;
-
-       list_for_each_entry_safe(bus, n, &attach_queue, list) {
-               if (drop_them_all) {
-                       list_del(&bus->list);
-                       continue;
-               }
-               /* Can't init the PCIcore in ssb_bus_register(), as that
-                * is too early in boot for embedded systems
-                * (no udelay() available). So do it here in attach stage.
-                */
-               err = ssb_bus_powerup(bus, 0);
-               if (err)
-                       goto error;
-               ssb_pcicore_init(&bus->pcicore);
-               ssb_bus_may_powerdown(bus);
-
-               err = ssb_devices_register(bus);
-error:
-               if (err) {
-                       drop_them_all = 1;
-                       list_del(&bus->list);
-                       continue;
-               }
-               list_move_tail(&bus->list, &buses);
-       }
-
-       return err;
-}
-
-static u16 ssb_ssb_read16(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       offset += dev->core_index * SSB_CORE_SIZE;
-       return readw(bus->mmio + offset);
-}
-
-static u32 ssb_ssb_read32(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       offset += dev->core_index * SSB_CORE_SIZE;
-       return readl(bus->mmio + offset);
-}
-
-static void ssb_ssb_write16(struct ssb_device *dev, u16 offset, u16 value)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       offset += dev->core_index * SSB_CORE_SIZE;
-       writew(value, bus->mmio + offset);
-}
-
-static void ssb_ssb_write32(struct ssb_device *dev, u16 offset, u32 value)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       offset += dev->core_index * SSB_CORE_SIZE;
-       writel(value, bus->mmio + offset);
-}
-
-/* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */
-static const struct ssb_bus_ops ssb_ssb_ops = {
-       .read16         = ssb_ssb_read16,
-       .read32         = ssb_ssb_read32,
-       .write16        = ssb_ssb_write16,
-       .write32        = ssb_ssb_write32,
-};
-
-static int ssb_fetch_invariants(struct ssb_bus *bus,
-                               ssb_invariants_func_t get_invariants)
-{
-       struct ssb_init_invariants iv;
-       int err;
-
-       memset(&iv, 0, sizeof(iv));
-       err = get_invariants(bus, &iv);
-       if (err)
-               goto out;
-       memcpy(&bus->boardinfo, &iv.boardinfo, sizeof(iv.boardinfo));
-       memcpy(&bus->sprom, &iv.sprom, sizeof(iv.sprom));
-out:
-       return err;
-}
-
-static int ssb_bus_register(struct ssb_bus *bus,
-                           ssb_invariants_func_t get_invariants,
-                           unsigned long baseaddr)
-{
-       int err;
-
-       spin_lock_init(&bus->bar_lock);
-       INIT_LIST_HEAD(&bus->list);
-
-       /* Powerup the bus */
-       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
-       if (err)
-               goto out;
-       ssb_buses_lock();
-       bus->busnumber = next_busnumber;
-       /* Scan for devices (cores) */
-       err = ssb_bus_scan(bus, baseaddr);
-       if (err)
-               goto err_disable_xtal;
-
-       /* Init PCI-host device (if any) */
-       err = ssb_pci_init(bus);
-       if (err)
-               goto err_unmap;
-       /* Init PCMCIA-host device (if any) */
-       err = ssb_pcmcia_init(bus);
-       if (err)
-               goto err_pci_exit;
-
-       /* Initialize basic system devices (if available) */
-       err = ssb_bus_powerup(bus, 0);
-       if (err)
-               goto err_pcmcia_exit;
-       ssb_chipcommon_init(&bus->chipco);
-       ssb_mipscore_init(&bus->mipscore);
-       err = ssb_fetch_invariants(bus, get_invariants);
-       if (err) {
-               ssb_bus_may_powerdown(bus);
-               goto err_pcmcia_exit;
-       }
-       ssb_bus_may_powerdown(bus);
-
-       /* Queue it for attach.
-        * See the comment at the ssb_is_early_boot definition. */
-       list_add_tail(&bus->list, &attach_queue);
-       if (!ssb_is_early_boot) {
-               /* This is not early boot, so we must attach the bus now */
-               err = ssb_attach_queued_buses();
-               if (err)
-                       goto err_dequeue;
-       }
-       next_busnumber++;
-       ssb_buses_unlock();
-
-out:
-       return err;
-
-err_dequeue:
-       list_del(&bus->list);
-err_pcmcia_exit:
-/*     ssb_pcmcia_exit(bus); */
-err_pci_exit:
-       ssb_pci_exit(bus);
-err_unmap:
-       ssb_iounmap(bus);
-err_disable_xtal:
-       ssb_buses_unlock();
-       ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
-       return err;
-}
-
-#ifdef CONFIG_SSB_PCIHOST
-int ssb_bus_pcibus_register(struct ssb_bus *bus,
-                           struct pci_dev *host_pci)
-{
-       int err;
-
-       bus->bustype = SSB_BUSTYPE_PCI;
-       bus->host_pci = host_pci;
-       bus->ops = &ssb_pci_ops;
-
-       err = ssb_bus_register(bus, ssb_pci_get_invariants, 0);
-       if (!err) {
-               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
-                          "PCI device %s\n", host_pci->dev.bus_id);
-       }
-
-       return err;
-}
-EXPORT_SYMBOL(ssb_bus_pcibus_register);
-#endif /* CONFIG_SSB_PCIHOST */
-
-#ifdef CONFIG_SSB_PCMCIAHOST
-int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
-                              struct pcmcia_device *pcmcia_dev,
-                              unsigned long baseaddr)
-{
-       int err;
-
-       bus->bustype = SSB_BUSTYPE_PCMCIA;
-       bus->host_pcmcia = pcmcia_dev;
-       bus->ops = &ssb_pcmcia_ops;
-
-       err = ssb_bus_register(bus, ssb_pcmcia_get_invariants, baseaddr);
-       if (!err) {
-               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
-                          "PCMCIA device %s\n", pcmcia_dev->devname);
-       }
-
-       return err;
-}
-EXPORT_SYMBOL(ssb_bus_pcmciabus_register);
-#endif /* CONFIG_SSB_PCMCIAHOST */
-
-int ssb_bus_ssbbus_register(struct ssb_bus *bus,
-                           unsigned long baseaddr,
-                           ssb_invariants_func_t get_invariants)
-{
-       int err;
-
-       bus->bustype = SSB_BUSTYPE_SSB;
-       bus->ops = &ssb_ssb_ops;
-
-       err = ssb_bus_register(bus, get_invariants, baseaddr);
-       if (!err) {
-               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found at "
-                          "address 0x%08lX\n", baseaddr);
-       }
-
-       return err;
-}
-
-int __ssb_driver_register(struct ssb_driver *drv, struct module *owner)
-{
-       drv->drv.name = drv->name;
-       drv->drv.bus = &ssb_bustype;
-       drv->drv.owner = owner;
-
-       return driver_register(&drv->drv);
-}
-EXPORT_SYMBOL(__ssb_driver_register);
-
-void ssb_driver_unregister(struct ssb_driver *drv)
-{
-       driver_unregister(&drv->drv);
-}
-EXPORT_SYMBOL(ssb_driver_unregister);
-
-void ssb_set_devtypedata(struct ssb_device *dev, void *data)
-{
-       struct ssb_bus *bus = dev->bus;
-       struct ssb_device *ent;
-       int i;
-
-       for (i = 0; i < bus->nr_devices; i++) {
-               ent = &(bus->devices[i]);
-               if (ent->id.vendor != dev->id.vendor)
-                       continue;
-               if (ent->id.coreid != dev->id.coreid)
-                       continue;
-
-               ent->devtypedata = data;
-       }
-}
-EXPORT_SYMBOL(ssb_set_devtypedata);
-
-static u32 clkfactor_f6_resolve(u32 v)
-{
-       /* map the magic values */
-       switch (v) {
-       case SSB_CHIPCO_CLK_F6_2:
-               return 2;
-       case SSB_CHIPCO_CLK_F6_3:
-               return 3;
-       case SSB_CHIPCO_CLK_F6_4:
-               return 4;
-       case SSB_CHIPCO_CLK_F6_5:
-               return 5;
-       case SSB_CHIPCO_CLK_F6_6:
-               return 6;
-       case SSB_CHIPCO_CLK_F6_7:
-               return 7;
-       }
-       return 0;
-}
-
-/* Calculate the speed the backplane would run at a given set of clockcontrol values */
-u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m)
-{
-       u32 n1, n2, clock, m1, m2, m3, mc;
-
-       n1 = (n & SSB_CHIPCO_CLK_N1);
-       n2 = ((n & SSB_CHIPCO_CLK_N2) >> SSB_CHIPCO_CLK_N2_SHIFT);
-
-       switch (plltype) {
-       case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */
-               if (m & SSB_CHIPCO_CLK_T6_MMASK)
-                       return SSB_CHIPCO_CLK_T6_M0;
-               return SSB_CHIPCO_CLK_T6_M1;
-       case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */
-       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
-       case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */
-       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
-               n1 = clkfactor_f6_resolve(n1);
-               n2 += SSB_CHIPCO_CLK_F5_BIAS;
-               break;
-       case SSB_PLLTYPE_2: /* 48Mhz, 4 dividers */
-               n1 += SSB_CHIPCO_CLK_T2_BIAS;
-               n2 += SSB_CHIPCO_CLK_T2_BIAS;
-               SSB_WARN_ON(!((n1 >= 2) && (n1 <= 7)));
-               SSB_WARN_ON(!((n2 >= 5) && (n2 <= 23)));
-               break;
-       case SSB_PLLTYPE_5: /* 25Mhz, 4 dividers */
-               return 100000000;
-       default:
-               SSB_WARN_ON(1);
-       }
-
-       switch (plltype) {
-       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
-       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
-               clock = SSB_CHIPCO_CLK_BASE2 * n1 * n2;
-               break;
-       default:
-               clock = SSB_CHIPCO_CLK_BASE1 * n1 * n2;
-       }
-       if (!clock)
-               return 0;
-
-       m1 = (m & SSB_CHIPCO_CLK_M1);
-       m2 = ((m & SSB_CHIPCO_CLK_M2) >> SSB_CHIPCO_CLK_M2_SHIFT);
-       m3 = ((m & SSB_CHIPCO_CLK_M3) >> SSB_CHIPCO_CLK_M3_SHIFT);
-       mc = ((m & SSB_CHIPCO_CLK_MC) >> SSB_CHIPCO_CLK_MC_SHIFT);
-
-       switch (plltype) {
-       case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */
-       case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */
-       case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */
-       case SSB_PLLTYPE_7: /* 25Mhz, 4 dividers */
-               m1 = clkfactor_f6_resolve(m1);
-               if ((plltype == SSB_PLLTYPE_1) ||
-                   (plltype == SSB_PLLTYPE_3))
-                       m2 += SSB_CHIPCO_CLK_F5_BIAS;
-               else
-                       m2 = clkfactor_f6_resolve(m2);
-               m3 = clkfactor_f6_resolve(m3);
-
-               switch (mc) {
-               case SSB_CHIPCO_CLK_MC_BYPASS:
-                       return clock;
-               case SSB_CHIPCO_CLK_MC_M1:
-                       return (clock / m1);
-               case SSB_CHIPCO_CLK_MC_M1M2:
-                       return (clock / (m1 * m2));
-               case SSB_CHIPCO_CLK_MC_M1M2M3:
-                       return (clock / (m1 * m2 * m3));
-               case SSB_CHIPCO_CLK_MC_M1M3:
-                       return (clock / (m1 * m3));
-               }
-               return 0;
-       case SSB_PLLTYPE_2:
-               m1 += SSB_CHIPCO_CLK_T2_BIAS;
-               m2 += SSB_CHIPCO_CLK_T2M2_BIAS;
-               m3 += SSB_CHIPCO_CLK_T2_BIAS;
-               SSB_WARN_ON(!((m1 >= 2) && (m1 <= 7)));
-               SSB_WARN_ON(!((m2 >= 3) && (m2 <= 10)));
-               SSB_WARN_ON(!((m3 >= 2) && (m3 <= 7)));
-
-               if (!(mc & SSB_CHIPCO_CLK_T2MC_M1BYP))
-                       clock /= m1;
-               if (!(mc & SSB_CHIPCO_CLK_T2MC_M2BYP))
-                       clock /= m2;
-               if (!(mc & SSB_CHIPCO_CLK_T2MC_M3BYP))
-                       clock /= m3;
-               return clock;
-       default:
-               SSB_WARN_ON(1);
-       }
-       return 0;
-}
-
-/* Get the current speed the backplane is running at */
-u32 ssb_clockspeed(struct ssb_bus *bus)
-{
-       u32 rate;
-       u32 plltype;
-       u32 clkctl_n, clkctl_m;
-
-       if (ssb_extif_available(&bus->extif))
-               ssb_extif_get_clockcontrol(&bus->extif, &plltype,
-                                          &clkctl_n, &clkctl_m);
-       else if (bus->chipco.dev)
-               ssb_chipco_get_clockcontrol(&bus->chipco, &plltype,
-                                           &clkctl_n, &clkctl_m);
-       else
-               return 0;
-
-       if (bus->chip_id == 0x5365) {
-               rate = 100000000;
-       } else {
-               rate = ssb_calc_clock_rate(plltype, clkctl_n, clkctl_m);
-               if (plltype == SSB_PLLTYPE_3) /* 25Mhz, 2 dividers */
-                       rate /= 2;
-       }
-
-       return rate;
-}
-EXPORT_SYMBOL(ssb_clockspeed);
-
-static u32 ssb_tmslow_reject_bitmask(struct ssb_device *dev)
-{
-       u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV;
-
-       /* The REJECT bit changed position in TMSLOW between
-        * Backplane revisions. */
-       switch (rev) {
-       case SSB_IDLOW_SSBREV_22:
-               return SSB_TMSLOW_REJECT_22;
-       case SSB_IDLOW_SSBREV_23:
-               return SSB_TMSLOW_REJECT_23;
-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */
-       case SSB_IDLOW_SSBREV_25:     /* same here */
-       case SSB_IDLOW_SSBREV_26:     /* same here */
-       case SSB_IDLOW_SSBREV_27:     /* same here */
-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */
-       default:
-               printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
-               WARN_ON(1);
-       }
-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23);
-}
-
-int ssb_device_is_enabled(struct ssb_device *dev)
-{
-       u32 val;
-       u32 reject;
-
-       reject = ssb_tmslow_reject_bitmask(dev);
-       val = ssb_read32(dev, SSB_TMSLOW);
-       val &= SSB_TMSLOW_CLOCK | SSB_TMSLOW_RESET | reject;
-
-       return (val == SSB_TMSLOW_CLOCK);
-}
-EXPORT_SYMBOL(ssb_device_is_enabled);
-
-static void ssb_flush_tmslow(struct ssb_device *dev)
-{
-       /* Make _really_ sure the device has finished the TMSLOW
-        * register write transaction, as we risk running into
-        * a machine check exception otherwise.
-        * Do this by reading the register back to commit the
-        * PCI write and delay an additional usec for the device
-        * to react to the change. */
-       ssb_read32(dev, SSB_TMSLOW);
-       udelay(1);
-}
-
-void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags)
-{
-       u32 val;
-
-       ssb_device_disable(dev, core_specific_flags);
-       ssb_write32(dev, SSB_TMSLOW,
-                   SSB_TMSLOW_RESET | SSB_TMSLOW_CLOCK |
-                   SSB_TMSLOW_FGC | core_specific_flags);
-       ssb_flush_tmslow(dev);
-
-       /* Clear SERR if set. This is a hw bug workaround. */
-       if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_SERR)
-               ssb_write32(dev, SSB_TMSHIGH, 0);
-
-       val = ssb_read32(dev, SSB_IMSTATE);
-       if (val & (SSB_IMSTATE_IBE | SSB_IMSTATE_TO)) {
-               val &= ~(SSB_IMSTATE_IBE | SSB_IMSTATE_TO);
-               ssb_write32(dev, SSB_IMSTATE, val);
-       }
-
-       ssb_write32(dev, SSB_TMSLOW,
-                   SSB_TMSLOW_CLOCK | SSB_TMSLOW_FGC |
-                   core_specific_flags);
-       ssb_flush_tmslow(dev);
-
-       ssb_write32(dev, SSB_TMSLOW, SSB_TMSLOW_CLOCK |
-                   core_specific_flags);
-       ssb_flush_tmslow(dev);
-}
-EXPORT_SYMBOL(ssb_device_enable);
-
-/* Wait for a bit in a register to get set or unset.
- * timeout is in units of ten-microseconds */
-static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask,
-                       int timeout, int set)
-{
-       int i;
-       u32 val;
-
-       for (i = 0; i < timeout; i++) {
-               val = ssb_read32(dev, reg);
-               if (set) {
-                       if (val & bitmask)
-                               return 0;
-               } else {
-                       if (!(val & bitmask))
-                               return 0;
-               }
-               udelay(10);
-       }
-       printk(KERN_ERR PFX "Timeout waiting for bitmask %08X on "
-                           "register %04X to %s.\n",
-              bitmask, reg, (set ? "set" : "clear"));
-
-       return -ETIMEDOUT;
-}
-
-void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags)
-{
-       u32 reject;
-
-       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET)
-               return;
-
-       reject = ssb_tmslow_reject_bitmask(dev);
-       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK);
-       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1);
-       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0);
-       ssb_write32(dev, SSB_TMSLOW,
-                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK |
-                   reject | SSB_TMSLOW_RESET |
-                   core_specific_flags);
-       ssb_flush_tmslow(dev);
-
-       ssb_write32(dev, SSB_TMSLOW,
-                   reject | SSB_TMSLOW_RESET |
-                   core_specific_flags);
-       ssb_flush_tmslow(dev);
-}
-EXPORT_SYMBOL(ssb_device_disable);
-
-u32 ssb_dma_translation(struct ssb_device *dev)
-{
-       switch (dev->bus->bustype) {
-       case SSB_BUSTYPE_SSB:
-               return 0;
-       case SSB_BUSTYPE_PCI:
-       case SSB_BUSTYPE_PCMCIA:
-               return SSB_PCI_DMA;
-       }
-       return 0;
-}
-EXPORT_SYMBOL(ssb_dma_translation);
-
-int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask)
-{
-       struct device *dev = ssb_dev->dev;
-
-#ifdef CONFIG_SSB_PCIHOST
-       if (ssb_dev->bus->bustype == SSB_BUSTYPE_PCI &&
-           !dma_supported(dev, mask))
-               return -EIO;
-#endif
-       dev->coherent_dma_mask = mask;
-       dev->dma_mask = &dev->coherent_dma_mask;
-
-       return 0;
-}
-EXPORT_SYMBOL(ssb_dma_set_mask);
-
-int ssb_bus_may_powerdown(struct ssb_bus *bus)
-{
-       struct ssb_chipcommon *cc;
-       int err = 0;
-
-       /* On buses where more than one core may be working
-        * at a time, we must not powerdown stuff if there are
-        * still cores that may want to run. */
-       if (bus->bustype == SSB_BUSTYPE_SSB)
-               goto out;
-
-       cc = &bus->chipco;
-       ssb_chipco_set_clockmode(cc, SSB_CLKMODE_SLOW);
-       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
-       if (err)
-               goto error;
-out:
-#ifdef CONFIG_SSB_DEBUG
-       bus->powered_up = 0;
-#endif
-       return err;
-error:
-       ssb_printk(KERN_ERR PFX "Bus powerdown failed\n");
-       goto out;
-}
-EXPORT_SYMBOL(ssb_bus_may_powerdown);
-
-int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl)
-{
-       struct ssb_chipcommon *cc;
-       int err;
-       enum ssb_clkmode mode;
-
-       err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
-       if (err)
-               goto error;
-       cc = &bus->chipco;
-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST;
-       ssb_chipco_set_clockmode(cc, mode);
-
-#ifdef CONFIG_SSB_DEBUG
-       bus->powered_up = 1;
-#endif
-       return 0;
-error:
-       ssb_printk(KERN_ERR PFX "Bus powerup failed\n");
-       return err;
-}
-EXPORT_SYMBOL(ssb_bus_powerup);
-
-u32 ssb_admatch_base(u32 adm)
-{
-       u32 base = 0;
-
-       switch (adm & SSB_ADM_TYPE) {
-       case SSB_ADM_TYPE0:
-               base = (adm & SSB_ADM_BASE0);
-               break;
-       case SSB_ADM_TYPE1:
-               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
-               base = (adm & SSB_ADM_BASE1);
-               break;
-       case SSB_ADM_TYPE2:
-               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
-               base = (adm & SSB_ADM_BASE2);
-               break;
-       default:
-               SSB_WARN_ON(1);
-       }
-
-       return base;
-}
-EXPORT_SYMBOL(ssb_admatch_base);
-
-u32 ssb_admatch_size(u32 adm)
-{
-       u32 size = 0;
-
-       switch (adm & SSB_ADM_TYPE) {
-       case SSB_ADM_TYPE0:
-               size = ((adm & SSB_ADM_SZ0) >> SSB_ADM_SZ0_SHIFT);
-               break;
-       case SSB_ADM_TYPE1:
-               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
-               size = ((adm & SSB_ADM_SZ1) >> SSB_ADM_SZ1_SHIFT);
-               break;
-       case SSB_ADM_TYPE2:
-               SSB_WARN_ON(adm & SSB_ADM_NEG); /* unsupported */
-               size = ((adm & SSB_ADM_SZ2) >> SSB_ADM_SZ2_SHIFT);
-               break;
-       default:
-               SSB_WARN_ON(1);
-       }
-       size = (1 << (size + 1));
-
-       return size;
-}
-EXPORT_SYMBOL(ssb_admatch_size);
-
-static int __init ssb_modinit(void)
-{
-       int err;
-
-       /* See the comment at the ssb_is_early_boot definition */
-       ssb_is_early_boot = 0;
-       err = bus_register(&ssb_bustype);
-       if (err)
-               return err;
-
-       /* Maybe we already registered some buses at early boot.
-        * Check for this and attach them
-        */
-       ssb_buses_lock();
-       err = ssb_attach_queued_buses();
-       ssb_buses_unlock();
-       if (err)
-               bus_unregister(&ssb_bustype);
-
-       err = b43_pci_ssb_bridge_init();
-       if (err) {
-               ssb_printk(KERN_ERR "Broadcom 43xx PCI-SSB-bridge "
-                          "initialization failed");
-               /* don't fail SSB init because of this */
-               err = 0;
-       }
-
-       return err;
-}
-/* ssb must be initialized after PCI but before the ssb drivers.
- * That means we must use some initcall between subsys_initcall
- * and device_initcall. */
-fs_initcall(ssb_modinit);
-
-static void __exit ssb_modexit(void)
-{
-       b43_pci_ssb_bridge_exit();
-       bus_unregister(&ssb_bustype);
-}
-module_exit(ssb_modexit)
diff --git a/target/linux/generic-2.6/files/drivers/ssb/pci.c b/target/linux/generic-2.6/files/drivers/ssb/pci.c
deleted file mode 100644 (file)
index b434df7..0000000
+++ /dev/null
@@ -1,790 +0,0 @@
-/*
- * Sonics Silicon Backplane PCI-Hostbus related functions.
- *
- * Copyright (C) 2005-2006 Michael Buesch <mb@bu3sch.de>
- * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
- * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
- * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
- * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
- *
- * Derived from the Broadcom 4400 device driver.
- * Copyright (C) 2002 David S. Miller (davem@redhat.com)
- * Fixed by Pekka Pietikainen (pp@ee.oulu.fi)
- * Copyright (C) 2006 Broadcom Corporation.
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-#include <linux/ssb/ssb_regs.h>
-#include <linux/pci.h>
-#include <linux/delay.h>
-
-#include "ssb_private.h"
-
-
-/* Define the following to 1 to enable a printk on each coreswitch. */
-#define SSB_VERBOSE_PCICORESWITCH_DEBUG                0
-
-
-/* Lowlevel coreswitching */
-int ssb_pci_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
-{
-       int err;
-       int attempts = 0;
-       u32 cur_core;
-
-       while (1) {
-               err = pci_write_config_dword(bus->host_pci, SSB_BAR0_WIN,
-                                            (coreidx * SSB_CORE_SIZE)
-                                            + SSB_ENUM_BASE);
-               if (err)
-                       goto error;
-               err = pci_read_config_dword(bus->host_pci, SSB_BAR0_WIN,
-                                           &cur_core);
-               if (err)
-                       goto error;
-               cur_core = (cur_core - SSB_ENUM_BASE)
-                          / SSB_CORE_SIZE;
-               if (cur_core == coreidx)
-                       break;
-
-               if (attempts++ > SSB_BAR0_MAX_RETRIES)
-                       goto error;
-               udelay(10);
-       }
-       return 0;
-error:
-       ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
-       return -ENODEV;
-}
-
-int ssb_pci_switch_core(struct ssb_bus *bus,
-                       struct ssb_device *dev)
-{
-       int err;
-       unsigned long flags;
-
-#if SSB_VERBOSE_PCICORESWITCH_DEBUG
-       ssb_printk(KERN_INFO PFX
-                  "Switching to %s core, index %d\n",
-                  ssb_core_name(dev->id.coreid),
-                  dev->core_index);
-#endif
-
-       spin_lock_irqsave(&bus->bar_lock, flags);
-       err = ssb_pci_switch_coreidx(bus, dev->core_index);
-       if (!err)
-               bus->mapped_device = dev;
-       spin_unlock_irqrestore(&bus->bar_lock, flags);
-
-       return err;
-}
-
-/* Enable/disable the on board crystal oscillator and/or PLL. */
-int ssb_pci_xtal(struct ssb_bus *bus, u32 what, int turn_on)
-{
-       int err;
-       u32 in, out, outenable;
-       u16 pci_status;
-
-       if (bus->bustype != SSB_BUSTYPE_PCI)
-               return 0;
-
-       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_IN, &in);
-       if (err)
-               goto err_pci;
-       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT, &out);
-       if (err)
-               goto err_pci;
-       err = pci_read_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, &outenable);
-       if (err)
-               goto err_pci;
-
-       outenable |= what;
-
-       if (turn_on) {
-               /* Avoid glitching the clock if GPRS is already using it.
-                * We can't actually read the state of the PLLPD so we infer it
-                * by the value of XTAL_PU which *is* readable via gpioin.
-                */
-               if (!(in & SSB_GPIO_XTAL)) {
-                       if (what & SSB_GPIO_XTAL) {
-                               /* Turn the crystal on */
-                               out |= SSB_GPIO_XTAL;
-                               if (what & SSB_GPIO_PLL)
-                                       out |= SSB_GPIO_PLL;
-                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
-                               if (err)
-                                       goto err_pci;
-                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE,
-                                                            outenable);
-                               if (err)
-                                       goto err_pci;
-                               msleep(1);
-                       }
-                       if (what & SSB_GPIO_PLL) {
-                               /* Turn the PLL on */
-                               out &= ~SSB_GPIO_PLL;
-                               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
-                               if (err)
-                                       goto err_pci;
-                               msleep(5);
-                       }
-               }
-
-               err = pci_read_config_word(bus->host_pci, PCI_STATUS, &pci_status);
-               if (err)
-                       goto err_pci;
-               pci_status &= ~PCI_STATUS_SIG_TARGET_ABORT;
-               err = pci_write_config_word(bus->host_pci, PCI_STATUS, pci_status);
-               if (err)
-                       goto err_pci;
-       } else {
-               if (what & SSB_GPIO_XTAL) {
-                       /* Turn the crystal off */
-                       out &= ~SSB_GPIO_XTAL;
-               }
-               if (what & SSB_GPIO_PLL) {
-                       /* Turn the PLL off */
-                       out |= SSB_GPIO_PLL;
-               }
-               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT, out);
-               if (err)
-                       goto err_pci;
-               err = pci_write_config_dword(bus->host_pci, SSB_GPIO_OUT_ENABLE, outenable);
-               if (err)
-                       goto err_pci;
-       }
-
-out:
-       return err;
-
-err_pci:
-       printk(KERN_ERR PFX "Error: ssb_pci_xtal() could not access PCI config space!\n");
-       err = -EBUSY;
-       goto out;
-}
-
-/* Get the word-offset for a SSB_SPROM_XXX define. */
-#define SPOFF(offset)  (((offset) - SSB_SPROM_BASE) / sizeof(u16))
-/* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */
-#define SPEX(_outvar, _offset, _mask, _shift)  \
-       out->_outvar = ((in[SPOFF(_offset)] & (_mask)) >> (_shift))
-
-static inline u8 ssb_crc8(u8 crc, u8 data)
-{
-       /* Polynomial:   x^8 + x^7 + x^6 + x^4 + x^2 + 1   */
-       static const u8 t[] = {
-               0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
-               0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
-               0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
-               0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
-               0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
-               0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
-               0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
-               0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
-               0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
-               0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
-               0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
-               0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
-               0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
-               0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
-               0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
-               0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
-               0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
-               0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
-               0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
-               0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
-               0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
-               0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
-               0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
-               0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
-               0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
-               0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
-               0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
-               0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
-               0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
-               0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
-               0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
-               0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F,
-       };
-       return t[crc ^ data];
-}
-
-static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
-{
-       int word;
-       u8 crc = 0xFF;
-
-       for (word = 0; word < size - 1; word++) {
-               crc = ssb_crc8(crc, sprom[word] & 0x00FF);
-               crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);
-       }
-       crc = ssb_crc8(crc, sprom[size - 1] & 0x00FF);
-       crc ^= 0xFF;
-
-       return crc;
-}
-
-static int sprom_check_crc(const u16 *sprom, u16 size)
-{
-       u8 crc;
-       u8 expected_crc;
-       u16 tmp;
-
-       crc = ssb_sprom_crc(sprom, size);
-       tmp = sprom[size - 1] & SSB_SPROM_REVISION_CRC;
-       expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
-       if (crc != expected_crc)
-               return -EPROTO;
-
-       return 0;
-}
-
-static void sprom_do_read(struct ssb_bus *bus, u16 *sprom)
-{
-       int i;
-
-       for (i = 0; i < bus->sprom_size; i++)
-               sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2));
-}
-
-static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom)
-{
-       struct pci_dev *pdev = bus->host_pci;
-       int i, err;
-       u32 spromctl;
-       u16 size = bus->sprom_size;
-
-       ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
-       err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
-       if (err)
-               goto err_ctlreg;
-       spromctl |= SSB_SPROMCTL_WE;
-       err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
-       if (err)
-               goto err_ctlreg;
-       ssb_printk(KERN_NOTICE PFX "[ 0%%");
-       msleep(500);
-       for (i = 0; i < size; i++) {
-               if (i == size / 4)
-                       ssb_printk("25%%");
-               else if (i == size / 2)
-                       ssb_printk("50%%");
-               else if (i == (size * 3) / 4)
-                       ssb_printk("75%%");
-               else if (i % 2)
-                       ssb_printk(".");
-               writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2));
-               mmiowb();
-               msleep(20);
-       }
-       err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
-       if (err)
-               goto err_ctlreg;
-       spromctl &= ~SSB_SPROMCTL_WE;
-       err = pci_write_config_dword(pdev, SSB_SPROMCTL, spromctl);
-       if (err)
-               goto err_ctlreg;
-       msleep(500);
-       ssb_printk("100%% ]\n");
-       ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
-
-       return 0;
-err_ctlreg:
-       ssb_printk(KERN_ERR PFX "Could not access SPROM control register.\n");
-       return err;
-}
-
-static s8 r123_extract_antgain(u8 sprom_revision, const u16 *in,
-                              u16 mask, u16 shift)
-{
-       u16 v;
-       u8 gain;
-
-       v = in[SPOFF(SSB_SPROM1_AGAIN)];
-       gain = (v & mask) >> shift;
-       if (gain == 0xFF)
-               gain = 2; /* If unset use 2dBm */
-       if (sprom_revision == 1) {
-               /* Convert to Q5.2 */
-               gain <<= 2;
-       } else {
-               /* Q5.2 Fractional part is stored in 0xC0 */
-               gain = ((gain & 0xC0) >> 6) | ((gain & 0x3F) << 2);
-       }
-
-       return (s8)gain;
-}
-
-static void sprom_extract_r123(struct ssb_sprom *out, const u16 *in)
-{
-       int i;
-       u16 v;
-       s8 gain;
-       u16 loc[3];
-
-       if (out->revision == 3) {                       /* rev 3 moved MAC */
-               loc[0] = SSB_SPROM3_IL0MAC;
-               loc[1] = SSB_SPROM3_ET0MAC;
-               loc[2] = SSB_SPROM3_ET1MAC;
-       } else {
-               loc[0] = SSB_SPROM1_IL0MAC;
-               loc[1] = SSB_SPROM1_ET0MAC;
-               loc[2] = SSB_SPROM1_ET1MAC;
-       }
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(loc[0]) + i];
-               *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
-       }
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(loc[1]) + i];
-               *(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
-       }
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(loc[2]) + i];
-               *(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
-       }
-       SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
-       SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
-            SSB_SPROM1_ETHPHY_ET1A_SHIFT);
-       SPEX(et0mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0M, 14);
-       SPEX(et1mdcport, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1M, 15);
-       SPEX(board_rev, SSB_SPROM1_BINF, SSB_SPROM1_BINF_BREV, 0);
-       SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
-            SSB_SPROM1_BINF_CCODE_SHIFT);
-       SPEX(ant_available_a, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTA,
-            SSB_SPROM1_BINF_ANTA_SHIFT);
-       SPEX(ant_available_bg, SSB_SPROM1_BINF, SSB_SPROM1_BINF_ANTBG,
-            SSB_SPROM1_BINF_ANTBG_SHIFT);
-       SPEX(pa0b0, SSB_SPROM1_PA0B0, 0xFFFF, 0);
-       SPEX(pa0b1, SSB_SPROM1_PA0B1, 0xFFFF, 0);
-       SPEX(pa0b2, SSB_SPROM1_PA0B2, 0xFFFF, 0);
-       SPEX(pa1b0, SSB_SPROM1_PA1B0, 0xFFFF, 0);
-       SPEX(pa1b1, SSB_SPROM1_PA1B1, 0xFFFF, 0);
-       SPEX(pa1b2, SSB_SPROM1_PA1B2, 0xFFFF, 0);
-       SPEX(gpio0, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P0, 0);
-       SPEX(gpio1, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P1,
-            SSB_SPROM1_GPIOA_P1_SHIFT);
-       SPEX(gpio2, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P2, 0);
-       SPEX(gpio3, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P3,
-            SSB_SPROM1_GPIOB_P3_SHIFT);
-       SPEX(maxpwr_a, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_A,
-            SSB_SPROM1_MAXPWR_A_SHIFT);
-       SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG, 0);
-       SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A,
-            SSB_SPROM1_ITSSI_A_SHIFT);
-       SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
-       SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
-       if (out->revision >= 2)
-               SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);
-
-       /* Extract the antenna gain values. */
-       gain = r123_extract_antgain(out->revision, in,
-                                   SSB_SPROM1_AGAIN_BG,
-                                   SSB_SPROM1_AGAIN_BG_SHIFT);
-       out->antenna_gain.ghz24.a0 = gain;
-       out->antenna_gain.ghz24.a1 = gain;
-       out->antenna_gain.ghz24.a2 = gain;
-       out->antenna_gain.ghz24.a3 = gain;
-       gain = r123_extract_antgain(out->revision, in,
-                                   SSB_SPROM1_AGAIN_A,
-                                   SSB_SPROM1_AGAIN_A_SHIFT);
-       out->antenna_gain.ghz5.a0 = gain;
-       out->antenna_gain.ghz5.a1 = gain;
-       out->antenna_gain.ghz5.a2 = gain;
-       out->antenna_gain.ghz5.a3 = gain;
-}
-
-static void sprom_extract_r4(struct ssb_sprom *out, const u16 *in)
-{
-       int i;
-       u16 v;
-
-       /* extract the equivalent of the r1 variables */
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(SSB_SPROM4_IL0MAC) + i];
-               *(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
-       }
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(SSB_SPROM4_ET0MAC) + i];
-               *(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
-       }
-       for (i = 0; i < 3; i++) {
-               v = in[SPOFF(SSB_SPROM4_ET1MAC) + i];
-               *(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
-       }
-       SPEX(et0phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET0A, 0);
-       SPEX(et1phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET1A,
-            SSB_SPROM4_ETHPHY_ET1A_SHIFT);
-       SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
-       SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
-       SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0);
-       SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A,
-            SSB_SPROM4_ANTAVAIL_A_SHIFT);
-       SPEX(ant_available_bg, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_BG,
-            SSB_SPROM4_ANTAVAIL_BG_SHIFT);
-       SPEX(maxpwr_bg, SSB_SPROM4_MAXP_BG, SSB_SPROM4_MAXP_BG_MASK, 0);
-       SPEX(itssi_bg, SSB_SPROM4_MAXP_BG, SSB_SPROM4_ITSSI_BG,
-            SSB_SPROM4_ITSSI_BG_SHIFT);
-       SPEX(maxpwr_a, SSB_SPROM4_MAXP_A, SSB_SPROM4_MAXP_A_MASK, 0);
-       SPEX(itssi_a, SSB_SPROM4_MAXP_A, SSB_SPROM4_ITSSI_A,
-            SSB_SPROM4_ITSSI_A_SHIFT);
-       SPEX(gpio0, SSB_SPROM4_GPIOA, SSB_SPROM4_GPIOA_P0, 0);
-       SPEX(gpio1, SSB_SPROM4_GPIOA, SSB_SPROM4_GPIOA_P1,
-            SSB_SPROM4_GPIOA_P1_SHIFT);
-       SPEX(gpio2, SSB_SPROM4_GPIOB, SSB_SPROM4_GPIOB_P2, 0);
-       SPEX(gpio3, SSB_SPROM4_GPIOB, SSB_SPROM4_GPIOB_P3,
-            SSB_SPROM4_GPIOB_P3_SHIFT);
-
-       /* Extract the antenna gain values. */
-       SPEX(antenna_gain.ghz24.a0, SSB_SPROM4_AGAIN01,
-            SSB_SPROM4_AGAIN0, SSB_SPROM4_AGAIN0_SHIFT);
-       SPEX(antenna_gain.ghz24.a1, SSB_SPROM4_AGAIN01,
-            SSB_SPROM4_AGAIN1, SSB_SPROM4_AGAIN1_SHIFT);
-       SPEX(antenna_gain.ghz24.a2, SSB_SPROM4_AGAIN23,
-            SSB_SPROM4_AGAIN2, SSB_SPROM4_AGAIN2_SHIFT);
-       SPEX(antenna_gain.ghz24.a3, SSB_SPROM4_AGAIN23,
-            SSB_SPROM4_AGAIN3, SSB_SPROM4_AGAIN3_SHIFT);
-       memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24,
-              sizeof(out->antenna_gain.ghz5));
-
-       /* TODO - get remaining rev 4 stuff needed */
-}
-
-static int sprom_extract(struct ssb_bus *bus, struct ssb_sprom *out,
-                        const u16 *in, u16 size)
-{
-       memset(out, 0, sizeof(*out));
-
-       out->revision = in[size - 1] & 0x00FF;
-       ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision);
-       if ((bus->chip_id & 0xFF00) == 0x4400) {
-               /* Workaround: The BCM44XX chip has a stupid revision
-                * number stored in the SPROM.
-                * Always extract r1. */
-               out->revision = 1;
-               sprom_extract_r123(out, in);
-       } else if (bus->chip_id == 0x4321) {
-               /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
-               out->revision = 4;
-               sprom_extract_r4(out, in);
-       } else {
-               if (out->revision == 0)
-                       goto unsupported;
-               if (out->revision >= 1 && out->revision <= 3) {
-                       sprom_extract_r123(out, in);
-               }
-               if (out->revision == 4)
-                       sprom_extract_r4(out, in);
-               if (out->revision >= 5)
-                       goto unsupported;
-       }
-
-       return 0;
-unsupported:
-       ssb_printk(KERN_WARNING PFX "Unsupported SPROM revision %d "
-                  "detected. Will extract v1\n", out->revision);
-       sprom_extract_r123(out, in);
-       return 0;
-}
-
-static int ssb_pci_sprom_get(struct ssb_bus *bus,
-                            struct ssb_sprom *sprom)
-{
-       int err = -ENOMEM;
-       u16 *buf;
-
-       buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
-       if (!buf)
-               goto out;
-       bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
-       sprom_do_read(bus, buf);
-       err = sprom_check_crc(buf, bus->sprom_size);
-       if (err) {
-               /* check for rev 4 sprom - has special signature */
-               if (buf[32] == 0x5372) {
-                       kfree(buf);
-                       buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
-                                     GFP_KERNEL);
-                       if (!buf)
-                               goto out;
-                       bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
-                       sprom_do_read(bus, buf);
-                       err = sprom_check_crc(buf, bus->sprom_size);
-               }
-               if (err)
-                       ssb_printk(KERN_WARNING PFX "WARNING: Invalid"
-                                  " SPROM CRC (corrupt SPROM)\n");
-       }
-       err = sprom_extract(bus, sprom, buf, bus->sprom_size);
-
-       kfree(buf);
-out:
-       return err;
-}
-
-static void ssb_pci_get_boardinfo(struct ssb_bus *bus,
-                                 struct ssb_boardinfo *bi)
-{
-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID,
-                            &bi->vendor);
-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID,
-                            &bi->type);
-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
-                            &bi->rev);
-}
-
-int ssb_pci_get_invariants(struct ssb_bus *bus,
-                          struct ssb_init_invariants *iv)
-{
-       int err;
-
-       err = ssb_pci_sprom_get(bus, &iv->sprom);
-       if (err)
-               goto out;
-       ssb_pci_get_boardinfo(bus, &iv->boardinfo);
-
-out:
-       return err;
-}
-
-#ifdef CONFIG_SSB_DEBUG
-static int ssb_pci_assert_buspower(struct ssb_bus *bus)
-{
-       if (likely(bus->powered_up))
-               return 0;
-
-       printk(KERN_ERR PFX "FATAL ERROR: Bus powered down "
-              "while accessing PCI MMIO space\n");
-       if (bus->power_warn_count <= 10) {
-               bus->power_warn_count++;
-               dump_stack();
-       }
-
-       return -ENODEV;
-}
-#else /* DEBUG */
-static inline int ssb_pci_assert_buspower(struct ssb_bus *bus)
-{
-       return 0;
-}
-#endif /* DEBUG */
-
-static u16 ssb_pci_read16(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       if (unlikely(ssb_pci_assert_buspower(bus)))
-               return 0xFFFF;
-       if (unlikely(bus->mapped_device != dev)) {
-               if (unlikely(ssb_pci_switch_core(bus, dev)))
-                       return 0xFFFF;
-       }
-       return ioread16(bus->mmio + offset);
-}
-
-static u32 ssb_pci_read32(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       if (unlikely(ssb_pci_assert_buspower(bus)))
-               return 0xFFFFFFFF;
-       if (unlikely(bus->mapped_device != dev)) {
-               if (unlikely(ssb_pci_switch_core(bus, dev)))
-                       return 0xFFFFFFFF;
-       }
-       return ioread32(bus->mmio + offset);
-}
-
-static void ssb_pci_write16(struct ssb_device *dev, u16 offset, u16 value)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       if (unlikely(ssb_pci_assert_buspower(bus)))
-               return;
-       if (unlikely(bus->mapped_device != dev)) {
-               if (unlikely(ssb_pci_switch_core(bus, dev)))
-                       return;
-       }
-       iowrite16(value, bus->mmio + offset);
-}
-
-static void ssb_pci_write32(struct ssb_device *dev, u16 offset, u32 value)
-{
-       struct ssb_bus *bus = dev->bus;
-
-       if (unlikely(ssb_pci_assert_buspower(bus)))
-               return;
-       if (unlikely(bus->mapped_device != dev)) {
-               if (unlikely(ssb_pci_switch_core(bus, dev)))
-                       return;
-       }
-       iowrite32(value, bus->mmio + offset);
-}
-
-/* Not "static", as it's used in main.c */
-const struct ssb_bus_ops ssb_pci_ops = {
-       .read16         = ssb_pci_read16,
-       .read32         = ssb_pci_read32,
-       .write16        = ssb_pci_write16,
-       .write32        = ssb_pci_write32,
-};
-
-static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, u16 size)
-{
-       int i, pos = 0;
-
-       for (i = 0; i < size; i++)
-               pos += snprintf(buf + pos, buf_len - pos - 1,
-                               "%04X", swab16(sprom[i]) & 0xFFFF);
-       pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
-
-       return pos + 1;
-}
-
-static int hex2sprom(u16 *sprom, const char *dump, size_t len, u16 size)
-{
-       char tmp[5] = { 0 };
-       int cnt = 0;
-       unsigned long parsed;
-
-       if (len < size * 2)
-               return -EINVAL;
-
-       while (cnt < size) {
-               memcpy(tmp, dump, 4);
-               dump += 4;
-               parsed = simple_strtoul(tmp, NULL, 16);
-               sprom[cnt++] = swab16((u16)parsed);
-       }
-
-       return 0;
-}
-
-static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev,
-                                      struct device_attribute *attr,
-                                      char *buf)
-{
-       struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
-       struct ssb_bus *bus;
-       u16 *sprom;
-       int err = -ENODEV;
-       ssize_t count = 0;
-
-       bus = ssb_pci_dev_to_bus(pdev);
-       if (!bus)
-               goto out;
-       err = -ENOMEM;
-       sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
-       if (!sprom)
-               goto out;
-
-       /* Use interruptible locking, as the SPROM write might
-        * be holding the lock for several seconds. So allow userspace
-        * to cancel operation. */
-       err = -ERESTARTSYS;
-       if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
-               goto out_kfree;
-       sprom_do_read(bus, sprom);
-       mutex_unlock(&bus->pci_sprom_mutex);
-
-       count = sprom2hex(sprom, buf, PAGE_SIZE, bus->sprom_size);
-       err = 0;
-
-out_kfree:
-       kfree(sprom);
-out:
-       return err ? err : count;
-}
-
-static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
-                                       struct device_attribute *attr,
-                                       const char *buf, size_t count)
-{
-       struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
-       struct ssb_bus *bus;
-       u16 *sprom;
-       int res = 0, err = -ENODEV;
-
-       bus = ssb_pci_dev_to_bus(pdev);
-       if (!bus)
-               goto out;
-       err = -ENOMEM;
-       sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
-       if (!sprom)
-               goto out;
-       err = hex2sprom(sprom, buf, count, bus->sprom_size);
-       if (err) {
-               err = -EINVAL;
-               goto out_kfree;
-       }
-       err = sprom_check_crc(sprom, bus->sprom_size);
-       if (err) {
-               err = -EINVAL;
-               goto out_kfree;
-       }
-
-       /* Use interruptible locking, as the SPROM write might
-        * be holding the lock for several seconds. So allow userspace
-        * to cancel operation. */
-       err = -ERESTARTSYS;
-       if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
-               goto out_kfree;
-       err = ssb_devices_freeze(bus);
-       if (err == -EOPNOTSUPP) {
-               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. "
-                          "No suspend support. Is CONFIG_PM enabled?\n");
-               goto out_unlock;
-       }
-       if (err) {
-               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
-               goto out_unlock;
-       }
-       res = sprom_do_write(bus, sprom);
-       err = ssb_devices_thaw(bus);
-       if (err)
-               ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
-out_unlock:
-       mutex_unlock(&bus->pci_sprom_mutex);
-out_kfree:
-       kfree(sprom);
-out:
-       if (res)
-               return res;
-       return err ? err : count;
-}
-
-static DEVICE_ATTR(ssb_sprom, 0600,
-                  ssb_pci_attr_sprom_show,
-                  ssb_pci_attr_sprom_store);
-
-void ssb_pci_exit(struct ssb_bus *bus)
-{
-       struct pci_dev *pdev;
-
-       if (bus->bustype != SSB_BUSTYPE_PCI)
-               return;
-
-       pdev = bus->host_pci;
-       device_remove_file(&pdev->dev, &dev_attr_ssb_sprom);
-}
-
-int ssb_pci_init(struct ssb_bus *bus)
-{
-       struct pci_dev *pdev;
-       int err;
-
-       if (bus->bustype != SSB_BUSTYPE_PCI)
-               return 0;
-
-       pdev = bus->host_pci;
-       mutex_init(&bus->pci_sprom_mutex);
-       err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom);
-       if (err)
-               goto out;
-
-out:
-       return err;
-}
diff --git a/target/linux/generic-2.6/files/drivers/ssb/pcihost_wrapper.c b/target/linux/generic-2.6/files/drivers/ssb/pcihost_wrapper.c
deleted file mode 100644 (file)
index 82a10ab..0000000
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * PCI Hostdevice wrapper
- *
- * Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>
- * Copyright (c) 2005 Stefano Brivio <st3@riseup.net>
- * Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org>
- * Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
- * Copyright (c) 2005-2007 Michael Buesch <mbuesch@freenet.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/pci.h>
-#include <linux/ssb/ssb.h>
-
-
-#ifdef CONFIG_PM
-static int ssb_pcihost_suspend(struct pci_dev *dev, pm_message_t state)
-{
-       pci_save_state(dev);
-       pci_disable_device(dev);
-       pci_set_power_state(dev, pci_choose_state(dev, state));
-
-       return 0;
-}
-
-static int ssb_pcihost_resume(struct pci_dev *dev)
-{
-       int err;
-
-       pci_set_power_state(dev, 0);
-       err = pci_enable_device(dev);
-       if (err)
-               return err;
-       pci_restore_state(dev);
-
-       return 0;
-}
-#else /* CONFIG_PM */
-# define ssb_pcihost_suspend   NULL
-# define ssb_pcihost_resume    NULL
-#endif /* CONFIG_PM */
-
-static int ssb_pcihost_probe(struct pci_dev *dev,
-                            const struct pci_device_id *id)
-{
-       struct ssb_bus *ssb;
-       int err = -ENOMEM;
-       const char *name;
-
-       ssb = kzalloc(sizeof(*ssb), GFP_KERNEL);
-       if (!ssb)
-               goto out;
-       err = pci_enable_device(dev);
-       if (err)
-               goto err_kfree_ssb;
-       name = dev->dev.bus_id;
-       if (dev->driver && dev->driver->name)
-               name = dev->driver->name;
-       err = pci_request_regions(dev, name);
-       if (err)
-               goto err_pci_disable;
-       pci_set_master(dev);
-
-       err = ssb_bus_pcibus_register(ssb, dev);
-       if (err)
-               goto err_pci_release_regions;
-
-       pci_set_drvdata(dev, ssb);
-
-out:
-       return err;
-
-err_pci_release_regions:
-       pci_release_regions(dev);
-err_pci_disable:
-       pci_disable_device(dev);
-err_kfree_ssb:
-       kfree(ssb);
-       return err;
-}
-
-static void ssb_pcihost_remove(struct pci_dev *dev)
-{
-       struct ssb_bus *ssb = pci_get_drvdata(dev);
-
-       ssb_bus_unregister(ssb);
-       pci_release_regions(dev);
-       pci_disable_device(dev);
-       kfree(ssb);
-       pci_set_drvdata(dev, NULL);
-}
-
-int ssb_pcihost_register(struct pci_driver *driver)
-{
-       driver->probe = ssb_pcihost_probe;
-       driver->remove = ssb_pcihost_remove;
-       driver->suspend = ssb_pcihost_suspend;
-       driver->resume = ssb_pcihost_resume;
-
-       return pci_register_driver(driver);
-}
-EXPORT_SYMBOL(ssb_pcihost_register);
diff --git a/target/linux/generic-2.6/files/drivers/ssb/pcmcia.c b/target/linux/generic-2.6/files/drivers/ssb/pcmcia.c
deleted file mode 100644 (file)
index 46816cd..0000000
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * PCMCIA-Hostbus related functions
- *
- * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
- * Copyright 2007 Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-#include <linux/delay.h>
-#include <linux/io.h>
-
-#include <pcmcia/cs_types.h>
-#include <pcmcia/cs.h>
-#include <pcmcia/cistpl.h>
-#include <pcmcia/ciscode.h>
-#include <pcmcia/ds.h>
-#include <pcmcia/cisreg.h>
-
-#include "ssb_private.h"
-
-
-/* Define the following to 1 to enable a printk on each coreswitch. */
-#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG             0
-
-
-int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
-                             u8 coreidx)
-{
-       struct pcmcia_device *pdev = bus->host_pcmcia;
-       int err;
-       int attempts = 0;
-       u32 cur_core;
-       conf_reg_t reg;
-       u32 addr;
-       u32 read_addr;
-
-       addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
-       while (1) {
-               reg.Action = CS_WRITE;
-               reg.Offset = 0x2E;
-               reg.Value = (addr & 0x0000F000) >> 12;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-               reg.Offset = 0x30;
-               reg.Value = (addr & 0x00FF0000) >> 16;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-               reg.Offset = 0x32;
-               reg.Value = (addr & 0xFF000000) >> 24;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-
-               read_addr = 0;
-
-               reg.Action = CS_READ;
-               reg.Offset = 0x2E;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-               read_addr |= ((u32)(reg.Value & 0x0F)) << 12;
-               reg.Offset = 0x30;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-               read_addr |= ((u32)reg.Value) << 16;
-               reg.Offset = 0x32;
-               err = pcmcia_access_configuration_register(pdev, &reg);
-               if (err != CS_SUCCESS)
-                       goto error;
-               read_addr |= ((u32)reg.Value) << 24;
-
-               cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
-               if (cur_core == coreidx)
-                       break;
-
-               if (attempts++ > SSB_BAR0_MAX_RETRIES)
-                       goto error;
-               udelay(10);
-       }
-
-       return 0;
-error:
-       ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
-       return -ENODEV;
-}
-
-int ssb_pcmcia_switch_core(struct ssb_bus *bus,
-                          struct ssb_device *dev)
-{
-       int err;
-
-#if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG
-       ssb_printk(KERN_INFO PFX
-                  "Switching to %s core, index %d\n",
-                  ssb_core_name(dev->id.coreid),
-                  dev->core_index);
-#endif
-
-       err = ssb_pcmcia_switch_coreidx(bus, dev->core_index);
-       if (!err)
-               bus->mapped_device = dev;
-
-       return err;
-}
-
-int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
-{
-       int attempts = 0;
-       conf_reg_t reg;
-       int res;
-
-       SSB_WARN_ON((seg != 0) && (seg != 1));
-       reg.Offset = 0x34;
-       reg.Function = 0;
-       while (1) {
-               reg.Action = CS_WRITE;
-               reg.Value = seg;
-               res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
-               if (unlikely(res != CS_SUCCESS))
-                       goto error;
-               reg.Value = 0xFF;
-               reg.Action = CS_READ;
-               res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
-               if (unlikely(res != CS_SUCCESS))
-                       goto error;
-
-               if (reg.Value == seg)
-                       break;
-
-               if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
-                       goto error;
-               udelay(10);
-       }
-       bus->mapped_pcmcia_seg = seg;
-
-       return 0;
-error:
-       ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
-       return -ENODEV;
-}
-
-static int select_core_and_segment(struct ssb_device *dev,
-                                  u16 *offset)
-{
-       struct ssb_bus *bus = dev->bus;
-       int err;
-       u8 need_segment;
-
-       if (*offset >= 0x800) {
-               *offset -= 0x800;
-               need_segment = 1;
-       } else
-               need_segment = 0;
-
-       if (unlikely(dev != bus->mapped_device)) {
-               err = ssb_pcmcia_switch_core(bus, dev);
-               if (unlikely(err))
-                       return err;
-       }
-       if (unlikely(need_segment != bus->mapped_pcmcia_seg)) {
-               err = ssb_pcmcia_switch_segment(bus, need_segment);
-               if (unlikely(err))
-                       return err;
-       }
-
-       return 0;
-}
-
-static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-       unsigned long flags;
-       int err;
-       u16 value = 0xFFFF;
-
-       spin_lock_irqsave(&bus->bar_lock, flags);
-       err = select_core_and_segment(dev, &offset);
-       if (likely(!err))
-               value = readw(bus->mmio + offset);
-       spin_unlock_irqrestore(&bus->bar_lock, flags);
-
-       return value;
-}
-
-static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset)
-{
-       struct ssb_bus *bus = dev->bus;
-       unsigned long flags;
-       int err;
-       u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF;
-
-       spin_lock_irqsave(&bus->bar_lock, flags);
-       err = select_core_and_segment(dev, &offset);
-       if (likely(!err)) {
-               lo = readw(bus->mmio + offset);
-               hi = readw(bus->mmio + offset + 2);
-       }
-       spin_unlock_irqrestore(&bus->bar_lock, flags);
-
-       return (lo | (hi << 16));
-}
-
-static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value)
-{
-       struct ssb_bus *bus = dev->bus;
-       unsigned long flags;
-       int err;
-
-       spin_lock_irqsave(&bus->bar_lock, flags);
-       err = select_core_and_segment(dev, &offset);
-       if (likely(!err))
-               writew(value, bus->mmio + offset);
-       mmiowb();
-       spin_unlock_irqrestore(&bus->bar_lock, flags);
-}
-
-static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value)
-{
-       struct ssb_bus *bus = dev->bus;
-       unsigned long flags;
-       int err;
-
-       spin_lock_irqsave(&bus->bar_lock, flags);
-       err = select_core_and_segment(dev, &offset);
-       if (likely(!err)) {
-               writew((value & 0x0000FFFF), bus->mmio + offset);
-               writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2);
-       }
-       mmiowb();
-       spin_unlock_irqrestore(&bus->bar_lock, flags);
-}
-
-/* Not "static", as it's used in main.c */
-const struct ssb_bus_ops ssb_pcmcia_ops = {
-       .read16         = ssb_pcmcia_read16,
-       .read32         = ssb_pcmcia_read32,
-       .write16        = ssb_pcmcia_write16,
-       .write32        = ssb_pcmcia_write32,
-};
-
-#include <linux/etherdevice.h>
-int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
-                             struct ssb_init_invariants *iv)
-{
-       //TODO
-       random_ether_addr(iv->sprom.il0mac);
-       return 0;
-}
-
-int ssb_pcmcia_init(struct ssb_bus *bus)
-{
-       conf_reg_t reg;
-       int err;
-
-       if (bus->bustype != SSB_BUSTYPE_PCMCIA)
-               return 0;
-
-       /* Switch segment to a known state and sync
-        * bus->mapped_pcmcia_seg with hardware state. */
-       ssb_pcmcia_switch_segment(bus, 0);
-
-       /* Init IRQ routing */
-       reg.Action = CS_READ;
-       reg.Function = 0;
-       if (bus->chip_id == 0x4306)
-               reg.Offset = 0x00;
-       else
-               reg.Offset = 0x80;
-       err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
-       if (err != CS_SUCCESS)
-               goto error;
-       reg.Action = CS_WRITE;
-       reg.Value |= 0x04 | 0x01;
-       err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
-       if (err != CS_SUCCESS)
-               goto error;
-
-       return 0;
-error:
-       return -ENODEV;
-}
diff --git a/target/linux/generic-2.6/files/drivers/ssb/scan.c b/target/linux/generic-2.6/files/drivers/ssb/scan.c
deleted file mode 100644 (file)
index 63ee5cf..0000000
+++ /dev/null
@@ -1,424 +0,0 @@
-/*
- * Sonics Silicon Backplane
- * Bus scanning
- *
- * Copyright (C) 2005-2007 Michael Buesch <mb@bu3sch.de>
- * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
- * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
- * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
- * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
- * Copyright (C) 2006 Broadcom Corporation.
- *
- * Licensed under the GNU/GPL. See COPYING for details.
- */
-
-#include <linux/ssb/ssb.h>
-#include <linux/ssb/ssb_regs.h>
-#include <linux/pci.h>
-#include <linux/io.h>
-
-#include <pcmcia/cs_types.h>
-#include <pcmcia/cs.h>
-#include <pcmcia/cistpl.h>
-#include <pcmcia/ds.h>
-
-#include "ssb_private.h"
-
-
-const char *ssb_core_name(u16 coreid)
-{
-       switch (coreid) {
-       case SSB_DEV_CHIPCOMMON:
-               return "ChipCommon";
-       case SSB_DEV_ILINE20:
-               return "ILine 20";
-       case SSB_DEV_SDRAM:
-               return "SDRAM";
-       case SSB_DEV_PCI:
-               return "PCI";
-       case SSB_DEV_MIPS:
-               return "MIPS";
-       case SSB_DEV_ETHERNET:
-               return "Fast Ethernet";
-       case SSB_DEV_V90:
-               return "V90";
-       case SSB_DEV_USB11_HOSTDEV:
-               return "USB 1.1 Hostdev";
-       case SSB_DEV_ADSL:
-               return "ADSL";
-       case SSB_DEV_ILINE100:
-               return "ILine 100";
-       case SSB_DEV_IPSEC:
-               return "IPSEC";
-       case SSB_DEV_PCMCIA:
-               return "PCMCIA";
-       case SSB_DEV_INTERNAL_MEM:
-               return "Internal Memory";
-       case SSB_DEV_MEMC_SDRAM:
-               return "MEMC SDRAM";
-       case SSB_DEV_EXTIF:
-               return "EXTIF";
-       case SSB_DEV_80211:
-               return "IEEE 802.11";
-       case SSB_DEV_MIPS_3302:
-               return "MIPS 3302";
-       case SSB_DEV_USB11_HOST:
-               return "USB 1.1 Host";
-       case SSB_DEV_USB11_DEV:
-               return "USB 1.1 Device";
-       case SSB_DEV_USB20_HOST:
-               return "USB 2.0 Host";
-       case SSB_DEV_USB20_DEV:
-               return "USB 2.0 Device";
-       case SSB_DEV_SDIO_HOST:
-               return "SDIO Host";
-       case SSB_DEV_ROBOSWITCH:
-               return "Roboswitch";
-       case SSB_DEV_PARA_ATA:
-               return "PATA";
-       case SSB_DEV_SATA_XORDMA:
-               return "SATA XOR-DMA";
-       case SSB_DEV_ETHERNET_GBIT:
-               return "GBit Ethernet";
-       case SSB_DEV_PCIE:
-               return "PCI-E";
-       case SSB_DEV_MIMO_PHY:
-               return "MIMO PHY";
-       case SSB_DEV_SRAM_CTRLR:
-               return "SRAM Controller";
-       case SSB_DEV_MINI_MACPHY:
-               return "Mini MACPHY";
-       case SSB_DEV_ARM_1176:
-               return "ARM 1176";
-       case SSB_DEV_ARM_7TDMI:
-               return "ARM 7TDMI";
-       }
-       return "UNKNOWN";
-}
-
-static u16 pcidev_to_chipid(struct pci_dev *pci_dev)
-{
-       u16 chipid_fallback = 0;
-
-       switch (pci_dev->device) {
-       case 0x4301:
-               chipid_fallback = 0x4301;
-               break;
-       case 0x4305 ... 0x4307:
-               chipid_fallback = 0x4307;
-               break;
-       case 0x4403:
-               chipid_fallback = 0x4402;
-               break;
-       case 0x4610 ... 0x4615:
-               chipid_fallback = 0x4610;
-               break;
-       case 0x4710 ... 0x4715:
-               chipid_fallback = 0x4710;
-               break;
-       case 0x4320 ... 0x4325:
-               chipid_fallback = 0x4309;
-               break;
-       case PCI_DEVICE_ID_BCM4401:
-       case PCI_DEVICE_ID_BCM4401B0:
-       case PCI_DEVICE_ID_BCM4401B1:
-               chipid_fallback = 0x4401;
-               break;
-       default:
-               ssb_printk(KERN_ERR PFX
-                          "PCI-ID not in fallback list\n");
-       }
-
-       return chipid_fallback;
-}
-
-static u8 chipid_to_nrcores(u16 chipid)
-{
-       switch (chipid) {
-       case 0x5365:
-               return 7;
-       case 0x4306:
-               return 6;
-       case 0x4310:
-               return 8;
-       case 0x4307:
-       case 0x4301:
-               return 5;
-       case 0x4401:
-       case 0x4402:
-               return 3;
-       case 0x4710:
-       case 0x4610:
-       case 0x4704:
-               return 9;
-       default:
-               ssb_printk(KERN_ERR PFX
-                          "CHIPID not in nrcores fallback list\n");
-       }
-
-       return 1;
-}
-
-static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx,
-                      u16 offset)
-{
-       switch (bus->bustype) {
-       case SSB_BUSTYPE_SSB:
-               offset += current_coreidx * SSB_CORE_SIZE;
-               break;
-       case SSB_BUSTYPE_PCI:
-               break;
-       case SSB_BUSTYPE_PCMCIA:
-               if (offset >= 0x800) {
-                       ssb_pcmcia_switch_segment(bus, 1);
-                       offset -= 0x800;
-               } else
-                       ssb_pcmcia_switch_segment(bus, 0);
-               break;
-       }
-       return readl(bus->mmio + offset);
-}
-
-static int scan_switchcore(struct ssb_bus *bus, u8 coreidx)
-{
-       switch (bus->bustype) {
-       case SSB_BUSTYPE_SSB:
-               break;
-       case SSB_BUSTYPE_PCI:
-               return ssb_pci_switch_coreidx(bus, coreidx);
-       case SSB_BUSTYPE_PCMCIA:
-               return ssb_pcmcia_switch_coreidx(bus, coreidx);
-       }
-       return 0;
-}
-
-void ssb_iounmap(struct ssb_bus *bus)
-{
-       switch (bus->bustype) {
-       case SSB_BUSTYPE_SSB:
-       case SSB_BUSTYPE_PCMCIA:
-               iounmap(bus->mmio);
-               break;
-       case SSB_BUSTYPE_PCI:
-#ifdef CONFIG_SSB_PCIHOST
-               pci_iounmap(bus->host_pci, bus->mmio);
-#else
-               SSB_BUG_ON(1); /* Can't reach this code. */
-#endif
-               break;
-       }
-       bus->mmio = NULL;
-       bus->mapped_device = NULL;
-}
-
-static void __iomem *ssb_ioremap(struct ssb_bus *bus,
-                                unsigned long baseaddr)
-{
-       void __iomem *mmio = NULL;
-
-       switch (bus->bustype) {
-       case SSB_BUSTYPE_SSB:
-               /* Only map the first core for now. */
-               /* fallthrough... */
-       case SSB_BUSTYPE_PCMCIA:
-               mmio = ioremap(baseaddr, SSB_CORE_SIZE);
-               break;
-       case SSB_BUSTYPE_PCI:
-#ifdef CONFIG_SSB_PCIHOST
-               mmio = pci_iomap(bus->host_pci, 0, ~0UL);
-#else
-               SSB_BUG_ON(1); /* Can't reach this code. */
-#endif
-               break;
-       }
-
-       return mmio;
-}
-
-static int we_support_multiple_80211_cores(struct ssb_bus *bus)
-{
-       /* More than one 802.11 core is only supported by special chips.
-        * There are chips with two 802.11 cores, but with dangling
-        * pins on the second core. Be careful and reject them here.
-        */
-
-#ifdef CONFIG_SSB_PCIHOST
-       if (bus->bustype == SSB_BUSTYPE_PCI) {
-               if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM &&
-                   bus->host_pci->device == 0x4324)
-                       return 1;
-       }
-#endif /* CONFIG_SSB_PCIHOST */
-       return 0;
-}
-
-int ssb_bus_scan(struct ssb_bus *bus,
-                unsigned long baseaddr)
-{
-       int err = -ENOMEM;
-       void __iomem *mmio;
-       u32 idhi, cc, rev, tmp;
-       int dev_i, i;
-       struct ssb_device *dev;
-       int nr_80211_cores = 0;
-
-       mmio = ssb_ioremap(bus, baseaddr);
-       if (!mmio)
-               goto out;
-       bus->mmio = mmio;
-
-       err = scan_switchcore(bus, 0); /* Switch to first core */
-       if (err)
-               goto err_unmap;
-
-       idhi = scan_read32(bus, 0, SSB_IDHIGH);
-       cc = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT;
-       rev = (idhi & SSB_IDHIGH_RCLO);
-       rev |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT;
-
-       bus->nr_devices = 0;
-       if (cc == SSB_DEV_CHIPCOMMON) {
-               tmp = scan_read32(bus, 0, SSB_CHIPCO_CHIPID);
-
-               bus->chip_id = (tmp & SSB_CHIPCO_IDMASK);
-               bus->chip_rev = (tmp & SSB_CHIPCO_REVMASK) >>
-                               SSB_CHIPCO_REVSHIFT;
-               bus->chip_package = (tmp & SSB_CHIPCO_PACKMASK) >>
-                                   SSB_CHIPCO_PACKSHIFT;
-               if (rev >= 4) {
-                       bus->nr_devices = (tmp & SSB_CHIPCO_NRCORESMASK) >>
-                                         SSB_CHIPCO_NRCORESSHIFT;
-               }
-               tmp = scan_read32(bus, 0, SSB_CHIPCO_CAP);
-               bus->chipco.capabilities = tmp;
-       } else {
-               if (bus->bustype == SSB_BUSTYPE_PCI) {
-                       bus->chip_id = pcidev_to_chipid(bus->host_pci);
-                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID,
-                                            &bus->chip_rev);
-                       bus->chip_package = 0;
-               } else {
-                       bus->chip_id = 0x4710;
-                       bus->chip_rev = 0;
-                       bus->chip_package = 0;
-               }
-       }
-       if (!bus->nr_devices)
-               bus->nr_devices = chipid_to_nrcores(bus->chip_id);
-       if (bus->nr_devices > ARRAY_SIZE(bus->devices)) {
-               ssb_printk(KERN_ERR PFX
-                          "More than %d ssb cores found (%d)\n",
-                          SSB_MAX_NR_CORES, bus->nr_devices);
-               goto err_unmap;
-       }
-       if (bus->bustype == SSB_BUSTYPE_SSB) {
-               /* Now that we know the number of cores,
-                * remap the whole IO space for all cores.
-                */
-               err = -ENOMEM;
-               iounmap(mmio);
-               mmio = ioremap(baseaddr, SSB_CORE_SIZE * bus->nr_devices);
-               if (!mmio)
-                       goto out;
-               bus->mmio = mmio;
-       }
-
-       /* Fetch basic information about each core/device */
-       for (i = 0, dev_i = 0; i < bus->nr_devices; i++) {
-               err = scan_switchcore(bus, i);
-               if (err)
-                       goto err_unmap;
-               dev = &(bus->devices[dev_i]);
-
-               idhi = scan_read32(bus, i, SSB_IDHIGH);
-               dev->id.coreid = (idhi & SSB_IDHIGH_CC) >> SSB_IDHIGH_CC_SHIFT;
-               dev->id.revision = (idhi & SSB_IDHIGH_RCLO);
-               dev->id.revision |= (idhi & SSB_IDHIGH_RCHI) >> SSB_IDHIGH_RCHI_SHIFT;
-               dev->id.vendor = (idhi & SSB_IDHIGH_VC) >> SSB_IDHIGH_VC_SHIFT;
-               dev->core_index = i;
-               dev->bus = bus;
-               dev->ops = bus->ops;
-
-               ssb_dprintk(KERN_INFO PFX
-                           "Core %d found: %s "
-                           "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n",
-                           i, ssb_core_name(dev->id.coreid),
-                           dev->id.coreid, dev->id.revision, dev->id.vendor);
-
-               switch (dev->id.coreid) {
-               case SSB_DEV_80211:
-                       nr_80211_cores++;
-                       if (nr_80211_cores > 1) {
-                               if (!we_support_multiple_80211_cores(bus)) {
-                                       ssb_dprintk(KERN_INFO PFX "Ignoring additional "
-                                                   "802.11 core\n");
-                                       continue;
-                               }
-                       }
-                       break;
-               case SSB_DEV_EXTIF:
-#ifdef CONFIG_SSB_DRIVER_EXTIF
-                       if (bus->extif.dev) {
-                               ssb_printk(KERN_WARNING PFX
-                                          "WARNING: Multiple EXTIFs found\n");
-                               break;
-                       }
-                       bus->extif.dev = dev;
-#endif /* CONFIG_SSB_DRIVER_EXTIF */
-                       break;
-               case SSB_DEV_CHIPCOMMON:
-                       if (bus->chipco.dev) {
-                               ssb_printk(KERN_WARNING PFX
-                                          "WARNING: Multiple ChipCommon found\n");
-                               break;
-                       }
-                       bus->chipco.dev = dev;
-                       break;
-               case SSB_DEV_MIPS:
-               case SSB_DEV_MIPS_3302:
-#ifdef CONFIG_SSB_DRIVER_MIPS
-                       if (bus->mipscore.dev) {
-                               ssb_printk(KERN_WARNING PFX
-                                          "WARNING: Multiple MIPS cores found\n");
-                               break;
-                       }
-                       bus->mipscore.dev = dev;
-#endif /* CONFIG_SSB_DRIVER_MIPS */
-                       break;
-               case SSB_DEV_PCI:
-               case SSB_DEV_PCIE:
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-                       if (bus->bustype == SSB_BUSTYPE_PCI) {
-                               /* Ignore PCI cores on PCI-E cards.
-                                * Ignore PCI-E cores on PCI cards. */
-                               if (dev->id.coreid == SSB_DEV_PCI) {
-                                       if (bus->host_pci->is_pcie)
-                                               continue;
-                               } else {
-                                       if (!bus->host_pci->is_pcie)
-                                               continue;
-                               }
-                       }
-                       if (bus->pcicore.dev) {
-                               ssb_printk(KERN_WARNING PFX
-                                          "WARNING: Multiple PCI(E) cores found\n");
-                               break;
-                       }
-                       bus->pcicore.dev = dev;
-#endif /* CONFIG_SSB_DRIVER_PCICORE */
-                       break;
-               default:
-                       break;
-               }
-
-               dev_i++;
-       }
-       bus->nr_devices = dev_i;
-
-       err = 0;
-out:
-       return err;
-err_unmap:
-       ssb_iounmap(bus);
-       goto out;
-}
diff --git a/target/linux/generic-2.6/files/drivers/ssb/ssb_private.h b/target/linux/generic-2.6/files/drivers/ssb/ssb_private.h
deleted file mode 100644 (file)
index a789364..0000000
+++ /dev/null
@@ -1,136 +0,0 @@
-#ifndef LINUX_SSB_PRIVATE_H_
-#define LINUX_SSB_PRIVATE_H_
-
-#include <linux/ssb/ssb.h>
-#include <linux/types.h>
-
-
-#define PFX    "ssb: "
-
-#ifdef CONFIG_SSB_SILENT
-# define ssb_printk(fmt, x...) do { /* nothing */ } while (0)
-#else
-# define ssb_printk            printk
-#endif /* CONFIG_SSB_SILENT */
-
-/* dprintk: Debugging printk; vanishes for non-debug compilation */
-#ifdef CONFIG_SSB_DEBUG
-# define ssb_dprintk(fmt, x...)        ssb_printk(fmt , ##x)
-#else
-# define ssb_dprintk(fmt, x...)        do { /* nothing */ } while (0)
-#endif
-
-#ifdef CONFIG_SSB_DEBUG
-# define SSB_WARN_ON(x)                WARN_ON(x)
-# define SSB_BUG_ON(x)         BUG_ON(x)
-#else
-static inline int __ssb_do_nothing(int x) { return x; }
-# define SSB_WARN_ON(x)                __ssb_do_nothing(unlikely(!!(x)))
-# define SSB_BUG_ON(x)         __ssb_do_nothing(unlikely(!!(x)))
-#endif
-
-
-/* pci.c */
-#ifdef CONFIG_SSB_PCIHOST
-extern int ssb_pci_switch_core(struct ssb_bus *bus,
-                              struct ssb_device *dev);
-extern int ssb_pci_switch_coreidx(struct ssb_bus *bus,
-                                 u8 coreidx);
-extern int ssb_pci_xtal(struct ssb_bus *bus, u32 what,
-                       int turn_on);
-extern int ssb_pci_get_invariants(struct ssb_bus *bus,
-                                 struct ssb_init_invariants *iv);
-extern void ssb_pci_exit(struct ssb_bus *bus);
-extern int ssb_pci_init(struct ssb_bus *bus);
-extern const struct ssb_bus_ops ssb_pci_ops;
-
-#else /* CONFIG_SSB_PCIHOST */
-
-static inline int ssb_pci_switch_core(struct ssb_bus *bus,
-                                     struct ssb_device *dev)
-{
-       return 0;
-}
-static inline int ssb_pci_switch_coreidx(struct ssb_bus *bus,
-                                        u8 coreidx)
-{
-       return 0;
-}
-static inline int ssb_pci_xtal(struct ssb_bus *bus, u32 what,
-                              int turn_on)
-{
-       return 0;
-}
-static inline void ssb_pci_exit(struct ssb_bus *bus)
-{
-}
-static inline int ssb_pci_init(struct ssb_bus *bus)
-{
-       return 0;
-}
-#endif /* CONFIG_SSB_PCIHOST */
-
-
-/* pcmcia.c */
-#ifdef CONFIG_SSB_PCMCIAHOST
-extern int ssb_pcmcia_switch_core(struct ssb_bus *bus,
-                                 struct ssb_device *dev);
-extern int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
-                                    u8 coreidx);
-extern int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
-                                    u8 seg);
-extern int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
-                                    struct ssb_init_invariants *iv);
-extern int ssb_pcmcia_init(struct ssb_bus *bus);
-extern const struct ssb_bus_ops ssb_pcmcia_ops;
-#else /* CONFIG_SSB_PCMCIAHOST */
-static inline int ssb_pcmcia_switch_core(struct ssb_bus *bus,
-                                        struct ssb_device *dev)
-{
-       return 0;
-}
-static inline int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
-                                           u8 coreidx)
-{
-       return 0;
-}
-static inline int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
-                                           u8 seg)
-{
-       return 0;
-}
-static inline int ssb_pcmcia_init(struct ssb_bus *bus)
-{
-       return 0;
-}
-#endif /* CONFIG_SSB_PCMCIAHOST */
-
-
-/* scan.c */
-extern const char *ssb_core_name(u16 coreid);
-extern int ssb_bus_scan(struct ssb_bus *bus,
-                       unsigned long baseaddr);
-extern void ssb_iounmap(struct ssb_bus *ssb);
-
-
-/* core.c */
-extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m);
-extern int ssb_devices_freeze(struct ssb_bus *bus);
-extern int ssb_devices_thaw(struct ssb_bus *bus);
-extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev);
-
-/* b43_pci_bridge.c */
-#ifdef CONFIG_SSB_PCIHOST
-extern int __init b43_pci_ssb_bridge_init(void);
-extern void __exit b43_pci_ssb_bridge_exit(void);
-#else /* CONFIG_SSB_PCIHOST */
-static inline int b43_pci_ssb_bridge_init(void)
-{
-       return 0;
-}
-static inline void b43_pci_ssb_bridge_exit(void)
-{
-}
-#endif /* CONFIG_SSB_PCIHOST */
-
-#endif /* LINUX_SSB_PRIVATE_H_ */
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/Kconfig b/target/linux/generic-2.6/files/fs/yaffs2/Kconfig
deleted file mode 100644 (file)
index 7b6f836..0000000
+++ /dev/null
@@ -1,175 +0,0 @@
-#
-# YAFFS file system configurations
-#
-
-config YAFFS_FS
-       tristate "YAFFS2 file system support"
-       default n
-       depends on MTD
-       select YAFFS_YAFFS1
-       select YAFFS_YAFFS2
-       help
-         YAFFS2, or Yet Another Flash Filing System, is a filing system
-         optimised for NAND Flash chips.
-
-         To compile the YAFFS2 file system support as a module, choose M
-         here: the module will be called yaffs2.
-
-         If unsure, say N.
-
-         Further information on YAFFS2 is available at
-         <http://www.aleph1.co.uk/yaffs/>.
-
-config YAFFS_YAFFS1
-       bool "512 byte / page devices"
-       depends on YAFFS_FS
-       default y
-       help
-         Enable YAFFS1 support -- yaffs for 512 byte / page devices
-
-         Not needed for 2K-page devices.
-
-         If unsure, say Y.
-
-config YAFFS_9BYTE_TAGS
-       bool "Use older-style on-NAND data format with pageStatus byte"
-       depends on YAFFS_YAFFS1
-       default n
-       help
-
-         Older-style on-NAND data format has a "pageStatus" byte to record
-         chunk/page state.  This byte is zero when the page is discarded.
-         Choose this option if you have existing on-NAND data using this
-         format that you need to continue to support.  New data written
-         also uses the older-style format.  Note: Use of this option
-         generally requires that MTD's oob layout be adjusted to use the
-         older-style format.  See notes on tags formats and MTD versions.
-
-         If unsure, say N.
-
-config YAFFS_DOES_ECC
-       bool "Lets Yaffs do its own ECC"
-       depends on YAFFS_FS && YAFFS_YAFFS1 && !YAFFS_9BYTE_TAGS
-       default n
-       help
-         This enables Yaffs to use its own ECC functions instead of using
-         the ones from the generic MTD-NAND driver.
-
-         If unsure, say N.
-
-config YAFFS_ECC_WRONG_ORDER
-       bool "Use the same ecc byte order as Steven Hill's nand_ecc.c"
-       depends on YAFFS_FS && YAFFS_DOES_ECC && !YAFFS_9BYTE_TAGS
-       default n
-       help
-         This makes yaffs_ecc.c use the same ecc byte order as Steven
-         Hill's nand_ecc.c. If not set, then you get the same ecc byte
-         order as SmartMedia.
-
-         If unsure, say N.
-
-config YAFFS_YAFFS2
-       bool "2048 byte (or larger) / page devices"
-       depends on YAFFS_FS
-       default y
-       help
-         Enable YAFFS2 support -- yaffs for >= 2K bytes per page devices
-
-         If unsure, say Y.
-
-config YAFFS_AUTO_YAFFS2
-       bool "Autoselect yaffs2 format"
-       depends on YAFFS_YAFFS2
-       default y
-       help
-         Without this, you need to explicitely use yaffs2 as the file
-         system type. With this, you can say "yaffs" and yaffs or yaffs2
-         will be used depending on the device page size (yaffs on
-         512-byte page devices, yaffs2 on 2K page devices).
-
-         If unsure, say Y.
-
-config YAFFS_DISABLE_LAZY_LOAD
-       bool "Disable lazy loading"
-       depends on YAFFS_YAFFS2
-       default n
-       help
-         "Lazy loading" defers loading file details until they are
-         required. This saves mount time, but makes the first look-up
-         a bit longer.
-
-         Lazy loading will only happen if enabled by this option being 'n'
-         and if the appropriate tags are available, else yaffs2 will
-         automatically fall back to immediate loading and do the right
-         thing.
-
-         Lazy laoding will be required by checkpointing.
-
-         Setting this to 'y' will disable lazy loading.
-
-         If unsure, say N.
-
-config YAFFS_CHECKPOINT_RESERVED_BLOCKS
-       int "Reserved blocks for checkpointing"
-       depends on YAFFS_YAFFS2
-       default 10
-       help
-          Give the number of Blocks to reserve for checkpointing.
-         Checkpointing saves the state at unmount so that mounting is
-         much faster as a scan of all the flash to regenerate this state
-         is not needed.  These Blocks are reserved per partition, so if
-         you have very small partitions the default (10) may be a mess
-         for you.  You can set this value to 0, but that does not mean
-         checkpointing is disabled at all. There only won't be any
-         specially reserved blocks for checkpointing, so if there is
-         enough free space on the filesystem, it will be used for
-         checkpointing.
-
-         If unsure, leave at default (10), but don't wonder if there are
-         always 2MB used on your large page device partition (10 x 2k
-         pagesize). When using small partitions or when being very small
-         on space, you probably want to set this to zero.
-
-config YAFFS_DISABLE_WIDE_TNODES
-       bool "Turn off wide tnodes"
-       depends on YAFFS_FS
-       default n
-       help
-         Wide tnodes are only used for NAND arrays >=32MB for 512-byte
-         page devices and >=128MB for 2k page devices. They use slightly
-         more RAM but are faster since they eliminate chunk group
-         searching.
-
-         Setting this to 'y' will force tnode width to 16 bits and save
-         memory but make large arrays slower.
-
-         If unsure, say N.
-
-config YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-       bool "Force chunk erase check"
-       depends on YAFFS_FS
-       default n
-       help
-          Normally YAFFS only checks chunks before writing until an erased
-         chunk is found. This helps to detect any partially written
-         chunks that might have happened due to power loss.
-
-         Enabling this forces on the test that chunks are erased in flash
-         before writing to them. This takes more time but is potentially
-         a bit more secure.
-
-         Suggest setting Y during development and ironing out driver
-         issues etc. Suggest setting to N if you want faster writing.
-
-         If unsure, say Y.
-
-config YAFFS_SHORT_NAMES_IN_RAM
-       bool "Cache short names in RAM"
-       depends on YAFFS_FS
-       default y
-       help
-         If this config is set, then short names are stored with the
-         yaffs_Object.  This costs an extra 16 bytes of RAM per object,
-         but makes look-ups faster.
-
-         If unsure, say Y.
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/Makefile b/target/linux/generic-2.6/files/fs/yaffs2/Makefile
deleted file mode 100644 (file)
index 73f4658..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Makefile for the linux YAFFS filesystem routines.
-#
-
-obj-$(CONFIG_YAFFS_FS) += yaffs.o
-
-yaffs-y := yaffs_ecc.o yaffs_fs.o yaffs_guts.o yaffs_checkptrw.o
-yaffs-y += yaffs_packedtags2.o yaffs_nand.o yaffs_qsort.o
-yaffs-y += yaffs_tagscompat.o yaffs_tagsvalidity.o
-yaffs-y += yaffs_mtdif1.o yaffs_packedtags1.o
-yaffs-y += yaffs_mtdif.o yaffs_mtdif2.o
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/devextras.h b/target/linux/generic-2.6/files/fs/yaffs2/devextras.h
deleted file mode 100644 (file)
index fcf2690..0000000
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-/*
- * This file is just holds extra declarations used during development.
- * Most of these are from kernel includes placed here so we can use them in
- * applications.
- *
- */
-
-#ifndef __EXTRAS_H__
-#define __EXTRAS_H__
-
-#if defined WIN32
-#define __inline__ __inline
-#define new newHack
-#endif
-
-#if !(defined __KERNEL__) || (defined WIN32)
-
-/* User space defines */
-
-typedef unsigned char __u8;
-typedef unsigned short __u16;
-typedef unsigned __u32;
-
-/*
- * Simple doubly linked list implementation.
- *
- * Some of the internal functions ("__xxx") are useful when
- * manipulating whole lists rather than single entries, as
- * sometimes we already know the next/prev entries and we can
- * generate better code by using them directly rather than
- * using the generic single-entry routines.
- */
-
-#define prefetch(x) 1
-
-struct list_head {
-       struct list_head *next, *prev;
-};
-
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
-
-#define LIST_HEAD(name) \
-       struct list_head name = LIST_HEAD_INIT(name)
-
-#define INIT_LIST_HEAD(ptr) do { \
-       (ptr)->next = (ptr); (ptr)->prev = (ptr); \
-} while (0)
-
-/*
- * Insert a new entry between two known consecutive entries.
- *
- * This is only for internal list manipulation where we know
- * the prev/next entries already!
- */
-static __inline__ void __list_add(struct list_head *new,
-                                 struct list_head *prev,
-                                 struct list_head *next)
-{
-       next->prev = new;
-       new->next = next;
-       new->prev = prev;
-       prev->next = new;
-}
-
-/**
- * list_add - add a new entry
- * @new: new entry to be added
- * @head: list head to add it after
- *
- * Insert a new entry after the specified head.
- * This is good for implementing stacks.
- */
-static __inline__ void list_add(struct list_head *new, struct list_head *head)
-{
-       __list_add(new, head, head->next);
-}
-
-/**
- * list_add_tail - add a new entry
- * @new: new entry to be added
- * @head: list head to add it before
- *
- * Insert a new entry before the specified head.
- * This is useful for implementing queues.
- */
-static __inline__ void list_add_tail(struct list_head *new,
-                                    struct list_head *head)
-{
-       __list_add(new, head->prev, head);
-}
-
-/*
- * Delete a list entry by making the prev/next entries
- * point to each other.
- *
- * This is only for internal list manipulation where we know
- * the prev/next entries already!
- */
-static __inline__ void __list_del(struct list_head *prev,
-                                 struct list_head *next)
-{
-       next->prev = prev;
-       prev->next = next;
-}
-
-/**
- * list_del - deletes entry from list.
- * @entry: the element to delete from the list.
- * Note: list_empty on entry does not return true after this, the entry is
- * in an undefined state.
- */
-static __inline__ void list_del(struct list_head *entry)
-{
-       __list_del(entry->prev, entry->next);
-}
-
-/**
- * list_del_init - deletes entry from list and reinitialize it.
- * @entry: the element to delete from the list.
- */
-static __inline__ void list_del_init(struct list_head *entry)
-{
-       __list_del(entry->prev, entry->next);
-       INIT_LIST_HEAD(entry);
-}
-
-/**
- * list_empty - tests whether a list is empty
- * @head: the list to test.
- */
-static __inline__ int list_empty(struct list_head *head)
-{
-       return head->next == head;
-}
-
-/**
- * list_splice - join two lists
- * @list: the new list to add.
- * @head: the place to add it in the first list.
- */
-static __inline__ void list_splice(struct list_head *list,
-                                  struct list_head *head)
-{
-       struct list_head *first = list->next;
-
-       if (first != list) {
-               struct list_head *last = list->prev;
-               struct list_head *at = head->next;
-
-               first->prev = head;
-               head->next = first;
-
-               last->next = at;
-               at->prev = last;
-       }
-}
-
-/**
- * list_entry - get the struct for this entry
- * @ptr:       the &struct list_head pointer.
- * @type:      the type of the struct this is embedded in.
- * @member:    the name of the list_struct within the struct.
- */
-#define list_entry(ptr, type, member) \
-       ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
-
-/**
- * list_for_each       -       iterate over a list
- * @pos:       the &struct list_head to use as a loop counter.
- * @head:      the head for your list.
- */
-#define list_for_each(pos, head) \
-       for (pos = (head)->next, prefetch(pos->next); pos != (head); \
-               pos = pos->next, prefetch(pos->next))
-
-/**
- * list_for_each_safe  -       iterate over a list safe against removal
- *                              of list entry
- * @pos:       the &struct list_head to use as a loop counter.
- * @n:         another &struct list_head to use as temporary storage
- * @head:      the head for your list.
- */
-#define list_for_each_safe(pos, n, head) \
-       for (pos = (head)->next, n = pos->next; pos != (head); \
-               pos = n, n = pos->next)
-
-/*
- * File types
- */
-#define DT_UNKNOWN     0
-#define DT_FIFO                1
-#define DT_CHR         2
-#define DT_DIR         4
-#define DT_BLK         6
-#define DT_REG         8
-#define DT_LNK         10
-#define DT_SOCK                12
-#define DT_WHT         14
-
-#ifndef WIN32
-#include <sys/stat.h>
-#endif
-
-/*
- * Attribute flags.  These should be or-ed together to figure out what
- * has been changed!
- */
-#define ATTR_MODE      1
-#define ATTR_UID       2
-#define ATTR_GID       4
-#define ATTR_SIZE      8
-#define ATTR_ATIME     16
-#define ATTR_MTIME     32
-#define ATTR_CTIME     64
-#define ATTR_ATIME_SET 128
-#define ATTR_MTIME_SET 256
-#define ATTR_FORCE     512     /* Not a change, but a change it */
-#define ATTR_ATTR_FLAG 1024
-
-struct iattr {
-       unsigned int ia_valid;
-       unsigned ia_mode;
-       unsigned ia_uid;
-       unsigned ia_gid;
-       unsigned ia_size;
-       unsigned ia_atime;
-       unsigned ia_mtime;
-       unsigned ia_ctime;
-       unsigned int ia_attr_flags;
-};
-
-#define KERN_DEBUG
-
-#else
-
-#ifndef WIN32
-#include <linux/types.h>
-#include <linux/list.h>
-#include <linux/fs.h>
-#include <linux/stat.h>
-#endif
-
-#endif
-
-#if defined WIN32
-#undef new
-#endif
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/moduleconfig.h b/target/linux/generic-2.6/files/fs/yaffs2/moduleconfig.h
deleted file mode 100644 (file)
index 016391c..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Martin Fouts <Martin.Fouts@palmsource.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_CONFIG_H__
-#define __YAFFS_CONFIG_H__
-
-#ifdef YAFFS_OUT_OF_TREE
-
-/* DO NOT UNSET THESE THREE. YAFFS2 will not compile if you do. */
-#define CONFIG_YAFFS_FS
-#define CONFIG_YAFFS_YAFFS1
-#define CONFIG_YAFFS_YAFFS2
-
-/* These options are independent of each other.  Select those that matter. */
-
-/* Default: Not selected */
-/* Meaning: Yaffs does its own ECC, rather than using MTD ECC */
-//#define CONFIG_YAFFS_DOES_ECC
-
-/* Default: Not selected */
-/* Meaning: ECC byte order is 'wrong'.  Only meaningful if */
-/*          CONFIG_YAFFS_DOES_ECC is set */
-//#define CONFIG_YAFFS_ECC_WRONG_ORDER
-
-/* Default: Selected */
-/* Meaning: Disables testing whether chunks are erased before writing to them*/
-#define CONFIG_YAFFS_DISABLE_CHUNK_ERASED_CHECK
-
-/* Default: Selected */
-/* Meaning: Cache short names, taking more RAM, but faster look-ups */
-#define CONFIG_YAFFS_SHORT_NAMES_IN_RAM
-
-/* Default: 10 */
-/* Meaning: set the count of blocks to reserve for checkpointing */
-#define CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS 10
-
-/*
-Older-style on-NAND data format has a "pageStatus" byte to record
-chunk/page state.  This byte is zeroed when the page is discarded.
-Choose this option if you have existing on-NAND data in this format
-that you need to continue to support.  New data written also uses the
-older-style format.
-Note: Use of this option generally requires that MTD's oob layout be
-adjusted to use the older-style format.  See notes on tags formats and
-MTD versions.
-*/
-/* Default: Not selected */
-/* Meaning: Use older-style on-NAND data format with pageStatus byte */
-#define CONFIG_YAFFS_9BYTE_TAGS
-
-#endif /* YAFFS_OUT_OF_TREE */
-
-#endif /* __YAFFS_CONFIG_H__ */
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.c
deleted file mode 100644 (file)
index 933a33f..0000000
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-const char *yaffs_checkptrw_c_version =
-    "$Id: yaffs_checkptrw.c,v 1.14 2007-05-15 20:07:40 charles Exp $";
-
-
-#include "yaffs_checkptrw.h"
-
-
-static int yaffs_CheckpointSpaceOk(yaffs_Device *dev)
-{
-
-       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
-
-       T(YAFFS_TRACE_CHECKPOINT,
-               (TSTR("checkpt blocks available = %d" TENDSTR),
-               blocksAvailable));
-
-
-       return (blocksAvailable <= 0) ? 0 : 1;
-}
-
-
-static int yaffs_CheckpointErase(yaffs_Device *dev)
-{
-
-       int i;
-
-
-       if(!dev->eraseBlockInNAND)
-               return 0;
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checking blocks %d to %d"TENDSTR),
-               dev->internalStartBlock,dev->internalEndBlock));
-
-       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
-               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
-               if(bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT){
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("erasing checkpt block %d"TENDSTR),i));
-                       if(dev->eraseBlockInNAND(dev,i- dev->blockOffset /* realign */)){
-                               bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
-                               dev->nErasedBlocks++;
-                               dev->nFreeChunks += dev->nChunksPerBlock;
-                       }
-                       else {
-                               dev->markNANDBlockBad(dev,i);
-                               bi->blockState = YAFFS_BLOCK_STATE_DEAD;
-                       }
-               }
-       }
-
-       dev->blocksInCheckpoint = 0;
-
-       return 1;
-}
-
-
-static void yaffs_CheckpointFindNextErasedBlock(yaffs_Device *dev)
-{
-       int  i;
-       int blocksAvailable = dev->nErasedBlocks - dev->nReservedBlocks;
-       T(YAFFS_TRACE_CHECKPOINT,
-               (TSTR("allocating checkpt block: erased %d reserved %d avail %d next %d "TENDSTR),
-               dev->nErasedBlocks,dev->nReservedBlocks,blocksAvailable,dev->checkpointNextBlock));
-
-       if(dev->checkpointNextBlock >= 0 &&
-          dev->checkpointNextBlock <= dev->internalEndBlock &&
-          blocksAvailable > 0){
-
-               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
-                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
-                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY){
-                               dev->checkpointNextBlock = i + 1;
-                               dev->checkpointCurrentBlock = i;
-                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("allocating checkpt block %d"TENDSTR),i));
-                               return;
-                       }
-               }
-       }
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("out of checkpt blocks"TENDSTR)));
-
-       dev->checkpointNextBlock = -1;
-       dev->checkpointCurrentBlock = -1;
-}
-
-static void yaffs_CheckpointFindNextCheckpointBlock(yaffs_Device *dev)
-{
-       int  i;
-       yaffs_ExtendedTags tags;
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: start:  blocks %d next %d" TENDSTR),
-               dev->blocksInCheckpoint, dev->checkpointNextBlock));
-
-       if(dev->blocksInCheckpoint < dev->checkpointMaxBlocks)
-               for(i = dev->checkpointNextBlock; i <= dev->internalEndBlock; i++){
-                       int chunk = i * dev->nChunksPerBlock;
-                       int realignedChunk = chunk - dev->chunkOffset;
-
-                       dev->readChunkWithTagsFromNAND(dev,realignedChunk,NULL,&tags);
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("find next checkpt block: search: block %d oid %d seq %d eccr %d" TENDSTR),
-                               i, tags.objectId,tags.sequenceNumber,tags.eccResult));
-
-                       if(tags.sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA){
-                               /* Right kind of block */
-                               dev->checkpointNextBlock = tags.objectId;
-                               dev->checkpointCurrentBlock = i;
-                               dev->checkpointBlockList[dev->blocksInCheckpoint] = i;
-                               dev->blocksInCheckpoint++;
-                               T(YAFFS_TRACE_CHECKPOINT,(TSTR("found checkpt block %d"TENDSTR),i));
-                               return;
-                       }
-               }
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("found no more checkpt blocks"TENDSTR)));
-
-       dev->checkpointNextBlock = -1;
-       dev->checkpointCurrentBlock = -1;
-}
-
-
-int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting)
-{
-
-       /* Got the functions we need? */
-       if (!dev->writeChunkWithTagsToNAND ||
-           !dev->readChunkWithTagsFromNAND ||
-           !dev->eraseBlockInNAND ||
-           !dev->markNANDBlockBad)
-               return 0;
-
-       if(forWriting && !yaffs_CheckpointSpaceOk(dev))
-               return 0;
-
-       if(!dev->checkpointBuffer)
-               dev->checkpointBuffer = YMALLOC_DMA(dev->nDataBytesPerChunk);
-       if(!dev->checkpointBuffer)
-               return 0;
-
-
-       dev->checkpointPageSequence = 0;
-
-       dev->checkpointOpenForWrite = forWriting;
-
-       dev->checkpointByteCount = 0;
-       dev->checkpointSum = 0;
-       dev->checkpointXor = 0;
-       dev->checkpointCurrentBlock = -1;
-       dev->checkpointCurrentChunk = -1;
-       dev->checkpointNextBlock = dev->internalStartBlock;
-
-       /* Erase all the blocks in the checkpoint area */
-       if(forWriting){
-               memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
-               dev->checkpointByteOffset = 0;
-               return yaffs_CheckpointErase(dev);
-
-
-       } else {
-               int i;
-               /* Set to a value that will kick off a read */
-               dev->checkpointByteOffset = dev->nDataBytesPerChunk;
-               /* A checkpoint block list of 1 checkpoint block per 16 block is (hopefully)
-                * going to be way more than we need */
-               dev->blocksInCheckpoint = 0;
-               dev->checkpointMaxBlocks = (dev->internalEndBlock - dev->internalStartBlock)/16 + 2;
-               dev->checkpointBlockList = YMALLOC(sizeof(int) * dev->checkpointMaxBlocks);
-               for(i = 0; i < dev->checkpointMaxBlocks; i++)
-                       dev->checkpointBlockList[i] = -1;
-       }
-
-       return 1;
-}
-
-int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum)
-{
-       __u32 compositeSum;
-       compositeSum =  (dev->checkpointSum << 8) | (dev->checkpointXor & 0xFF);
-       *sum = compositeSum;
-       return 1;
-}
-
-static int yaffs_CheckpointFlushBuffer(yaffs_Device *dev)
-{
-
-       int chunk;
-       int realignedChunk;
-
-       yaffs_ExtendedTags tags;
-
-       if(dev->checkpointCurrentBlock < 0){
-               yaffs_CheckpointFindNextErasedBlock(dev);
-               dev->checkpointCurrentChunk = 0;
-       }
-
-       if(dev->checkpointCurrentBlock < 0)
-               return 0;
-
-       tags.chunkDeleted = 0;
-       tags.objectId = dev->checkpointNextBlock; /* Hint to next place to look */
-       tags.chunkId = dev->checkpointPageSequence + 1;
-       tags.sequenceNumber =  YAFFS_SEQUENCE_CHECKPOINT_DATA;
-       tags.byteCount = dev->nDataBytesPerChunk;
-       if(dev->checkpointCurrentChunk == 0){
-               /* First chunk we write for the block? Set block state to
-                  checkpoint */
-               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointCurrentBlock);
-               bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
-               dev->blocksInCheckpoint++;
-       }
-
-       chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock + dev->checkpointCurrentChunk;
-
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint wite buffer nand %d(%d:%d) objid %d chId %d" TENDSTR),
-               chunk, dev->checkpointCurrentBlock, dev->checkpointCurrentChunk,tags.objectId,tags.chunkId));
-
-       realignedChunk = chunk - dev->chunkOffset;
-
-       dev->writeChunkWithTagsToNAND(dev,realignedChunk,dev->checkpointBuffer,&tags);
-       dev->checkpointByteOffset = 0;
-       dev->checkpointPageSequence++;
-       dev->checkpointCurrentChunk++;
-       if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock){
-               dev->checkpointCurrentChunk = 0;
-               dev->checkpointCurrentBlock = -1;
-       }
-       memset(dev->checkpointBuffer,0,dev->nDataBytesPerChunk);
-
-       return 1;
-}
-
-
-int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes)
-{
-       int i=0;
-       int ok = 1;
-
-
-       __u8 * dataBytes = (__u8 *)data;
-
-
-
-       if(!dev->checkpointBuffer)
-               return 0;
-
-       if(!dev->checkpointOpenForWrite)
-               return -1;
-
-       while(i < nBytes && ok) {
-
-
-
-               dev->checkpointBuffer[dev->checkpointByteOffset] = *dataBytes ;
-               dev->checkpointSum += *dataBytes;
-               dev->checkpointXor ^= *dataBytes;
-
-               dev->checkpointByteOffset++;
-               i++;
-               dataBytes++;
-               dev->checkpointByteCount++;
-
-
-               if(dev->checkpointByteOffset < 0 ||
-                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk)
-                       ok = yaffs_CheckpointFlushBuffer(dev);
-
-       }
-
-       return  i;
-}
-
-int yaffs_CheckpointRead(yaffs_Device *dev, void *data, int nBytes)
-{
-       int i=0;
-       int ok = 1;
-       yaffs_ExtendedTags tags;
-
-
-       int chunk;
-       int realignedChunk;
-
-       __u8 *dataBytes = (__u8 *)data;
-
-       if(!dev->checkpointBuffer)
-               return 0;
-
-       if(dev->checkpointOpenForWrite)
-               return -1;
-
-       while(i < nBytes && ok) {
-
-
-               if(dev->checkpointByteOffset < 0 ||
-                  dev->checkpointByteOffset >= dev->nDataBytesPerChunk) {
-
-                       if(dev->checkpointCurrentBlock < 0){
-                               yaffs_CheckpointFindNextCheckpointBlock(dev);
-                               dev->checkpointCurrentChunk = 0;
-                       }
-
-                       if(dev->checkpointCurrentBlock < 0)
-                               ok = 0;
-                       else {
-
-                               chunk = dev->checkpointCurrentBlock * dev->nChunksPerBlock +
-                                         dev->checkpointCurrentChunk;
-
-                               realignedChunk = chunk - dev->chunkOffset;
-
-                               /* read in the next chunk */
-                               /* printf("read checkpoint page %d\n",dev->checkpointPage); */
-                               dev->readChunkWithTagsFromNAND(dev, realignedChunk,
-                                                              dev->checkpointBuffer,
-                                                             &tags);
-
-                               if(tags.chunkId != (dev->checkpointPageSequence + 1) ||
-                                  tags.sequenceNumber != YAFFS_SEQUENCE_CHECKPOINT_DATA)
-                                  ok = 0;
-
-                               dev->checkpointByteOffset = 0;
-                               dev->checkpointPageSequence++;
-                               dev->checkpointCurrentChunk++;
-
-                               if(dev->checkpointCurrentChunk >= dev->nChunksPerBlock)
-                                       dev->checkpointCurrentBlock = -1;
-                       }
-               }
-
-               if(ok){
-                       *dataBytes = dev->checkpointBuffer[dev->checkpointByteOffset];
-                       dev->checkpointSum += *dataBytes;
-                       dev->checkpointXor ^= *dataBytes;
-                       dev->checkpointByteOffset++;
-                       i++;
-                       dataBytes++;
-                       dev->checkpointByteCount++;
-               }
-       }
-
-       return  i;
-}
-
-int yaffs_CheckpointClose(yaffs_Device *dev)
-{
-
-       if(dev->checkpointOpenForWrite){
-               if(dev->checkpointByteOffset != 0)
-                       yaffs_CheckpointFlushBuffer(dev);
-       } else {
-               int i;
-               for(i = 0; i < dev->blocksInCheckpoint && dev->checkpointBlockList[i] >= 0; i++){
-                       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,dev->checkpointBlockList[i]);
-                       if(bi->blockState == YAFFS_BLOCK_STATE_EMPTY)
-                               bi->blockState = YAFFS_BLOCK_STATE_CHECKPOINT;
-                       else {
-                               // Todo this looks odd...
-                       }
-               }
-               YFREE(dev->checkpointBlockList);
-               dev->checkpointBlockList = NULL;
-       }
-
-       dev->nFreeChunks -= dev->blocksInCheckpoint * dev->nChunksPerBlock;
-       dev->nErasedBlocks -= dev->blocksInCheckpoint;
-
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint byte count %d" TENDSTR),
-                       dev->checkpointByteCount));
-
-       if(dev->checkpointBuffer){
-               /* free the buffer */
-               YFREE(dev->checkpointBuffer);
-               dev->checkpointBuffer = NULL;
-               return 1;
-       }
-       else
-               return 0;
-
-}
-
-int yaffs_CheckpointInvalidateStream(yaffs_Device *dev)
-{
-       /* Erase the first checksum block */
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("checkpoint invalidate"TENDSTR)));
-
-       if(!yaffs_CheckpointSpaceOk(dev))
-               return 0;
-
-       return yaffs_CheckpointErase(dev);
-}
-
-
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_checkptrw.h
deleted file mode 100644 (file)
index d3ff174..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_CHECKPTRW_H__
-#define __YAFFS_CHECKPTRW_H__
-
-#include "yaffs_guts.h"
-
-int yaffs_CheckpointOpen(yaffs_Device *dev, int forWriting);
-
-int yaffs_CheckpointWrite(yaffs_Device *dev,const void *data, int nBytes);
-
-int yaffs_CheckpointRead(yaffs_Device *dev,void *data, int nBytes);
-
-int yaffs_GetCheckpointSum(yaffs_Device *dev, __u32 *sum);
-
-int yaffs_CheckpointClose(yaffs_Device *dev);
-
-int yaffs_CheckpointInvalidateStream(yaffs_Device *dev);
-
-
-#endif
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.c
deleted file mode 100644 (file)
index e286039..0000000
+++ /dev/null
@@ -1,331 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/*
- * This code implements the ECC algorithm used in SmartMedia.
- *
- * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
- * The two unused bit are set to 1.
- * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
- * blocks are used on a 512-byte NAND page.
- *
- */
-
-/* Table generated by gen-ecc.c
- * Using a table means we do not have to calculate p1..p4 and p1'..p4'
- * for each byte of data. These are instead provided in a table in bits7..2.
- * Bit 0 of each entry indicates whether the entry has an odd or even parity, and therefore
- * this bytes influence on the line parity.
- */
-
-const char *yaffs_ecc_c_version =
-    "$Id: yaffs_ecc.c,v 1.9 2007-02-14 01:09:06 wookey Exp $";
-
-#include "yportenv.h"
-
-#include "yaffs_ecc.h"
-
-static const unsigned char column_parity_table[] = {
-       0x00, 0x55, 0x59, 0x0c, 0x65, 0x30, 0x3c, 0x69,
-       0x69, 0x3c, 0x30, 0x65, 0x0c, 0x59, 0x55, 0x00,
-       0x95, 0xc0, 0xcc, 0x99, 0xf0, 0xa5, 0xa9, 0xfc,
-       0xfc, 0xa9, 0xa5, 0xf0, 0x99, 0xcc, 0xc0, 0x95,
-       0x99, 0xcc, 0xc0, 0x95, 0xfc, 0xa9, 0xa5, 0xf0,
-       0xf0, 0xa5, 0xa9, 0xfc, 0x95, 0xc0, 0xcc, 0x99,
-       0x0c, 0x59, 0x55, 0x00, 0x69, 0x3c, 0x30, 0x65,
-       0x65, 0x30, 0x3c, 0x69, 0x00, 0x55, 0x59, 0x0c,
-       0xa5, 0xf0, 0xfc, 0xa9, 0xc0, 0x95, 0x99, 0xcc,
-       0xcc, 0x99, 0x95, 0xc0, 0xa9, 0xfc, 0xf0, 0xa5,
-       0x30, 0x65, 0x69, 0x3c, 0x55, 0x00, 0x0c, 0x59,
-       0x59, 0x0c, 0x00, 0x55, 0x3c, 0x69, 0x65, 0x30,
-       0x3c, 0x69, 0x65, 0x30, 0x59, 0x0c, 0x00, 0x55,
-       0x55, 0x00, 0x0c, 0x59, 0x30, 0x65, 0x69, 0x3c,
-       0xa9, 0xfc, 0xf0, 0xa5, 0xcc, 0x99, 0x95, 0xc0,
-       0xc0, 0x95, 0x99, 0xcc, 0xa5, 0xf0, 0xfc, 0xa9,
-       0xa9, 0xfc, 0xf0, 0xa5, 0xcc, 0x99, 0x95, 0xc0,
-       0xc0, 0x95, 0x99, 0xcc, 0xa5, 0xf0, 0xfc, 0xa9,
-       0x3c, 0x69, 0x65, 0x30, 0x59, 0x0c, 0x00, 0x55,
-       0x55, 0x00, 0x0c, 0x59, 0x30, 0x65, 0x69, 0x3c,
-       0x30, 0x65, 0x69, 0x3c, 0x55, 0x00, 0x0c, 0x59,
-       0x59, 0x0c, 0x00, 0x55, 0x3c, 0x69, 0x65, 0x30,
-       0xa5, 0xf0, 0xfc, 0xa9, 0xc0, 0x95, 0x99, 0xcc,
-       0xcc, 0x99, 0x95, 0xc0, 0xa9, 0xfc, 0xf0, 0xa5,
-       0x0c, 0x59, 0x55, 0x00, 0x69, 0x3c, 0x30, 0x65,
-       0x65, 0x30, 0x3c, 0x69, 0x00, 0x55, 0x59, 0x0c,
-       0x99, 0xcc, 0xc0, 0x95, 0xfc, 0xa9, 0xa5, 0xf0,
-       0xf0, 0xa5, 0xa9, 0xfc, 0x95, 0xc0, 0xcc, 0x99,
-       0x95, 0xc0, 0xcc, 0x99, 0xf0, 0xa5, 0xa9, 0xfc,
-       0xfc, 0xa9, 0xa5, 0xf0, 0x99, 0xcc, 0xc0, 0x95,
-       0x00, 0x55, 0x59, 0x0c, 0x65, 0x30, 0x3c, 0x69,
-       0x69, 0x3c, 0x30, 0x65, 0x0c, 0x59, 0x55, 0x00,
-};
-
-/* Count the bits in an unsigned char or a U32 */
-
-static int yaffs_CountBits(unsigned char x)
-{
-       int r = 0;
-       while (x) {
-               if (x & 1)
-                       r++;
-               x >>= 1;
-       }
-       return r;
-}
-
-static int yaffs_CountBits32(unsigned x)
-{
-       int r = 0;
-       while (x) {
-               if (x & 1)
-                       r++;
-               x >>= 1;
-       }
-       return r;
-}
-
-/* Calculate the ECC for a 256-byte block of data */
-void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc)
-{
-       unsigned int i;
-
-       unsigned char col_parity = 0;
-       unsigned char line_parity = 0;
-       unsigned char line_parity_prime = 0;
-       unsigned char t;
-       unsigned char b;
-
-       for (i = 0; i < 256; i++) {
-               b = column_parity_table[*data++];
-               col_parity ^= b;
-
-               if (b & 0x01)   // odd number of bits in the byte
-               {
-                       line_parity ^= i;
-                       line_parity_prime ^= ~i;
-               }
-
-       }
-
-       ecc[2] = (~col_parity) | 0x03;
-
-       t = 0;
-       if (line_parity & 0x80)
-               t |= 0x80;
-       if (line_parity_prime & 0x80)
-               t |= 0x40;
-       if (line_parity & 0x40)
-               t |= 0x20;
-       if (line_parity_prime & 0x40)
-               t |= 0x10;
-       if (line_parity & 0x20)
-               t |= 0x08;
-       if (line_parity_prime & 0x20)
-               t |= 0x04;
-       if (line_parity & 0x10)
-               t |= 0x02;
-       if (line_parity_prime & 0x10)
-               t |= 0x01;
-       ecc[1] = ~t;
-
-       t = 0;
-       if (line_parity & 0x08)
-               t |= 0x80;
-       if (line_parity_prime & 0x08)
-               t |= 0x40;
-       if (line_parity & 0x04)
-               t |= 0x20;
-       if (line_parity_prime & 0x04)
-               t |= 0x10;
-       if (line_parity & 0x02)
-               t |= 0x08;
-       if (line_parity_prime & 0x02)
-               t |= 0x04;
-       if (line_parity & 0x01)
-               t |= 0x02;
-       if (line_parity_prime & 0x01)
-               t |= 0x01;
-       ecc[0] = ~t;
-
-#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
-       // Swap the bytes into the wrong order
-       t = ecc[0];
-       ecc[0] = ecc[1];
-       ecc[1] = t;
-#endif
-}
-
-
-/* Correct the ECC on a 256 byte block of data */
-
-int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
-                    const unsigned char *test_ecc)
-{
-       unsigned char d0, d1, d2;       /* deltas */
-
-       d0 = read_ecc[0] ^ test_ecc[0];
-       d1 = read_ecc[1] ^ test_ecc[1];
-       d2 = read_ecc[2] ^ test_ecc[2];
-
-       if ((d0 | d1 | d2) == 0)
-               return 0; /* no error */
-
-       if (((d0 ^ (d0 >> 1)) & 0x55) == 0x55 &&
-           ((d1 ^ (d1 >> 1)) & 0x55) == 0x55 &&
-           ((d2 ^ (d2 >> 1)) & 0x54) == 0x54) {
-               /* Single bit (recoverable) error in data */
-
-               unsigned byte;
-               unsigned bit;
-
-#ifdef CONFIG_YAFFS_ECC_WRONG_ORDER
-               // swap the bytes to correct for the wrong order
-               unsigned char t;
-
-               t = d0;
-               d0 = d1;
-               d1 = t;
-#endif
-
-               bit = byte = 0;
-
-               if (d1 & 0x80)
-                       byte |= 0x80;
-               if (d1 & 0x20)
-                       byte |= 0x40;
-               if (d1 & 0x08)
-                       byte |= 0x20;
-               if (d1 & 0x02)
-                       byte |= 0x10;
-               if (d0 & 0x80)
-                       byte |= 0x08;
-               if (d0 & 0x20)
-                       byte |= 0x04;
-               if (d0 & 0x08)
-                       byte |= 0x02;
-               if (d0 & 0x02)
-                       byte |= 0x01;
-
-               if (d2 & 0x80)
-                       bit |= 0x04;
-               if (d2 & 0x20)
-                       bit |= 0x02;
-               if (d2 & 0x08)
-                       bit |= 0x01;
-
-               data[byte] ^= (1 << bit);
-
-               return 1; /* Corrected the error */
-       }
-
-       if ((yaffs_CountBits(d0) +
-            yaffs_CountBits(d1) +
-            yaffs_CountBits(d2)) ==  1) {
-               /* Reccoverable error in ecc */
-
-               read_ecc[0] = test_ecc[0];
-               read_ecc[1] = test_ecc[1];
-               read_ecc[2] = test_ecc[2];
-
-               return 1; /* Corrected the error */
-       }
-
-       /* Unrecoverable error */
-
-       return -1;
-
-}
-
-
-/*
- * ECCxxxOther does ECC calcs on arbitrary n bytes of data
- */
-void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
-                            yaffs_ECCOther * eccOther)
-{
-       unsigned int i;
-
-       unsigned char col_parity = 0;
-       unsigned line_parity = 0;
-       unsigned line_parity_prime = 0;
-       unsigned char b;
-
-       for (i = 0; i < nBytes; i++) {
-               b = column_parity_table[*data++];
-               col_parity ^= b;
-
-               if (b & 0x01)    {
-                       /* odd number of bits in the byte */
-                       line_parity ^= i;
-                       line_parity_prime ^= ~i;
-               }
-
-       }
-
-       eccOther->colParity = (col_parity >> 2) & 0x3f;
-       eccOther->lineParity = line_parity;
-       eccOther->lineParityPrime = line_parity_prime;
-}
-
-int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
-                         yaffs_ECCOther * read_ecc,
-                         const yaffs_ECCOther * test_ecc)
-{
-       unsigned char cDelta;   /* column parity delta */
-       unsigned lDelta;        /* line parity delta */
-       unsigned lDeltaPrime;   /* line parity delta */
-       unsigned bit;
-
-       cDelta = read_ecc->colParity ^ test_ecc->colParity;
-       lDelta = read_ecc->lineParity ^ test_ecc->lineParity;
-       lDeltaPrime = read_ecc->lineParityPrime ^ test_ecc->lineParityPrime;
-
-       if ((cDelta | lDelta | lDeltaPrime) == 0)
-               return 0; /* no error */
-
-       if (lDelta == ~lDeltaPrime &&
-           (((cDelta ^ (cDelta >> 1)) & 0x15) == 0x15))
-       {
-               /* Single bit (recoverable) error in data */
-
-               bit = 0;
-
-               if (cDelta & 0x20)
-                       bit |= 0x04;
-               if (cDelta & 0x08)
-                       bit |= 0x02;
-               if (cDelta & 0x02)
-                       bit |= 0x01;
-
-               if(lDelta >= nBytes)
-                       return -1;
-
-               data[lDelta] ^= (1 << bit);
-
-               return 1; /* corrected */
-       }
-
-       if ((yaffs_CountBits32(lDelta) + yaffs_CountBits32(lDeltaPrime) +
-            yaffs_CountBits(cDelta)) == 1) {
-               /* Reccoverable error in ecc */
-
-               *read_ecc = *test_ecc;
-               return 1; /* corrected */
-       }
-
-       /* Unrecoverable error */
-
-       return -1;
-
-}
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_ecc.h
deleted file mode 100644 (file)
index 79bc3d1..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
- /*
-  * This code implements the ECC algorithm used in SmartMedia.
-  *
-  * The ECC comprises 22 bits of parity information and is stuffed into 3 bytes.
-  * The two unused bit are set to 1.
-  * The ECC can correct single bit errors in a 256-byte page of data. Thus, two such ECC
-  * blocks are used on a 512-byte NAND page.
-  *
-  */
-
-#ifndef __YAFFS_ECC_H__
-#define __YAFFS_ECC_H__
-
-typedef struct {
-       unsigned char colParity;
-       unsigned lineParity;
-       unsigned lineParityPrime;
-} yaffs_ECCOther;
-
-void yaffs_ECCCalculate(const unsigned char *data, unsigned char *ecc);
-int yaffs_ECCCorrect(unsigned char *data, unsigned char *read_ecc,
-                    const unsigned char *test_ecc);
-
-void yaffs_ECCCalculateOther(const unsigned char *data, unsigned nBytes,
-                            yaffs_ECCOther * ecc);
-int yaffs_ECCCorrectOther(unsigned char *data, unsigned nBytes,
-                         yaffs_ECCOther * read_ecc,
-                         const yaffs_ECCOther * test_ecc);
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_fs.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_fs.c
deleted file mode 100644 (file)
index 67001b1..0000000
+++ /dev/null
@@ -1,2299 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- * Acknowledgements:
- * Luc van OostenRyck for numerous patches.
- * Nick Bane for numerous patches.
- * Nick Bane for 2.5/2.6 integration.
- * Andras Toth for mknod rdev issue.
- * Michael Fischer for finding the problem with inode inconsistency.
- * Some code bodily lifted from JFFS
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/*
- *
- * This is the file system front-end to YAFFS that hooks it up to
- * the VFS.
- *
- * Special notes:
- * >> 2.4: sb->u.generic_sbp points to the yaffs_Device associated with
- *         this superblock
- * >> 2.6: sb->s_fs_info  points to the yaffs_Device associated with this
- *         superblock
- * >> inode->u.generic_ip points to the associated yaffs_Object.
- */
-
-const char *yaffs_fs_c_version =
-    "$Id: yaffs_fs.c,v 1.63 2007-09-19 20:35:40 imcd Exp $";
-extern const char *yaffs_guts_c_version;
-
-#include <linux/version.h>
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
-#include <linux/config.h>
-#endif
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/list.h>
-#include <linux/fs.h>
-#include <linux/proc_fs.h>
-#include <linux/smp_lock.h>
-#include <linux/pagemap.h>
-#include <linux/mtd/mtd.h>
-#include <linux/interrupt.h>
-#include <linux/string.h>
-#include <linux/ctype.h>
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-
-#include <linux/statfs.h>      /* Added NCB 15-8-2003 */
-#include <asm/statfs.h>
-#define UnlockPage(p) unlock_page(p)
-#define Page_Uptodate(page)    test_bit(PG_uptodate, &(page)->flags)
-
-/* FIXME: use sb->s_id instead ? */
-#define yaffs_devname(sb, buf) bdevname(sb->s_bdev, buf)
-
-#else
-
-#include <linux/locks.h>
-#define        BDEVNAME_SIZE           0
-#define        yaffs_devname(sb, buf)  kdevname(sb->s_dev)
-
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
-/* added NCB 26/5/2006 for 2.4.25-vrs2-tcl1 kernel */
-#define __user
-#endif
-
-#endif
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-#define WRITE_SIZE_STR "writesize"
-#define WRITE_SIZE(mtd) (mtd)->writesize
-#else
-#define WRITE_SIZE_STR "oobblock"
-#define WRITE_SIZE(mtd) (mtd)->oobblock
-#endif
-
-#include <asm/uaccess.h>
-
-#include "yportenv.h"
-#include "yaffs_guts.h"
-
-#include <linux/mtd/mtd.h>
-#include "yaffs_mtdif.h"
-#include "yaffs_mtdif1.h"
-#include "yaffs_mtdif2.h"
-
-unsigned int yaffs_traceMask = YAFFS_TRACE_BAD_BLOCKS;
-unsigned int yaffs_wr_attempts = YAFFS_WR_ATTEMPTS;
-
-/* Module Parameters */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-module_param(yaffs_traceMask,uint,0644);
-module_param(yaffs_wr_attempts,uint,0644);
-#else
-MODULE_PARM(yaffs_traceMask,"i");
-MODULE_PARM(yaffs_wr_attempts,"i");
-#endif
-
-/*#define T(x) printk x */
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
-#define yaffs_InodeToObjectLV(iptr) (iptr)->i_private
-#else
-#define yaffs_InodeToObjectLV(iptr) (iptr)->u.generic_ip
-#endif
-
-#define yaffs_InodeToObject(iptr) ((yaffs_Object *)(yaffs_InodeToObjectLV(iptr)))
-#define yaffs_DentryToObject(dptr) yaffs_InodeToObject((dptr)->d_inode)
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-#define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->s_fs_info)
-#else
-#define yaffs_SuperToDevice(sb)        ((yaffs_Device *)sb->u.generic_sbp)
-#endif
-
-static void yaffs_put_super(struct super_block *sb);
-
-static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
-                               loff_t * pos);
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_file_flush(struct file *file, fl_owner_t id);
-#else
-static int yaffs_file_flush(struct file *file);
-#endif
-
-static int yaffs_sync_object(struct file *file, struct dentry *dentry,
-                            int datasync);
-
-static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir);
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
-                       struct nameidata *n);
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *n);
-#else
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode);
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry);
-#endif
-static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
-                     struct dentry *dentry);
-static int yaffs_unlink(struct inode *dir, struct dentry *dentry);
-static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
-                        const char *symname);
-static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-                      dev_t dev);
-#else
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-                      int dev);
-#endif
-static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                       struct inode *new_dir, struct dentry *new_dentry);
-static int yaffs_setattr(struct dentry *dentry, struct iattr *attr);
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_sync_fs(struct super_block *sb, int wait);
-static void yaffs_write_super(struct super_block *sb);
-#else
-static int yaffs_sync_fs(struct super_block *sb);
-static int yaffs_write_super(struct super_block *sb);
-#endif
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf);
-#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf);
-#else
-static int yaffs_statfs(struct super_block *sb, struct statfs *buf);
-#endif
-static void yaffs_read_inode(struct inode *inode);
-
-static void yaffs_put_inode(struct inode *inode);
-static void yaffs_delete_inode(struct inode *);
-static void yaffs_clear_inode(struct inode *);
-
-static int yaffs_readpage(struct file *file, struct page *page);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_writepage(struct page *page, struct writeback_control *wbc);
-#else
-static int yaffs_writepage(struct page *page);
-#endif
-static int yaffs_prepare_write(struct file *f, struct page *pg,
-                              unsigned offset, unsigned to);
-static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
-                             unsigned to);
-
-static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
-                         int buflen);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
-static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
-#else
-static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd);
-#endif
-
-static struct address_space_operations yaffs_file_address_operations = {
-       .readpage = yaffs_readpage,
-       .writepage = yaffs_writepage,
-       .prepare_write = yaffs_prepare_write,
-       .commit_write = yaffs_commit_write,
-};
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,22))
-static struct file_operations yaffs_file_operations = {
-       .read = do_sync_read,
-       .write = do_sync_write,
-       .aio_read = generic_file_aio_read,
-       .aio_write = generic_file_aio_write,
-       .mmap = generic_file_mmap,
-       .flush = yaffs_file_flush,
-       .fsync = yaffs_sync_object,
-       .splice_read = generic_file_splice_read,
-       .splice_write = generic_file_splice_write,
-};
-
-#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
-
-static struct file_operations yaffs_file_operations = {
-       .read = do_sync_read,
-       .write = do_sync_write,
-       .aio_read = generic_file_aio_read,
-       .aio_write = generic_file_aio_write,
-       .mmap = generic_file_mmap,
-       .flush = yaffs_file_flush,
-       .fsync = yaffs_sync_object,
-       .sendfile = generic_file_sendfile,
-};
-
-#else
-
-static struct file_operations yaffs_file_operations = {
-       .read = generic_file_read,
-       .write = generic_file_write,
-       .mmap = generic_file_mmap,
-       .flush = yaffs_file_flush,
-       .fsync = yaffs_sync_object,
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-       .sendfile = generic_file_sendfile,
-#endif
-};
-#endif
-
-static struct inode_operations yaffs_file_inode_operations = {
-       .setattr = yaffs_setattr,
-};
-
-static struct inode_operations yaffs_symlink_inode_operations = {
-       .readlink = yaffs_readlink,
-       .follow_link = yaffs_follow_link,
-       .setattr = yaffs_setattr,
-};
-
-static struct inode_operations yaffs_dir_inode_operations = {
-       .create = yaffs_create,
-       .lookup = yaffs_lookup,
-       .link = yaffs_link,
-       .unlink = yaffs_unlink,
-       .symlink = yaffs_symlink,
-       .mkdir = yaffs_mkdir,
-       .rmdir = yaffs_unlink,
-       .mknod = yaffs_mknod,
-       .rename = yaffs_rename,
-       .setattr = yaffs_setattr,
-};
-
-static struct file_operations yaffs_dir_operations = {
-       .read = generic_read_dir,
-       .readdir = yaffs_readdir,
-       .fsync = yaffs_sync_object,
-};
-
-static struct super_operations yaffs_super_ops = {
-       .statfs = yaffs_statfs,
-       .read_inode = yaffs_read_inode,
-       .put_inode = yaffs_put_inode,
-       .put_super = yaffs_put_super,
-       .delete_inode = yaffs_delete_inode,
-       .clear_inode = yaffs_clear_inode,
-       .sync_fs = yaffs_sync_fs,
-       .write_super = yaffs_write_super,
-};
-
-static void yaffs_GrossLock(yaffs_Device * dev)
-{
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs locking\n"));
-
-       down(&dev->grossLock);
-}
-
-static void yaffs_GrossUnlock(yaffs_Device * dev)
-{
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs unlocking\n"));
-       up(&dev->grossLock);
-
-}
-
-static int yaffs_readlink(struct dentry *dentry, char __user * buffer,
-                         int buflen)
-{
-       unsigned char *alias;
-       int ret;
-
-       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
-
-       yaffs_GrossLock(dev);
-
-       alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
-
-       yaffs_GrossUnlock(dev);
-
-       if (!alias)
-               return -ENOMEM;
-
-       ret = vfs_readlink(dentry, buffer, buflen, alias);
-       kfree(alias);
-       return ret;
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
-static void *yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
-#else
-static int yaffs_follow_link(struct dentry *dentry, struct nameidata *nd)
-#endif
-{
-       unsigned char *alias;
-       int ret;
-       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
-
-       yaffs_GrossLock(dev);
-
-       alias = yaffs_GetSymlinkAlias(yaffs_DentryToObject(dentry));
-
-       yaffs_GrossUnlock(dev);
-
-       if (!alias)
-        {
-               ret = -ENOMEM;
-               goto out;
-        }
-
-       ret = vfs_follow_link(nd, alias);
-       kfree(alias);
-out:
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
-       return ERR_PTR (ret);
-#else
-       return ret;
-#endif
-}
-
-struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                             yaffs_Object * obj);
-
-/*
- * Lookup is used to find objects in the fs
- */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry,
-                                  struct nameidata *n)
-#else
-static struct dentry *yaffs_lookup(struct inode *dir, struct dentry *dentry)
-#endif
-{
-       yaffs_Object *obj;
-       struct inode *inode = NULL;     /* NCB 2.5/2.6 needs NULL here */
-
-       yaffs_Device *dev = yaffs_InodeToObject(dir)->myDev;
-
-       yaffs_GrossLock(dev);
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_lookup for %d:%s\n",
-          yaffs_InodeToObject(dir)->objectId, dentry->d_name.name));
-
-       obj =
-           yaffs_FindObjectByName(yaffs_InodeToObject(dir),
-                                  dentry->d_name.name);
-
-       obj = yaffs_GetEquivalentObject(obj);   /* in case it was a hardlink */
-
-       /* Can't hold gross lock when calling yaffs_get_inode() */
-       yaffs_GrossUnlock(dev);
-
-       if (obj) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_lookup found %d\n", obj->objectId));
-
-               inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-
-               if (inode) {
-                       T(YAFFS_TRACE_OS,
-                         (KERN_DEBUG "yaffs_loookup dentry \n"));
-/* #if 0 asserted by NCB for 2.5/6 compatability - falls through to
- * d_add even if NULL inode */
-#if 0
-                       /*dget(dentry); // try to solve directory bug */
-                       d_add(dentry, inode);
-
-                       /* return dentry; */
-                       return NULL;
-#endif
-               }
-
-       } else {
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_lookup not found\n"));
-
-       }
-
-/* added NCB for 2.5/6 compatability - forces add even if inode is
- * NULL which creates dentry hash */
-       d_add(dentry, inode);
-
-       return NULL;
-       /*      return (ERR_PTR(-EIO)); */
-
-}
-
-/* For now put inode is just for debugging
- * Put inode is called when the inode **structure** is put.
- */
-static void yaffs_put_inode(struct inode *inode)
-{
-       T(YAFFS_TRACE_OS,
-         ("yaffs_put_inode: ino %d, count %d\n", (int)inode->i_ino,
-          atomic_read(&inode->i_count)));
-
-}
-
-/* clear is called to tell the fs to release any per-inode data it holds */
-static void yaffs_clear_inode(struct inode *inode)
-{
-       yaffs_Object *obj;
-       yaffs_Device *dev;
-
-       obj = yaffs_InodeToObject(inode);
-
-       T(YAFFS_TRACE_OS,
-         ("yaffs_clear_inode: ino %d, count %d %s\n", (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
-
-       if (obj) {
-               dev = obj->myDev;
-               yaffs_GrossLock(dev);
-
-               /* Clear the association between the inode and
-                * the yaffs_Object.
-                */
-               obj->myInode = NULL;
-               yaffs_InodeToObjectLV(inode) = NULL;
-
-               /* If the object freeing was deferred, then the real
-                * free happens now.
-                * This should fix the inode inconsistency problem.
-                */
-
-               yaffs_HandleDeferedFree(obj);
-
-               yaffs_GrossUnlock(dev);
-       }
-
-}
-
-/* delete is called when the link count is zero and the inode
- * is put (ie. nobody wants to know about it anymore, time to
- * delete the file).
- * NB Must call clear_inode()
- */
-static void yaffs_delete_inode(struct inode *inode)
-{
-       yaffs_Object *obj = yaffs_InodeToObject(inode);
-       yaffs_Device *dev;
-
-       T(YAFFS_TRACE_OS,
-         ("yaffs_delete_inode: ino %d, count %d %s\n", (int)inode->i_ino,
-          atomic_read(&inode->i_count),
-          obj ? "object exists" : "null object"));
-
-       if (obj) {
-               dev = obj->myDev;
-               yaffs_GrossLock(dev);
-               yaffs_DeleteFile(obj);
-               yaffs_GrossUnlock(dev);
-       }
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13))
-        truncate_inode_pages (&inode->i_data, 0);
-#endif
-       clear_inode(inode);
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_file_flush(struct file *file, fl_owner_t id)
-#else
-static int yaffs_file_flush(struct file *file)
-#endif
-{
-       yaffs_Object *obj = yaffs_DentryToObject(file->f_dentry);
-
-       yaffs_Device *dev = obj->myDev;
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_file_flush object %d (%s)\n", obj->objectId,
-          obj->dirty ? "dirty" : "clean"));
-
-       yaffs_GrossLock(dev);
-
-       yaffs_FlushFile(obj, 1);
-
-       yaffs_GrossUnlock(dev);
-
-       return 0;
-}
-
-static int yaffs_readpage_nolock(struct file *f, struct page *pg)
-{
-       /* Lifted from jffs2 */
-
-       yaffs_Object *obj;
-       unsigned char *pg_buf;
-       int ret;
-
-       yaffs_Device *dev;
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage at %08x, size %08x\n",
-                          (unsigned)(pg->index << PAGE_CACHE_SHIFT),
-                          (unsigned)PAGE_CACHE_SIZE));
-
-       obj = yaffs_DentryToObject(f->f_dentry);
-
-       dev = obj->myDev;
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-       BUG_ON(!PageLocked(pg));
-#else
-       if (!PageLocked(pg))
-               PAGE_BUG(pg);
-#endif
-
-       pg_buf = kmap(pg);
-       /* FIXME: Can kmap fail? */
-
-       yaffs_GrossLock(dev);
-
-       ret =
-           yaffs_ReadDataFromFile(obj, pg_buf, pg->index << PAGE_CACHE_SHIFT,
-                                  PAGE_CACHE_SIZE);
-
-       yaffs_GrossUnlock(dev);
-
-       if (ret >= 0)
-               ret = 0;
-
-       if (ret) {
-               ClearPageUptodate(pg);
-               SetPageError(pg);
-       } else {
-               SetPageUptodate(pg);
-               ClearPageError(pg);
-       }
-
-       flush_dcache_page(pg);
-       kunmap(pg);
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_readpage done\n"));
-       return ret;
-}
-
-static int yaffs_readpage_unlock(struct file *f, struct page *pg)
-{
-       int ret = yaffs_readpage_nolock(f, pg);
-       UnlockPage(pg);
-       return ret;
-}
-
-static int yaffs_readpage(struct file *f, struct page *pg)
-{
-       return yaffs_readpage_unlock(f, pg);
-}
-
-/* writepage inspired by/stolen from smbfs */
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_writepage(struct page *page, struct writeback_control *wbc)
-#else
-static int yaffs_writepage(struct page *page)
-#endif
-{
-       struct address_space *mapping = page->mapping;
-       loff_t offset = (loff_t) page->index << PAGE_CACHE_SHIFT;
-       struct inode *inode;
-       unsigned long end_index;
-       char *buffer;
-       yaffs_Object *obj;
-       int nWritten = 0;
-       unsigned nBytes;
-
-       if (!mapping)
-               BUG();
-       inode = mapping->host;
-       if (!inode)
-               BUG();
-
-       if (offset > inode->i_size) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG
-                  "yaffs_writepage at %08x, inode size = %08x!!!\n",
-                  (unsigned)(page->index << PAGE_CACHE_SHIFT),
-                  (unsigned)inode->i_size));
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "                -> don't care!!\n"));
-               unlock_page(page);
-               return 0;
-       }
-
-       end_index = inode->i_size >> PAGE_CACHE_SHIFT;
-
-       /* easy case */
-       if (page->index < end_index) {
-               nBytes = PAGE_CACHE_SIZE;
-       } else {
-               nBytes = inode->i_size & (PAGE_CACHE_SIZE - 1);
-       }
-
-       get_page(page);
-
-       buffer = kmap(page);
-
-       obj = yaffs_InodeToObject(inode);
-       yaffs_GrossLock(obj->myDev);
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_writepage at %08x, size %08x\n",
-          (unsigned)(page->index << PAGE_CACHE_SHIFT), nBytes));
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "writepag0: obj = %05x, ino = %05x\n",
-          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
-
-       nWritten =
-           yaffs_WriteDataToFile(obj, buffer, page->index << PAGE_CACHE_SHIFT,
-                                 nBytes, 0);
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "writepag1: obj = %05x, ino = %05x\n",
-          (int)obj->variant.fileVariant.fileSize, (int)inode->i_size));
-
-       yaffs_GrossUnlock(obj->myDev);
-
-       kunmap(page);
-       SetPageUptodate(page);
-       UnlockPage(page);
-       put_page(page);
-
-       return (nWritten == nBytes) ? 0 : -ENOSPC;
-}
-
-static int yaffs_prepare_write(struct file *f, struct page *pg,
-                              unsigned offset, unsigned to)
-{
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_prepair_write\n"));
-       if (!Page_Uptodate(pg) && (offset || to < PAGE_CACHE_SIZE))
-               return yaffs_readpage_nolock(f, pg);
-
-       return 0;
-
-}
-
-static int yaffs_commit_write(struct file *f, struct page *pg, unsigned offset,
-                             unsigned to)
-{
-
-       void *addr = page_address(pg) + offset;
-       loff_t pos = (((loff_t) pg->index) << PAGE_CACHE_SHIFT) + offset;
-       int nBytes = to - offset;
-       int nWritten;
-
-       unsigned spos = pos;
-       unsigned saddr = (unsigned)addr;
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_commit_write addr %x pos %x nBytes %d\n", saddr,
-          spos, nBytes));
-
-       nWritten = yaffs_file_write(f, addr, nBytes, &pos);
-
-       if (nWritten != nBytes) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG
-                  "yaffs_commit_write not same size nWritten %d  nBytes %d\n",
-                  nWritten, nBytes));
-               SetPageError(pg);
-               ClearPageUptodate(pg);
-       } else {
-               SetPageUptodate(pg);
-       }
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_commit_write returning %d\n",
-          nWritten == nBytes ? 0 : nWritten));
-
-       return nWritten == nBytes ? 0 : nWritten;
-
-}
-
-static void yaffs_FillInodeFromObject(struct inode *inode, yaffs_Object * obj)
-{
-       if (inode && obj) {
-
-
-               /* Check mode against the variant type and attempt to repair if broken. */
-               __u32 mode = obj->yst_mode;
-               switch( obj->variantType ){
-               case YAFFS_OBJECT_TYPE_FILE :
-                       if( ! S_ISREG(mode) ){
-                               obj->yst_mode &= ~S_IFMT;
-                               obj->yst_mode |= S_IFREG;
-                       }
-
-                       break;
-               case YAFFS_OBJECT_TYPE_SYMLINK :
-                       if( ! S_ISLNK(mode) ){
-                               obj->yst_mode &= ~S_IFMT;
-                               obj->yst_mode |= S_IFLNK;
-                       }
-
-                       break;
-               case YAFFS_OBJECT_TYPE_DIRECTORY :
-                       if( ! S_ISDIR(mode) ){
-                               obj->yst_mode &= ~S_IFMT;
-                               obj->yst_mode |= S_IFDIR;
-                       }
-
-                       break;
-               case YAFFS_OBJECT_TYPE_UNKNOWN :
-               case YAFFS_OBJECT_TYPE_HARDLINK :
-               case YAFFS_OBJECT_TYPE_SPECIAL :
-               default:
-                       /* TODO? */
-                       break;
-               }
-
-               inode->i_ino = obj->objectId;
-               inode->i_mode = obj->yst_mode;
-               inode->i_uid = obj->yst_uid;
-               inode->i_gid = obj->yst_gid;
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
-               inode->i_blksize = inode->i_sb->s_blocksize;
-#endif
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-
-               inode->i_rdev = old_decode_dev(obj->yst_rdev);
-               inode->i_atime.tv_sec = (time_t) (obj->yst_atime);
-               inode->i_atime.tv_nsec = 0;
-               inode->i_mtime.tv_sec = (time_t) obj->yst_mtime;
-               inode->i_mtime.tv_nsec = 0;
-               inode->i_ctime.tv_sec = (time_t) obj->yst_ctime;
-               inode->i_ctime.tv_nsec = 0;
-#else
-               inode->i_rdev = obj->yst_rdev;
-               inode->i_atime = obj->yst_atime;
-               inode->i_mtime = obj->yst_mtime;
-               inode->i_ctime = obj->yst_ctime;
-#endif
-               inode->i_size = yaffs_GetObjectFileLength(obj);
-               inode->i_blocks = (inode->i_size + 511) >> 9;
-
-               inode->i_nlink = yaffs_GetObjectLinkCount(obj);
-
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG
-                  "yaffs_FillInode mode %x uid %d gid %d size %d count %d\n",
-                  inode->i_mode, inode->i_uid, inode->i_gid,
-                  (int)inode->i_size, atomic_read(&inode->i_count)));
-
-               switch (obj->yst_mode & S_IFMT) {
-               default:        /* fifo, device or socket */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-                       init_special_inode(inode, obj->yst_mode,
-                                          old_decode_dev(obj->yst_rdev));
-#else
-                       init_special_inode(inode, obj->yst_mode,
-                                          (dev_t) (obj->yst_rdev));
-#endif
-                       break;
-               case S_IFREG:   /* file */
-                       inode->i_op = &yaffs_file_inode_operations;
-                       inode->i_fop = &yaffs_file_operations;
-                       inode->i_mapping->a_ops =
-                           &yaffs_file_address_operations;
-                       break;
-               case S_IFDIR:   /* directory */
-                       inode->i_op = &yaffs_dir_inode_operations;
-                       inode->i_fop = &yaffs_dir_operations;
-                       break;
-               case S_IFLNK:   /* symlink */
-                       inode->i_op = &yaffs_symlink_inode_operations;
-                       break;
-               }
-
-               yaffs_InodeToObjectLV(inode) = obj;
-
-               obj->myInode = inode;
-
-       } else {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_FileInode invalid parameters\n"));
-       }
-
-}
-
-struct inode *yaffs_get_inode(struct super_block *sb, int mode, int dev,
-                             yaffs_Object * obj)
-{
-       struct inode *inode;
-
-       if (!sb) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_get_inode for NULL super_block!!\n"));
-               return NULL;
-
-       }
-
-       if (!obj) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_get_inode for NULL object!!\n"));
-               return NULL;
-
-       }
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_get_inode for object %d\n", obj->objectId));
-
-       inode = iget(sb, obj->objectId);
-
-       /* NB Side effect: iget calls back to yaffs_read_inode(). */
-       /* iget also increments the inode's i_count */
-       /* NB You can't be holding grossLock or deadlock will happen! */
-
-       return inode;
-}
-
-static ssize_t yaffs_file_write(struct file *f, const char *buf, size_t n,
-                               loff_t * pos)
-{
-       yaffs_Object *obj;
-       int nWritten, ipos;
-       struct inode *inode;
-       yaffs_Device *dev;
-
-       obj = yaffs_DentryToObject(f->f_dentry);
-
-       dev = obj->myDev;
-
-       yaffs_GrossLock(dev);
-
-       inode = f->f_dentry->d_inode;
-
-       if (!S_ISBLK(inode->i_mode) && f->f_flags & O_APPEND) {
-               ipos = inode->i_size;
-       } else {
-               ipos = *pos;
-       }
-
-       if (!obj) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_file_write: hey obj is null!\n"));
-       } else {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG
-                  "yaffs_file_write about to write writing %d bytes"
-                  "to object %d at %d\n",
-                  n, obj->objectId, ipos));
-       }
-
-       nWritten = yaffs_WriteDataToFile(obj, buf, ipos, n, 0);
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_file_write writing %d bytes, %d written at %d\n",
-          n, nWritten, ipos));
-       if (nWritten > 0) {
-               ipos += nWritten;
-               *pos = ipos;
-               if (ipos > inode->i_size) {
-                       inode->i_size = ipos;
-                       inode->i_blocks = (ipos + 511) >> 9;
-
-                       T(YAFFS_TRACE_OS,
-                         (KERN_DEBUG
-                          "yaffs_file_write size updated to %d bytes, "
-                          "%d blocks\n",
-                          ipos, (int)(inode->i_blocks)));
-               }
-
-       }
-       yaffs_GrossUnlock(dev);
-       return nWritten == 0 ? -ENOSPC : nWritten;
-}
-
-static int yaffs_readdir(struct file *f, void *dirent, filldir_t filldir)
-{
-       yaffs_Object *obj;
-       yaffs_Device *dev;
-       struct inode *inode = f->f_dentry->d_inode;
-       unsigned long offset, curoffs;
-       struct list_head *i;
-       yaffs_Object *l;
-
-       char name[YAFFS_MAX_NAME_LENGTH + 1];
-
-       obj = yaffs_DentryToObject(f->f_dentry);
-       dev = obj->myDev;
-
-       yaffs_GrossLock(dev);
-
-       offset = f->f_pos;
-
-       T(YAFFS_TRACE_OS, ("yaffs_readdir: starting at %d\n", (int)offset));
-
-       if (offset == 0) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_readdir: entry . ino %d \n",
-                  (int)inode->i_ino));
-               if (filldir(dirent, ".", 1, offset, inode->i_ino, DT_DIR)
-                   < 0) {
-                       goto out;
-               }
-               offset++;
-               f->f_pos++;
-       }
-       if (offset == 1) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_readdir: entry .. ino %d \n",
-                  (int)f->f_dentry->d_parent->d_inode->i_ino));
-               if (filldir
-                   (dirent, "..", 2, offset,
-                    f->f_dentry->d_parent->d_inode->i_ino, DT_DIR) < 0) {
-                       goto out;
-               }
-               offset++;
-               f->f_pos++;
-       }
-
-       curoffs = 1;
-
-       /* If the directory has changed since the open or last call to
-          readdir, rewind to after the 2 canned entries. */
-
-       if (f->f_version != inode->i_version) {
-               offset = 2;
-               f->f_pos = offset;
-               f->f_version = inode->i_version;
-       }
-
-       list_for_each(i, &obj->variant.directoryVariant.children) {
-               curoffs++;
-               if (curoffs >= offset) {
-                       l = list_entry(i, yaffs_Object, siblings);
-
-                       yaffs_GetObjectName(l, name,
-                                           YAFFS_MAX_NAME_LENGTH + 1);
-                       T(YAFFS_TRACE_OS,
-                         (KERN_DEBUG "yaffs_readdir: %s inode %d\n", name,
-                          yaffs_GetObjectInode(l)));
-
-                       if (filldir(dirent,
-                                   name,
-                                   strlen(name),
-                                   offset,
-                                   yaffs_GetObjectInode(l),
-                                   yaffs_GetObjectType(l))
-                           < 0) {
-                               goto up_and_out;
-                       }
-
-                       offset++;
-                       f->f_pos++;
-               }
-       }
-
-      up_and_out:
-      out:
-
-       yaffs_GrossUnlock(dev);
-
-       return 0;
-}
-
-/*
- * File creation. Allocate an inode, and we're done..
- */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-                      dev_t rdev)
-#else
-static int yaffs_mknod(struct inode *dir, struct dentry *dentry, int mode,
-                      int rdev)
-#endif
-{
-       struct inode *inode;
-
-       yaffs_Object *obj = NULL;
-       yaffs_Device *dev;
-
-       yaffs_Object *parent = yaffs_InodeToObject(dir);
-
-       int error = -ENOSPC;
-       uid_t uid = current->fsuid;
-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
-
-       if((dir->i_mode & S_ISGID) && S_ISDIR(mode))
-               mode |= S_ISGID;
-
-       if (parent) {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_mknod: parent object %d type %d\n",
-                  parent->objectId, parent->variantType));
-       } else {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_mknod: could not get parent object\n"));
-               return -EPERM;
-       }
-
-       T(YAFFS_TRACE_OS, ("yaffs_mknod: making oject for %s, "
-                          "mode %x dev %x\n",
-                          dentry->d_name.name, mode, rdev));
-
-       dev = parent->myDev;
-
-       yaffs_GrossLock(dev);
-
-       switch (mode & S_IFMT) {
-       default:
-               /* Special (socket, fifo, device...) */
-               T(YAFFS_TRACE_OS, (KERN_DEBUG
-                                  "yaffs_mknod: making special\n"));
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-               obj =
-                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
-                                      gid, old_encode_dev(rdev));
-#else
-               obj =
-                   yaffs_MknodSpecial(parent, dentry->d_name.name, mode, uid,
-                                      gid, rdev);
-#endif
-               break;
-       case S_IFREG:           /* file          */
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
-               obj =
-                   yaffs_MknodFile(parent, dentry->d_name.name, mode, uid,
-                                   gid);
-               break;
-       case S_IFDIR:           /* directory */
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_mknod: making directory\n"));
-               obj =
-                   yaffs_MknodDirectory(parent, dentry->d_name.name, mode,
-                                        uid, gid);
-               break;
-       case S_IFLNK:           /* symlink */
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mknod: making file\n"));
-               obj = NULL;     /* Do we ever get here? */
-               break;
-       }
-
-       /* Can not call yaffs_get_inode() with gross lock held */
-       yaffs_GrossUnlock(dev);
-
-       if (obj) {
-               inode = yaffs_get_inode(dir->i_sb, mode, rdev, obj);
-               d_instantiate(dentry, inode);
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_mknod created object %d count = %d\n",
-                  obj->objectId, atomic_read(&inode->i_count)));
-               error = 0;
-       } else {
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_mknod failed making object\n"));
-               error = -ENOMEM;
-       }
-
-       return error;
-}
-
-static int yaffs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
-       int retVal;
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_mkdir\n"));
-       retVal = yaffs_mknod(dir, dentry, mode | S_IFDIR, 0);
-#if 0
-       /* attempt to fix dir bug - didn't work */
-       if (!retVal) {
-               dget(dentry);
-       }
-#endif
-       return retVal;
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode,
-                       struct nameidata *n)
-#else
-static int yaffs_create(struct inode *dir, struct dentry *dentry, int mode)
-#endif
-{
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_create\n"));
-       return yaffs_mknod(dir, dentry, mode | S_IFREG, 0);
-}
-
-static int yaffs_unlink(struct inode *dir, struct dentry *dentry)
-{
-       int retVal;
-
-       yaffs_Device *dev;
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_unlink %d:%s\n", (int)(dir->i_ino),
-          dentry->d_name.name));
-
-       dev = yaffs_InodeToObject(dir)->myDev;
-
-       yaffs_GrossLock(dev);
-
-       retVal = yaffs_Unlink(yaffs_InodeToObject(dir), dentry->d_name.name);
-
-       if (retVal == YAFFS_OK) {
-               dentry->d_inode->i_nlink--;
-               dir->i_version++;
-               yaffs_GrossUnlock(dev);
-               mark_inode_dirty(dentry->d_inode);
-               return 0;
-       }
-       yaffs_GrossUnlock(dev);
-       return -ENOTEMPTY;
-}
-
-/*
- * Create a link...
- */
-static int yaffs_link(struct dentry *old_dentry, struct inode *dir,
-                     struct dentry *dentry)
-{
-       struct inode *inode = old_dentry->d_inode;
-       yaffs_Object *obj = NULL;
-       yaffs_Object *link = NULL;
-       yaffs_Device *dev;
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_link\n"));
-
-       obj = yaffs_InodeToObject(inode);
-       dev = obj->myDev;
-
-       yaffs_GrossLock(dev);
-
-       if (!S_ISDIR(inode->i_mode))    /* Don't link directories */
-       {
-               link =
-                   yaffs_Link(yaffs_InodeToObject(dir), dentry->d_name.name,
-                              obj);
-       }
-
-       if (link) {
-               old_dentry->d_inode->i_nlink = yaffs_GetObjectLinkCount(obj);
-               d_instantiate(dentry, old_dentry->d_inode);
-               atomic_inc(&old_dentry->d_inode->i_count);
-               T(YAFFS_TRACE_OS,
-                 (KERN_DEBUG "yaffs_link link count %d i_count %d\n",
-                  old_dentry->d_inode->i_nlink,
-                  atomic_read(&old_dentry->d_inode->i_count)));
-
-       }
-
-       yaffs_GrossUnlock(dev);
-
-       if (link) {
-
-               return 0;
-       }
-
-       return -EPERM;
-}
-
-static int yaffs_symlink(struct inode *dir, struct dentry *dentry,
-                        const char *symname)
-{
-       yaffs_Object *obj;
-       yaffs_Device *dev;
-       uid_t uid = current->fsuid;
-       gid_t gid = (dir->i_mode & S_ISGID) ? dir->i_gid : current->fsgid;
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_symlink\n"));
-
-       dev = yaffs_InodeToObject(dir)->myDev;
-       yaffs_GrossLock(dev);
-       obj = yaffs_MknodSymLink(yaffs_InodeToObject(dir), dentry->d_name.name,
-                                S_IFLNK | S_IRWXUGO, uid, gid, symname);
-       yaffs_GrossUnlock(dev);
-
-       if (obj) {
-
-               struct inode *inode;
-
-               inode = yaffs_get_inode(dir->i_sb, obj->yst_mode, 0, obj);
-               d_instantiate(dentry, inode);
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink created OK\n"));
-               return 0;
-       } else {
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "symlink not created\n"));
-
-       }
-
-       return -ENOMEM;
-}
-
-static int yaffs_sync_object(struct file *file, struct dentry *dentry,
-                            int datasync)
-{
-
-       yaffs_Object *obj;
-       yaffs_Device *dev;
-
-       obj = yaffs_DentryToObject(dentry);
-
-       dev = obj->myDev;
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_object\n"));
-       yaffs_GrossLock(dev);
-       yaffs_FlushFile(obj, 1);
-       yaffs_GrossUnlock(dev);
-       return 0;
-}
-
-/*
- * The VFS layer already does all the dentry stuff for rename.
- *
- * NB: POSIX says you can rename an object over an old object of the same name
- */
-static int yaffs_rename(struct inode *old_dir, struct dentry *old_dentry,
-                       struct inode *new_dir, struct dentry *new_dentry)
-{
-       yaffs_Device *dev;
-       int retVal = YAFFS_FAIL;
-       yaffs_Object *target;
-
-        T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_rename\n"));
-       dev = yaffs_InodeToObject(old_dir)->myDev;
-
-       yaffs_GrossLock(dev);
-
-       /* Check if the target is an existing directory that is not empty. */
-       target =
-           yaffs_FindObjectByName(yaffs_InodeToObject(new_dir),
-                                  new_dentry->d_name.name);
-
-
-
-       if (target &&
-           target->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
-           !list_empty(&target->variant.directoryVariant.children)) {
-
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "target is non-empty dir\n"));
-
-               retVal = YAFFS_FAIL;
-       } else {
-
-               /* Now does unlinking internally using shadowing mechanism */
-               T(YAFFS_TRACE_OS, (KERN_DEBUG "calling yaffs_RenameObject\n"));
-
-               retVal =
-                   yaffs_RenameObject(yaffs_InodeToObject(old_dir),
-                                      old_dentry->d_name.name,
-                                      yaffs_InodeToObject(new_dir),
-                                      new_dentry->d_name.name);
-
-       }
-       yaffs_GrossUnlock(dev);
-
-       if (retVal == YAFFS_OK) {
-               if(target) {
-                       new_dentry->d_inode->i_nlink--;
-                       mark_inode_dirty(new_dentry->d_inode);
-               }
-
-               return 0;
-       } else {
-               return -ENOTEMPTY;
-       }
-
-}
-
-static int yaffs_setattr(struct dentry *dentry, struct iattr *attr)
-{
-       struct inode *inode = dentry->d_inode;
-       int error;
-       yaffs_Device *dev;
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_setattr of object %d\n",
-          yaffs_InodeToObject(inode)->objectId));
-
-       if ((error = inode_change_ok(inode, attr)) == 0) {
-
-               dev = yaffs_InodeToObject(inode)->myDev;
-               yaffs_GrossLock(dev);
-               if (yaffs_SetAttributes(yaffs_InodeToObject(inode), attr) ==
-                   YAFFS_OK) {
-                       error = 0;
-               } else {
-                       error = -EPERM;
-               }
-               yaffs_GrossUnlock(dev);
-               if (!error)
-                       error = inode_setattr(inode, attr);
-       }
-       return error;
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_statfs(struct dentry *dentry, struct kstatfs *buf)
-{
-       yaffs_Device *dev = yaffs_DentryToObject(dentry)->myDev;
-       struct super_block *sb = dentry->d_sb;
-#elif (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_statfs(struct super_block *sb, struct kstatfs *buf)
-{
-       yaffs_Device *dev = yaffs_SuperToDevice(sb);
-#else
-static int yaffs_statfs(struct super_block *sb, struct statfs *buf)
-{
-       yaffs_Device *dev = yaffs_SuperToDevice(sb);
-#endif
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_statfs\n"));
-
-       yaffs_GrossLock(dev);
-
-       buf->f_type = YAFFS_MAGIC;
-       buf->f_bsize = sb->s_blocksize;
-       buf->f_namelen = 255;
-       if (sb->s_blocksize > dev->nDataBytesPerChunk) {
-
-               buf->f_blocks =
-                   (dev->endBlock - dev->startBlock +
-                    1) * dev->nChunksPerBlock / (sb->s_blocksize /
-                                                 dev->nDataBytesPerChunk);
-               buf->f_bfree =
-                   yaffs_GetNumberOfFreeChunks(dev) / (sb->s_blocksize /
-                                                       dev->nDataBytesPerChunk);
-       } else {
-
-               buf->f_blocks =
-                   (dev->endBlock - dev->startBlock +
-                    1) * dev->nChunksPerBlock * (dev->nDataBytesPerChunk /
-                                                 sb->s_blocksize);
-               buf->f_bfree =
-                   yaffs_GetNumberOfFreeChunks(dev) * (dev->nDataBytesPerChunk /
-                                                       sb->s_blocksize);
-       }
-       buf->f_files = 0;
-       buf->f_ffree = 0;
-       buf->f_bavail = buf->f_bfree;
-
-       yaffs_GrossUnlock(dev);
-       return 0;
-}
-
-
-/**
-static int yaffs_do_sync_fs(struct super_block *sb)
-{
-
-       yaffs_Device *dev = yaffs_SuperToDevice(sb);
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_do_sync_fs\n"));
-
-       if(sb->s_dirt) {
-               yaffs_GrossLock(dev);
-
-               if(dev)
-                       yaffs_CheckpointSave(dev);
-
-               yaffs_GrossUnlock(dev);
-
-               sb->s_dirt = 0;
-       }
-       return 0;
-}
-**/
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static void yaffs_write_super(struct super_block *sb)
-#else
-static int yaffs_write_super(struct super_block *sb)
-#endif
-{
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_write_super\n"));
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
-       return 0; /* yaffs_do_sync_fs(sb);*/
-#endif
-}
-
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_sync_fs(struct super_block *sb, int wait)
-#else
-static int yaffs_sync_fs(struct super_block *sb)
-#endif
-{
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_sync_fs\n"));
-
-       return 0; /* yaffs_do_sync_fs(sb);*/
-
-}
-
-
-static void yaffs_read_inode(struct inode *inode)
-{
-       /* NB This is called as a side effect of other functions, but
-        * we had to release the lock to prevent deadlocks, so
-        * need to lock again.
-        */
-
-       yaffs_Object *obj;
-       yaffs_Device *dev = yaffs_SuperToDevice(inode->i_sb);
-
-       T(YAFFS_TRACE_OS,
-         (KERN_DEBUG "yaffs_read_inode for %d\n", (int)inode->i_ino));
-
-       yaffs_GrossLock(dev);
-
-       obj = yaffs_FindObjectByNumber(dev, inode->i_ino);
-
-       yaffs_FillInodeFromObject(inode, obj);
-
-       yaffs_GrossUnlock(dev);
-}
-
-static LIST_HEAD(yaffs_dev_list);
-
-#if 0 // not used
-static int yaffs_remount_fs(struct super_block *sb, int *flags, char *data)
-{
-       yaffs_Device    *dev = yaffs_SuperToDevice(sb);
-
-       if( *flags & MS_RDONLY ) {
-               struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
-
-               T(YAFFS_TRACE_OS,
-                       (KERN_DEBUG "yaffs_remount_fs: %s: RO\n", dev->name ));
-
-               yaffs_GrossLock(dev);
-
-               yaffs_FlushEntireDeviceCache(dev);
-
-               yaffs_CheckpointSave(dev);
-
-               if (mtd->sync)
-                       mtd->sync(mtd);
-
-               yaffs_GrossUnlock(dev);
-       }
-       else {
-               T(YAFFS_TRACE_OS,
-                       (KERN_DEBUG "yaffs_remount_fs: %s: RW\n", dev->name ));
-       }
-
-       return 0;
-}
-#endif
-
-static void yaffs_put_super(struct super_block *sb)
-{
-       yaffs_Device *dev = yaffs_SuperToDevice(sb);
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_put_super\n"));
-
-       yaffs_GrossLock(dev);
-
-       yaffs_FlushEntireDeviceCache(dev);
-
-       yaffs_CheckpointSave(dev);
-
-       if (dev->putSuperFunc) {
-               dev->putSuperFunc(sb);
-       }
-
-       yaffs_Deinitialise(dev);
-
-       yaffs_GrossUnlock(dev);
-
-       /* we assume this is protected by lock_kernel() in mount/umount */
-       list_del(&dev->devList);
-
-       if(dev->spareBuffer){
-               YFREE(dev->spareBuffer);
-               dev->spareBuffer = NULL;
-       }
-
-       kfree(dev);
-}
-
-
-static void yaffs_MTDPutSuper(struct super_block *sb)
-{
-
-       struct mtd_info *mtd = yaffs_SuperToDevice(sb)->genericDevice;
-
-       if (mtd->sync) {
-               mtd->sync(mtd);
-       }
-
-       put_mtd_device(mtd);
-}
-
-
-static void yaffs_MarkSuperBlockDirty(void *vsb)
-{
-       struct super_block *sb = (struct super_block *)vsb;
-
-       T(YAFFS_TRACE_OS, (KERN_DEBUG "yaffs_MarkSuperBlockDirty() sb = %p\n",sb));
-//     if(sb)
-//             sb->s_dirt = 1;
-}
-
-typedef struct {
-       int inband_tags;
-       int skip_checkpoint_read;
-       int skip_checkpoint_write;
-       int no_cache;
-} yaffs_options;
-
-#define MAX_OPT_LEN 20
-static int yaffs_parse_options(yaffs_options *options, const char *options_str)
-{
-       char cur_opt[MAX_OPT_LEN+1];
-       int p;
-       int error = 0;
-
-       /* Parse through the options which is a comma seperated list */
-
-       while(options_str && *options_str && !error){
-               memset(cur_opt,0,MAX_OPT_LEN+1);
-               p = 0;
-
-               while(*options_str && *options_str != ','){
-                       if(p < MAX_OPT_LEN){
-                               cur_opt[p] = *options_str;
-                               p++;
-                       }
-                       options_str++;
-               }
-
-               if(!strcmp(cur_opt,"inband-tags"))
-                       options->inband_tags = 1;
-               else if(!strcmp(cur_opt,"no-cache"))
-                       options->no_cache = 1;
-               else if(!strcmp(cur_opt,"no-checkpoint-read"))
-                       options->skip_checkpoint_read = 1;
-               else if(!strcmp(cur_opt,"no-checkpoint-write"))
-                       options->skip_checkpoint_write = 1;
-               else if(!strcmp(cur_opt,"no-checkpoint")){
-                       options->skip_checkpoint_read = 1;
-                       options->skip_checkpoint_write = 1;
-               } else {
-                       printk(KERN_INFO "yaffs: Bad mount option \"%s\"\n",cur_opt);
-                       error = 1;
-               }
-
-       }
-
-       return error;
-}
-
-static struct super_block *yaffs_internal_read_super(int yaffsVersion,
-                                                    struct super_block *sb,
-                                                    void *data, int silent)
-{
-       int nBlocks;
-       struct inode *inode = NULL;
-       struct dentry *root;
-       yaffs_Device *dev = 0;
-       char devname_buf[BDEVNAME_SIZE + 1];
-       struct mtd_info *mtd;
-       int err;
-       char *data_str = (char *)data;
-
-       yaffs_options options;
-
-       sb->s_magic = YAFFS_MAGIC;
-       sb->s_op = &yaffs_super_ops;
-
-       if (!sb)
-               printk(KERN_INFO "yaffs: sb is NULL\n");
-       else if (!sb->s_dev)
-               printk(KERN_INFO "yaffs: sb->s_dev is NULL\n");
-       else if (!yaffs_devname(sb, devname_buf))
-               printk(KERN_INFO "yaffs: devname is NULL\n");
-       else
-               printk(KERN_INFO "yaffs: dev is %d name is \"%s\"\n",
-                      sb->s_dev,
-                      yaffs_devname(sb, devname_buf));
-
-       if(!data_str)
-               data_str = "";
-
-       printk(KERN_INFO "yaffs: passed flags \"%s\"\n",data_str);
-
-       memset(&options,0,sizeof(options));
-
-       if(yaffs_parse_options(&options,data_str)){
-               /* Option parsing failed */
-               return NULL;
-       }
-
-
-       sb->s_blocksize = PAGE_CACHE_SIZE;
-       sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
-       T(YAFFS_TRACE_OS, ("yaffs_read_super: Using yaffs%d\n", yaffsVersion));
-       T(YAFFS_TRACE_OS,
-         ("yaffs_read_super: block size %d\n", (int)(sb->s_blocksize)));
-
-#ifdef CONFIG_YAFFS_DISABLE_WRITE_VERIFY
-       T(YAFFS_TRACE_OS,
-         ("yaffs: Write verification disabled. All guarantees "
-          "null and void\n"));
-#endif
-
-       T(YAFFS_TRACE_ALWAYS, ("yaffs: Attempting MTD mount on %u.%u, "
-                              "\"%s\"\n",
-                              MAJOR(sb->s_dev), MINOR(sb->s_dev),
-                              yaffs_devname(sb, devname_buf)));
-
-       /* Check it's an mtd device..... */
-       if (MAJOR(sb->s_dev) != MTD_BLOCK_MAJOR) {
-               return NULL;    /* This isn't an mtd device */
-       }
-       /* Get the device */
-       mtd = get_mtd_device(NULL, MINOR(sb->s_dev));
-       if (!mtd) {
-               T(YAFFS_TRACE_ALWAYS,
-                 ("yaffs: MTD device #%u doesn't appear to exist\n",
-                  MINOR(sb->s_dev)));
-               return NULL;
-       }
-       /* Check it's NAND */
-       if (mtd->type != MTD_NANDFLASH) {
-               T(YAFFS_TRACE_ALWAYS,
-                 ("yaffs: MTD device is not NAND it's type %d\n", mtd->type));
-               return NULL;
-       }
-
-       T(YAFFS_TRACE_OS, (" erase %p\n", mtd->erase));
-       T(YAFFS_TRACE_OS, (" read %p\n", mtd->read));
-       T(YAFFS_TRACE_OS, (" write %p\n", mtd->write));
-       T(YAFFS_TRACE_OS, (" readoob %p\n", mtd->read_oob));
-       T(YAFFS_TRACE_OS, (" writeoob %p\n", mtd->write_oob));
-       T(YAFFS_TRACE_OS, (" block_isbad %p\n", mtd->block_isbad));
-       T(YAFFS_TRACE_OS, (" block_markbad %p\n", mtd->block_markbad));
-       T(YAFFS_TRACE_OS, (" %s %d\n", WRITE_SIZE_STR, WRITE_SIZE(mtd)));
-       T(YAFFS_TRACE_OS, (" oobsize %d\n", mtd->oobsize));
-       T(YAFFS_TRACE_OS, (" erasesize %d\n", mtd->erasesize));
-       T(YAFFS_TRACE_OS, (" size %d\n", mtd->size));
-
-#ifdef CONFIG_YAFFS_AUTO_YAFFS2
-
-       if (yaffsVersion == 1 &&
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-           mtd->writesize >= 2048) {
-#else
-           mtd->oobblock >= 2048) {
-#endif
-           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs2\n"));
-           yaffsVersion = 2;
-       }
-
-       /* Added NCB 26/5/2006 for completeness */
-       if (yaffsVersion == 2 &&
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-           mtd->writesize == 512) {
-#else
-           mtd->oobblock == 512) {
-#endif
-           T(YAFFS_TRACE_ALWAYS,("yaffs: auto selecting yaffs1\n"));
-           yaffsVersion = 1;
-       }
-
-#endif
-
-       if (yaffsVersion == 2) {
-               /* Check for version 2 style functions */
-               if (!mtd->erase ||
-                   !mtd->block_isbad ||
-                   !mtd->block_markbad ||
-                   !mtd->read ||
-                   !mtd->write ||
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-                   !mtd->read_oob || !mtd->write_oob) {
-#else
-                   !mtd->write_ecc ||
-                   !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
-#endif
-                       T(YAFFS_TRACE_ALWAYS,
-                         ("yaffs: MTD device does not support required "
-                          "functions\n"));;
-                       return NULL;
-               }
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-               if (mtd->writesize < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
-#else
-               if (mtd->oobblock < YAFFS_MIN_YAFFS2_CHUNK_SIZE ||
-#endif
-                   mtd->oobsize < YAFFS_MIN_YAFFS2_SPARE_SIZE) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         ("yaffs: MTD device does not have the "
-                          "right page sizes\n"));
-                       return NULL;
-               }
-       } else {
-               /* Check for V1 style functions */
-               if (!mtd->erase ||
-                   !mtd->read ||
-                   !mtd->write ||
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-                   !mtd->read_oob || !mtd->write_oob) {
-#else
-                   !mtd->write_ecc ||
-                   !mtd->read_ecc || !mtd->read_oob || !mtd->write_oob) {
-#endif
-                       T(YAFFS_TRACE_ALWAYS,
-                         ("yaffs: MTD device does not support required "
-                          "functions\n"));;
-                       return NULL;
-               }
-
-               if (WRITE_SIZE(mtd) < YAFFS_BYTES_PER_CHUNK ||
-                   mtd->oobsize != YAFFS_BYTES_PER_SPARE) {
-                       T(YAFFS_TRACE_ALWAYS,
-                         ("yaffs: MTD device does not support have the "
-                          "right page sizes\n"));
-                       return NULL;
-               }
-       }
-
-       /* OK, so if we got here, we have an MTD that's NAND and looks
-        * like it has the right capabilities
-        * Set the yaffs_Device up for mtd
-        */
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-       sb->s_fs_info = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
-#else
-       sb->u.generic_sbp = dev = kmalloc(sizeof(yaffs_Device), GFP_KERNEL);
-#endif
-       if (!dev) {
-               /* Deep shit could not allocate device structure */
-               T(YAFFS_TRACE_ALWAYS,
-                 ("yaffs_read_super: Failed trying to allocate "
-                  "yaffs_Device. \n"));
-               return NULL;
-       }
-
-       memset(dev, 0, sizeof(yaffs_Device));
-       dev->genericDevice = mtd;
-       dev->name = mtd->name;
-
-       /* Set up the memory size parameters.... */
-
-       nBlocks = mtd->size / (YAFFS_CHUNKS_PER_BLOCK * YAFFS_BYTES_PER_CHUNK);
-       dev->startBlock = 0;
-       dev->endBlock = nBlocks - 1;
-       dev->nChunksPerBlock = YAFFS_CHUNKS_PER_BLOCK;
-       dev->nDataBytesPerChunk = YAFFS_BYTES_PER_CHUNK;
-       dev->nReservedBlocks = 5;
-       dev->nShortOpCaches = (options.no_cache) ? 0 : 10;
-
-       /* ... and the functions. */
-       if (yaffsVersion == 2) {
-               dev->writeChunkWithTagsToNAND =
-                   nandmtd2_WriteChunkWithTagsToNAND;
-               dev->readChunkWithTagsFromNAND =
-                   nandmtd2_ReadChunkWithTagsFromNAND;
-               dev->markNANDBlockBad = nandmtd2_MarkNANDBlockBad;
-               dev->queryNANDBlock = nandmtd2_QueryNANDBlock;
-               dev->spareBuffer = YMALLOC(mtd->oobsize);
-               dev->isYaffs2 = 1;
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-               dev->nDataBytesPerChunk = mtd->writesize;
-               dev->nChunksPerBlock = mtd->erasesize / mtd->writesize;
-#else
-               dev->nDataBytesPerChunk = mtd->oobblock;
-               dev->nChunksPerBlock = mtd->erasesize / mtd->oobblock;
-#endif
-               nBlocks = mtd->size / mtd->erasesize;
-
-               dev->nCheckpointReservedBlocks = CONFIG_YAFFS_CHECKPOINT_RESERVED_BLOCKS;
-               dev->startBlock = 0;
-               dev->endBlock = nBlocks - 1;
-       } else {
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-               /* use the MTD interface in yaffs_mtdif1.c */
-               dev->writeChunkWithTagsToNAND =
-                       nandmtd1_WriteChunkWithTagsToNAND;
-               dev->readChunkWithTagsFromNAND =
-                       nandmtd1_ReadChunkWithTagsFromNAND;
-               dev->markNANDBlockBad = nandmtd1_MarkNANDBlockBad;
-               dev->queryNANDBlock = nandmtd1_QueryNANDBlock;
-#else
-               dev->writeChunkToNAND = nandmtd_WriteChunkToNAND;
-               dev->readChunkFromNAND = nandmtd_ReadChunkFromNAND;
-#endif
-               dev->isYaffs2 = 0;
-       }
-       /* ... and common functions */
-       dev->eraseBlockInNAND = nandmtd_EraseBlockInNAND;
-       dev->initialiseNAND = nandmtd_InitialiseNAND;
-
-       dev->putSuperFunc = yaffs_MTDPutSuper;
-
-       dev->superBlock = (void *)sb;
-       dev->markSuperBlockDirty = yaffs_MarkSuperBlockDirty;
-
-
-#ifndef CONFIG_YAFFS_DOES_ECC
-       dev->useNANDECC = 1;
-#endif
-
-#ifdef CONFIG_YAFFS_DISABLE_WIDE_TNODES
-       dev->wideTnodesDisabled = 1;
-#endif
-
-       dev->skipCheckpointRead = options.skip_checkpoint_read;
-       dev->skipCheckpointWrite = options.skip_checkpoint_write;
-
-       /* we assume this is protected by lock_kernel() in mount/umount */
-       list_add_tail(&dev->devList, &yaffs_dev_list);
-
-       init_MUTEX(&dev->grossLock);
-
-       yaffs_GrossLock(dev);
-
-       err = yaffs_GutsInitialise(dev);
-
-       T(YAFFS_TRACE_OS,
-         ("yaffs_read_super: guts initialised %s\n",
-          (err == YAFFS_OK) ? "OK" : "FAILED"));
-
-       /* Release lock before yaffs_get_inode() */
-       yaffs_GrossUnlock(dev);
-
-       /* Create root inode */
-       if (err == YAFFS_OK)
-               inode = yaffs_get_inode(sb, S_IFDIR | 0755, 0,
-                                       yaffs_Root(dev));
-
-       if (!inode)
-               return NULL;
-
-       inode->i_op = &yaffs_dir_inode_operations;
-       inode->i_fop = &yaffs_dir_operations;
-
-       T(YAFFS_TRACE_OS, ("yaffs_read_super: got root inode\n"));
-
-       root = d_alloc_root(inode);
-
-       T(YAFFS_TRACE_OS, ("yaffs_read_super: d_alloc_root done\n"));
-
-       if (!root) {
-               iput(inode);
-               return NULL;
-       }
-       sb->s_root = root;
-
-       T(YAFFS_TRACE_OS, ("yaffs_read_super: done\n"));
-       return sb;
-}
-
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs_internal_read_super_mtd(struct super_block *sb, void *data,
-                                        int silent)
-{
-       return yaffs_internal_read_super(1, sb, data, silent) ? 0 : -EINVAL;
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs_read_super(struct file_system_type *fs,
-                           int flags, const char *dev_name,
-                           void *data, struct vfsmount *mnt)
-{
-
-       return get_sb_bdev(fs, flags, dev_name, data,
-                          yaffs_internal_read_super_mtd, mnt);
-}
-#else
-static struct super_block *yaffs_read_super(struct file_system_type *fs,
-                                           int flags, const char *dev_name,
-                                           void *data)
-{
-
-       return get_sb_bdev(fs, flags, dev_name, data,
-                          yaffs_internal_read_super_mtd);
-}
-#endif
-
-static struct file_system_type yaffs_fs_type = {
-       .owner = THIS_MODULE,
-       .name = "yaffs",
-       .get_sb = yaffs_read_super,
-       .kill_sb = kill_block_super,
-       .fs_flags = FS_REQUIRES_DEV,
-};
-#else
-static struct super_block *yaffs_read_super(struct super_block *sb, void *data,
-                                           int silent)
-{
-       return yaffs_internal_read_super(1, sb, data, silent);
-}
-
-static DECLARE_FSTYPE(yaffs_fs_type, "yaffs", yaffs_read_super,
-                     FS_REQUIRES_DEV);
-#endif
-
-
-#ifdef CONFIG_YAFFS_YAFFS2
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-static int yaffs2_internal_read_super_mtd(struct super_block *sb, void *data,
-                                         int silent)
-{
-       return yaffs_internal_read_super(2, sb, data, silent) ? 0 : -EINVAL;
-}
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static int yaffs2_read_super(struct file_system_type *fs,
-                       int flags, const char *dev_name, void *data,
-                       struct vfsmount *mnt)
-{
-       return get_sb_bdev(fs, flags, dev_name, data,
-                       yaffs2_internal_read_super_mtd, mnt);
-}
-#else
-static struct super_block *yaffs2_read_super(struct file_system_type *fs,
-                                            int flags, const char *dev_name,
-                                            void *data)
-{
-
-       return get_sb_bdev(fs, flags, dev_name, data,
-                          yaffs2_internal_read_super_mtd);
-}
-#endif
-
-static struct file_system_type yaffs2_fs_type = {
-       .owner = THIS_MODULE,
-       .name = "yaffs2",
-       .get_sb = yaffs2_read_super,
-       .kill_sb = kill_block_super,
-       .fs_flags = FS_REQUIRES_DEV,
-};
-#else
-static struct super_block *yaffs2_read_super(struct super_block *sb,
-                                            void *data, int silent)
-{
-       return yaffs_internal_read_super(2, sb, data, silent);
-}
-
-static DECLARE_FSTYPE(yaffs2_fs_type, "yaffs2", yaffs2_read_super,
-                     FS_REQUIRES_DEV);
-#endif
-
-#endif                         /* CONFIG_YAFFS_YAFFS2 */
-
-static struct proc_dir_entry *my_proc_entry;
-
-static char *yaffs_dump_dev(char *buf, yaffs_Device * dev)
-{
-       buf += sprintf(buf, "startBlock......... %d\n", dev->startBlock);
-       buf += sprintf(buf, "endBlock........... %d\n", dev->endBlock);
-       buf += sprintf(buf, "nDataBytesPerChunk. %d\n", dev->nDataBytesPerChunk);
-       buf += sprintf(buf, "chunkGroupBits..... %d\n", dev->chunkGroupBits);
-       buf += sprintf(buf, "chunkGroupSize..... %d\n", dev->chunkGroupSize);
-       buf += sprintf(buf, "nErasedBlocks...... %d\n", dev->nErasedBlocks);
-       buf += sprintf(buf, "nReservedBlocks.... %d\n", dev->nReservedBlocks);
-       buf += sprintf(buf, "nCheckptResBlocks.. %d\n", dev->nCheckpointReservedBlocks);
-       buf += sprintf(buf, "blocksInCheckpoint. %d\n", dev->blocksInCheckpoint);
-       buf += sprintf(buf, "nTnodesCreated..... %d\n", dev->nTnodesCreated);
-       buf += sprintf(buf, "nFreeTnodes........ %d\n", dev->nFreeTnodes);
-       buf += sprintf(buf, "nObjectsCreated.... %d\n", dev->nObjectsCreated);
-       buf += sprintf(buf, "nFreeObjects....... %d\n", dev->nFreeObjects);
-       buf += sprintf(buf, "nFreeChunks........ %d\n", dev->nFreeChunks);
-       buf += sprintf(buf, "nPageWrites........ %d\n", dev->nPageWrites);
-       buf += sprintf(buf, "nPageReads......... %d\n", dev->nPageReads);
-       buf += sprintf(buf, "nBlockErasures..... %d\n", dev->nBlockErasures);
-       buf += sprintf(buf, "nGCCopies.......... %d\n", dev->nGCCopies);
-       buf +=
-           sprintf(buf, "garbageCollections. %d\n", dev->garbageCollections);
-       buf +=
-           sprintf(buf, "passiveGCs......... %d\n",
-                   dev->passiveGarbageCollections);
-       buf += sprintf(buf, "nRetriedWrites..... %d\n", dev->nRetriedWrites);
-       buf += sprintf(buf, "nShortOpCaches..... %d\n", dev->nShortOpCaches);
-       buf += sprintf(buf, "nRetireBlocks...... %d\n", dev->nRetiredBlocks);
-       buf += sprintf(buf, "eccFixed........... %d\n", dev->eccFixed);
-       buf += sprintf(buf, "eccUnfixed......... %d\n", dev->eccUnfixed);
-       buf += sprintf(buf, "tagsEccFixed....... %d\n", dev->tagsEccFixed);
-       buf += sprintf(buf, "tagsEccUnfixed..... %d\n", dev->tagsEccUnfixed);
-       buf += sprintf(buf, "cacheHits.......... %d\n", dev->cacheHits);
-       buf += sprintf(buf, "nDeletedFiles...... %d\n", dev->nDeletedFiles);
-       buf += sprintf(buf, "nUnlinkedFiles..... %d\n", dev->nUnlinkedFiles);
-       buf +=
-           sprintf(buf, "nBackgroudDeletions %d\n", dev->nBackgroundDeletions);
-       buf += sprintf(buf, "useNANDECC......... %d\n", dev->useNANDECC);
-       buf += sprintf(buf, "isYaffs2........... %d\n", dev->isYaffs2);
-
-       return buf;
-}
-
-static int yaffs_proc_read(char *page,
-                          char **start,
-                          off_t offset, int count, int *eof, void *data)
-{
-       struct list_head *item;
-       char *buf = page;
-       int step = offset;
-       int n = 0;
-
-       /* Get proc_file_read() to step 'offset' by one on each sucessive call.
-        * We use 'offset' (*ppos) to indicate where we are in devList.
-        * This also assumes the user has posted a read buffer large
-        * enough to hold the complete output; but that's life in /proc.
-        */
-
-       *(int *)start = 1;
-
-       /* Print header first */
-       if (step == 0) {
-               buf += sprintf(buf, "YAFFS built:" __DATE__ " " __TIME__
-                              "\n%s\n%s\n", yaffs_fs_c_version,
-                              yaffs_guts_c_version);
-       }
-
-       /* hold lock_kernel while traversing yaffs_dev_list */
-       lock_kernel();
-
-       /* Locate and print the Nth entry.  Order N-squared but N is small. */
-       list_for_each(item, &yaffs_dev_list) {
-               yaffs_Device *dev = list_entry(item, yaffs_Device, devList);
-               if (n < step) {
-                       n++;
-                       continue;
-               }
-               buf += sprintf(buf, "\nDevice %d \"%s\"\n", n, dev->name);
-               buf = yaffs_dump_dev(buf, dev);
-               break;
-       }
-       unlock_kernel();
-
-       return buf - page < count ? buf - page : count;
-}
-
-/**
- * Set the verbosity of the warnings and error messages.
- *
- * Note that the names can only be a..z or _ with the current code.
- */
-
-static struct {
-       char *mask_name;
-       unsigned mask_bitfield;
-} mask_flags[] = {
-       {"allocate", YAFFS_TRACE_ALLOCATE},
-       {"always", YAFFS_TRACE_ALWAYS},
-       {"bad_blocks", YAFFS_TRACE_BAD_BLOCKS},
-       {"buffers", YAFFS_TRACE_BUFFERS},
-       {"bug", YAFFS_TRACE_BUG},
-       {"checkpt", YAFFS_TRACE_CHECKPOINT},
-       {"deletion", YAFFS_TRACE_DELETION},
-       {"erase", YAFFS_TRACE_ERASE},
-       {"error", YAFFS_TRACE_ERROR},
-       {"gc_detail", YAFFS_TRACE_GC_DETAIL},
-       {"gc", YAFFS_TRACE_GC},
-       {"mtd", YAFFS_TRACE_MTD},
-       {"nandaccess", YAFFS_TRACE_NANDACCESS},
-       {"os", YAFFS_TRACE_OS},
-       {"scan_debug", YAFFS_TRACE_SCAN_DEBUG},
-       {"scan", YAFFS_TRACE_SCAN},
-       {"tracing", YAFFS_TRACE_TRACING},
-
-       {"verify", YAFFS_TRACE_VERIFY},
-       {"verify_nand", YAFFS_TRACE_VERIFY_NAND},
-       {"verify_full", YAFFS_TRACE_VERIFY_FULL},
-       {"verify_all", YAFFS_TRACE_VERIFY_ALL},
-
-       {"write", YAFFS_TRACE_WRITE},
-       {"all", 0xffffffff},
-       {"none", 0},
-       {NULL, 0},
-};
-
-#define MAX_MASK_NAME_LENGTH 40
-static int yaffs_proc_write(struct file *file, const char *buf,
-                                        unsigned long count, void *data)
-{
-       unsigned rg = 0, mask_bitfield;
-       char *end;
-       char *mask_name;
-       const char *x;
-       char substring[MAX_MASK_NAME_LENGTH+1];
-       int i;
-       int done = 0;
-       int add, len = 0;
-       int pos = 0;
-
-       rg = yaffs_traceMask;
-
-       while (!done && (pos < count)) {
-               done = 1;
-               while ((pos < count) && isspace(buf[pos])) {
-                       pos++;
-               }
-
-               switch (buf[pos]) {
-               case '+':
-               case '-':
-               case '=':
-                       add = buf[pos];
-                       pos++;
-                       break;
-
-               default:
-                       add = ' ';
-                       break;
-               }
-               mask_name = NULL;
-
-               mask_bitfield = simple_strtoul(buf + pos, &end, 0);
-               if (end > buf + pos) {
-                       mask_name = "numeral";
-                       len = end - (buf + pos);
-                       pos += len;
-                       done = 0;
-               } else {
-                       for(x = buf + pos, i = 0;
-                           (*x == '_' || (*x >='a' && *x <= 'z')) &&
-                           i <MAX_MASK_NAME_LENGTH; x++, i++, pos++)
-                           substring[i] = *x;
-                       substring[i] = '\0';
-
-                       for (i = 0; mask_flags[i].mask_name != NULL; i++) {
-                               if(strcmp(substring,mask_flags[i].mask_name) == 0){
-                                       mask_name = mask_flags[i].mask_name;
-                                       mask_bitfield = mask_flags[i].mask_bitfield;
-                                       done = 0;
-                                       break;
-                               }
-                       }
-               }
-
-               if (mask_name != NULL) {
-                       done = 0;
-                       switch(add) {
-                       case '-':
-                               rg &= ~mask_bitfield;
-                               break;
-                       case '+':
-                               rg |= mask_bitfield;
-                               break;
-                       case '=':
-                               rg = mask_bitfield;
-                               break;
-                       default:
-                               rg |= mask_bitfield;
-                               break;
-                       }
-               }
-       }
-
-       yaffs_traceMask = rg | YAFFS_TRACE_ALWAYS;
-
-       printk("new trace = 0x%08X\n",yaffs_traceMask);
-
-       if (rg & YAFFS_TRACE_ALWAYS) {
-               for (i = 0; mask_flags[i].mask_name != NULL; i++) {
-                       char flag;
-                       flag = ((rg & mask_flags[i].mask_bitfield) == mask_flags[i].mask_bitfield) ? '+' : '-';
-                       printk("%c%s\n", flag, mask_flags[i].mask_name);
-               }
-       }
-
-       return count;
-}
-
-/* Stuff to handle installation of file systems */
-struct file_system_to_install {
-       struct file_system_type *fst;
-       int installed;
-};
-
-static struct file_system_to_install fs_to_install[] = {
-//#ifdef CONFIG_YAFFS_YAFFS1
-       {&yaffs_fs_type, 0},
-//#endif
-//#ifdef CONFIG_YAFFS_YAFFS2
-       {&yaffs2_fs_type, 0},
-//#endif
-       {NULL, 0}
-};
-
-static int __init init_yaffs_fs(void)
-{
-       int error = 0;
-       struct file_system_to_install *fsinst;
-
-       T(YAFFS_TRACE_ALWAYS,
-         ("yaffs " __DATE__ " " __TIME__ " Installing. \n"));
-
-       /* Install the proc_fs entry */
-       my_proc_entry = create_proc_entry("yaffs",
-                                              S_IRUGO | S_IFREG,
-                                              &proc_root);
-
-       if (my_proc_entry) {
-               my_proc_entry->write_proc = yaffs_proc_write;
-               my_proc_entry->read_proc = yaffs_proc_read;
-               my_proc_entry->data = NULL;
-       } else {
-               return -ENOMEM;
-       }
-
-       /* Now add the file system entries */
-
-       fsinst = fs_to_install;
-
-       while (fsinst->fst && !error) {
-               error = register_filesystem(fsinst->fst);
-               if (!error) {
-                       fsinst->installed = 1;
-               }
-               fsinst++;
-       }
-
-       /* Any errors? uninstall  */
-       if (error) {
-               fsinst = fs_to_install;
-
-               while (fsinst->fst) {
-                       if (fsinst->installed) {
-                               unregister_filesystem(fsinst->fst);
-                               fsinst->installed = 0;
-                       }
-                       fsinst++;
-               }
-       }
-
-       return error;
-}
-
-static void __exit exit_yaffs_fs(void)
-{
-
-       struct file_system_to_install *fsinst;
-
-       T(YAFFS_TRACE_ALWAYS, ("yaffs " __DATE__ " " __TIME__
-                              " removing. \n"));
-
-       remove_proc_entry("yaffs", &proc_root);
-
-       fsinst = fs_to_install;
-
-       while (fsinst->fst) {
-               if (fsinst->installed) {
-                       unregister_filesystem(fsinst->fst);
-                       fsinst->installed = 0;
-               }
-               fsinst++;
-       }
-
-}
-
-module_init(init_yaffs_fs)
-module_exit(exit_yaffs_fs)
-
-MODULE_DESCRIPTION("YAFFS2 - a NAND specific flash file system");
-MODULE_AUTHOR("Charles Manning, Aleph One Ltd., 2002-2006");
-MODULE_LICENSE("GPL");
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.c
deleted file mode 100644 (file)
index 2ab8146..0000000
+++ /dev/null
@@ -1,7469 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-const char *yaffs_guts_c_version =
-    "$Id: yaffs_guts.c,v 1.49 2007-05-15 20:07:40 charles Exp $";
-
-#include "yportenv.h"
-
-#include "yaffsinterface.h"
-#include "yaffs_guts.h"
-#include "yaffs_tagsvalidity.h"
-
-#include "yaffs_tagscompat.h"
-#ifndef  CONFIG_YAFFS_USE_OWN_SORT
-#include "yaffs_qsort.h"
-#endif
-#include "yaffs_nand.h"
-
-#include "yaffs_checkptrw.h"
-
-#include "yaffs_nand.h"
-#include "yaffs_packedtags2.h"
-
-
-#ifdef CONFIG_YAFFS_WINCE
-void yfsd_LockYAFFS(BOOL fsLockOnly);
-void yfsd_UnlockYAFFS(BOOL fsLockOnly);
-#endif
-
-#define YAFFS_PASSIVE_GC_CHUNKS 2
-
-#include "yaffs_ecc.h"
-
-
-/* Robustification (if it ever comes about...) */
-static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND);
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk);
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_ExtendedTags * tags);
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_ExtendedTags * tags);
-
-/* Other local prototypes */
-static int yaffs_UnlinkObject( yaffs_Object *obj);
-static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj);
-
-static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList);
-
-static int yaffs_WriteNewChunkWithTagsToNAND(yaffs_Device * dev,
-                                            const __u8 * buffer,
-                                            yaffs_ExtendedTags * tags,
-                                            int useReserve);
-static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
-                                 int chunkInNAND, int inScan);
-
-static yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
-                                          yaffs_ObjectType type);
-static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
-                                      yaffs_Object * obj);
-static int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name,
-                                   int force, int isShrink, int shadows);
-static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj);
-static int yaffs_CheckStructures(void);
-static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
-                             int chunkOffset, int *limit);
-static int yaffs_DoGenericObjectDeletion(yaffs_Object * in);
-
-static yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blockNo);
-
-static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo);
-static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
-                                   int lineNo);
-
-static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
-                                 int chunkInNAND);
-
-static int yaffs_UnlinkWorker(yaffs_Object * obj);
-static void yaffs_DestroyObject(yaffs_Object * obj);
-
-static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
-                          int chunkInObject);
-
-loff_t yaffs_GetFileSize(yaffs_Object * obj);
-
-static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr);
-
-static void yaffs_VerifyFreeChunks(yaffs_Device * dev);
-
-static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in);
-
-#ifdef YAFFS_PARANOID
-static int yaffs_CheckFileSanity(yaffs_Object * in);
-#else
-#define yaffs_CheckFileSanity(in)
-#endif
-
-static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in);
-static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId);
-
-static void yaffs_InvalidateCheckpoint(yaffs_Device *dev);
-
-static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
-                                yaffs_ExtendedTags * tags);
-
-static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos);
-static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
-                                         yaffs_FileStructure * fStruct,
-                                         __u32 chunkId);
-
-
-/* Function to calculate chunk and offset */
-
-static void yaffs_AddrToChunk(yaffs_Device *dev, loff_t addr, __u32 *chunk, __u32 *offset)
-{
-       if(dev->chunkShift){
-               /* Easy-peasy power of 2 case */
-               *chunk  = (__u32)(addr >> dev->chunkShift);
-               *offset = (__u32)(addr & dev->chunkMask);
-       }
-       else if(dev->crumbsPerChunk)
-       {
-               /* Case where we're using "crumbs" */
-               *offset = (__u32)(addr & dev->crumbMask);
-               addr >>= dev->crumbShift;
-               *chunk = ((__u32)addr)/dev->crumbsPerChunk;
-               *offset += ((addr - (*chunk * dev->crumbsPerChunk)) << dev->crumbShift);
-       }
-       else
-               YBUG();
-}
-
-/* Function to return the number of shifts for a power of 2 greater than or equal
- * to the given number
- * Note we don't try to cater for all possible numbers and this does not have to
- * be hellishly efficient.
- */
-
-static __u32 ShiftsGE(__u32 x)
-{
-       int extraBits;
-       int nShifts;
-
-       nShifts = extraBits = 0;
-
-       while(x>1){
-               if(x & 1) extraBits++;
-               x>>=1;
-               nShifts++;
-       }
-
-       if(extraBits)
-               nShifts++;
-
-       return nShifts;
-}
-
-/* Function to return the number of shifts to get a 1 in bit 0
- */
-
-static __u32 ShiftDiv(__u32 x)
-{
-       int nShifts;
-
-       nShifts =  0;
-
-       if(!x) return 0;
-
-       while( !(x&1)){
-               x>>=1;
-               nShifts++;
-       }
-
-       return nShifts;
-}
-
-
-
-/*
- * Temporary buffer manipulations.
- */
-
-static int yaffs_InitialiseTempBuffers(yaffs_Device *dev)
-{
-       int i;
-       __u8 *buf = (__u8 *)1;
-
-       memset(dev->tempBuffer,0,sizeof(dev->tempBuffer));
-
-       for (i = 0; buf && i < YAFFS_N_TEMP_BUFFERS; i++) {
-               dev->tempBuffer[i].line = 0;    /* not in use */
-               dev->tempBuffer[i].buffer = buf =
-                   YMALLOC_DMA(dev->nDataBytesPerChunk);
-       }
-
-       return buf ? YAFFS_OK : YAFFS_FAIL;
-
-}
-
-static __u8 *yaffs_GetTempBuffer(yaffs_Device * dev, int lineNo)
-{
-       int i, j;
-       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-               if (dev->tempBuffer[i].line == 0) {
-                       dev->tempBuffer[i].line = lineNo;
-                       if ((i + 1) > dev->maxTemp) {
-                               dev->maxTemp = i + 1;
-                               for (j = 0; j <= i; j++)
-                                       dev->tempBuffer[j].maxLine =
-                                           dev->tempBuffer[j].line;
-                       }
-
-                       return dev->tempBuffer[i].buffer;
-               }
-       }
-
-       T(YAFFS_TRACE_BUFFERS,
-         (TSTR("Out of temp buffers at line %d, other held by lines:"),
-          lineNo));
-       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-               T(YAFFS_TRACE_BUFFERS, (TSTR(" %d "), dev->tempBuffer[i].line));
-       }
-       T(YAFFS_TRACE_BUFFERS, (TSTR(" " TENDSTR)));
-
-       /*
-        * If we got here then we have to allocate an unmanaged one
-        * This is not good.
-        */
-
-       dev->unmanagedTempAllocations++;
-       return YMALLOC(dev->nDataBytesPerChunk);
-
-}
-
-static void yaffs_ReleaseTempBuffer(yaffs_Device * dev, __u8 * buffer,
-                                   int lineNo)
-{
-       int i;
-       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-               if (dev->tempBuffer[i].buffer == buffer) {
-                       dev->tempBuffer[i].line = 0;
-                       return;
-               }
-       }
-
-       if (buffer) {
-               /* assume it is an unmanaged one. */
-               T(YAFFS_TRACE_BUFFERS,
-                 (TSTR("Releasing unmanaged temp buffer in line %d" TENDSTR),
-                  lineNo));
-               YFREE(buffer);
-               dev->unmanagedTempDeallocations++;
-       }
-
-}
-
-/*
- * Determine if we have a managed buffer.
- */
-int yaffs_IsManagedTempBuffer(yaffs_Device * dev, const __u8 * buffer)
-{
-       int i;
-       for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-               if (dev->tempBuffer[i].buffer == buffer)
-                       return 1;
-
-       }
-
-    for (i = 0; i < dev->nShortOpCaches; i++) {
-        if( dev->srCache[i].data == buffer )
-            return 1;
-
-    }
-
-    if (buffer == dev->checkpointBuffer)
-      return 1;
-
-    T(YAFFS_TRACE_ALWAYS,
-         (TSTR("yaffs: unmaged buffer detected.\n" TENDSTR)));
-    return 0;
-}
-
-
-
-/*
- * Chunk bitmap manipulations
- */
-
-static Y_INLINE __u8 *yaffs_BlockBits(yaffs_Device * dev, int blk)
-{
-       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs: BlockBits block %d is not valid" TENDSTR),
-                  blk));
-               YBUG();
-       }
-       return dev->chunkBits +
-           (dev->chunkBitmapStride * (blk - dev->internalStartBlock));
-}
-
-static Y_INLINE void yaffs_VerifyChunkBitId(yaffs_Device *dev, int blk, int chunk)
-{
-       if(blk < dev->internalStartBlock || blk > dev->internalEndBlock ||
-          chunk < 0 || chunk >= dev->nChunksPerBlock) {
-          T(YAFFS_TRACE_ERROR,
-           (TSTR("**>> yaffs: Chunk Id (%d:%d) invalid"TENDSTR),blk,chunk));
-           YBUG();
-       }
-}
-
-static Y_INLINE void yaffs_ClearChunkBits(yaffs_Device * dev, int blk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-
-       memset(blkBits, 0, dev->chunkBitmapStride);
-}
-
-static Y_INLINE void yaffs_ClearChunkBit(yaffs_Device * dev, int blk, int chunk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-
-       yaffs_VerifyChunkBitId(dev,blk,chunk);
-
-       blkBits[chunk / 8] &= ~(1 << (chunk & 7));
-}
-
-static Y_INLINE void yaffs_SetChunkBit(yaffs_Device * dev, int blk, int chunk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-
-       yaffs_VerifyChunkBitId(dev,blk,chunk);
-
-       blkBits[chunk / 8] |= (1 << (chunk & 7));
-}
-
-static Y_INLINE int yaffs_CheckChunkBit(yaffs_Device * dev, int blk, int chunk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       yaffs_VerifyChunkBitId(dev,blk,chunk);
-
-       return (blkBits[chunk / 8] & (1 << (chunk & 7))) ? 1 : 0;
-}
-
-static Y_INLINE int yaffs_StillSomeChunkBits(yaffs_Device * dev, int blk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       int i;
-       for (i = 0; i < dev->chunkBitmapStride; i++) {
-               if (*blkBits)
-                       return 1;
-               blkBits++;
-       }
-       return 0;
-}
-
-static int yaffs_CountChunkBits(yaffs_Device * dev, int blk)
-{
-       __u8 *blkBits = yaffs_BlockBits(dev, blk);
-       int i;
-       int n = 0;
-       for (i = 0; i < dev->chunkBitmapStride; i++) {
-               __u8 x = *blkBits;
-               while(x){
-                       if(x & 1)
-                               n++;
-                       x >>=1;
-               }
-
-               blkBits++;
-       }
-       return n;
-}
-
-/*
- * Verification code
- */
-
-static int yaffs_SkipVerification(yaffs_Device *dev)
-{
-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY | YAFFS_TRACE_VERIFY_FULL));
-}
-
-static int yaffs_SkipFullVerification(yaffs_Device *dev)
-{
-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_FULL));
-}
-
-static int yaffs_SkipNANDVerification(yaffs_Device *dev)
-{
-       return !(yaffs_traceMask & (YAFFS_TRACE_VERIFY_NAND));
-}
-
-static const char * blockStateName[] = {
-"Unknown",
-"Needs scanning",
-"Scanning",
-"Empty",
-"Allocating",
-"Full",
-"Dirty",
-"Checkpoint",
-"Collecting",
-"Dead"
-};
-
-static void yaffs_VerifyBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
-{
-       int actuallyUsed;
-       int inUse;
-
-       if(yaffs_SkipVerification(dev))
-               return;
-
-       /* Report illegal runtime states */
-       if(bi->blockState <0 || bi->blockState >= YAFFS_NUMBER_OF_BLOCK_STATES)
-               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has undefined state %d"TENDSTR),n,bi->blockState));
-
-       switch(bi->blockState){
-        case YAFFS_BLOCK_STATE_UNKNOWN:
-        case YAFFS_BLOCK_STATE_SCANNING:
-        case YAFFS_BLOCK_STATE_NEEDS_SCANNING:
-               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has bad run-state %s"TENDSTR),
-               n,blockStateName[bi->blockState]));
-       }
-
-       /* Check pages in use and soft deletions are legal */
-
-       actuallyUsed = bi->pagesInUse - bi->softDeletions;
-
-       if(bi->pagesInUse < 0 || bi->pagesInUse > dev->nChunksPerBlock ||
-          bi->softDeletions < 0 || bi->softDeletions > dev->nChunksPerBlock ||
-          actuallyUsed < 0 || actuallyUsed > dev->nChunksPerBlock)
-               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has illegal values pagesInUsed %d softDeletions %d"TENDSTR),
-               n,bi->pagesInUse,bi->softDeletions));
-
-
-       /* Check chunk bitmap legal */
-       inUse = yaffs_CountChunkBits(dev,n);
-       if(inUse != bi->pagesInUse)
-               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has inconsistent values pagesInUse %d counted chunk bits %d"TENDSTR),
-                       n,bi->pagesInUse,inUse));
-
-       /* Check that the sequence number is valid.
-        * Ten million is legal, but is very unlikely
-        */
-       if(dev->isYaffs2 &&
-          (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING || bi->blockState == YAFFS_BLOCK_STATE_FULL) &&
-          (bi->sequenceNumber < YAFFS_LOWEST_SEQUENCE_NUMBER || bi->sequenceNumber > 10000000 ))
-               T(YAFFS_TRACE_VERIFY,(TSTR("Block %d has suspect sequence number of %d"TENDSTR),
-               n,bi->sequenceNumber));
-
-}
-
-static void yaffs_VerifyCollectedBlock(yaffs_Device *dev,yaffs_BlockInfo *bi,int n)
-{
-       yaffs_VerifyBlock(dev,bi,n);
-
-       /* After collection the block should be in the erased state */
-       /* TODO: This will need to change if we do partial gc */
-
-       if(bi->blockState != YAFFS_BLOCK_STATE_EMPTY){
-               T(YAFFS_TRACE_ERROR,(TSTR("Block %d is in state %d after gc, should be erased"TENDSTR),
-                       n,bi->blockState));
-       }
-}
-
-static void yaffs_VerifyBlocks(yaffs_Device *dev)
-{
-       int i;
-       int nBlocksPerState[YAFFS_NUMBER_OF_BLOCK_STATES];
-       int nIllegalBlockStates = 0;
-
-
-       if(yaffs_SkipVerification(dev))
-               return;
-
-       memset(nBlocksPerState,0,sizeof(nBlocksPerState));
-
-
-       for(i = dev->internalStartBlock; i <= dev->internalEndBlock; i++){
-               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev,i);
-               yaffs_VerifyBlock(dev,bi,i);
-
-               if(bi->blockState >=0 && bi->blockState < YAFFS_NUMBER_OF_BLOCK_STATES)
-                       nBlocksPerState[bi->blockState]++;
-               else
-                       nIllegalBlockStates++;
-
-       }
-
-       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
-       T(YAFFS_TRACE_VERIFY,(TSTR("Block summary"TENDSTR)));
-
-       T(YAFFS_TRACE_VERIFY,(TSTR("%d blocks have illegal states"TENDSTR),nIllegalBlockStates));
-       if(nBlocksPerState[YAFFS_BLOCK_STATE_ALLOCATING] > 1)
-               T(YAFFS_TRACE_VERIFY,(TSTR("Too many allocating blocks"TENDSTR)));
-
-       for(i = 0; i < YAFFS_NUMBER_OF_BLOCK_STATES; i++)
-               T(YAFFS_TRACE_VERIFY,
-                 (TSTR("%s %d blocks"TENDSTR),
-                 blockStateName[i],nBlocksPerState[i]));
-
-       if(dev->blocksInCheckpoint != nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT])
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Checkpoint block count wrong dev %d count %d"TENDSTR),
-                dev->blocksInCheckpoint, nBlocksPerState[YAFFS_BLOCK_STATE_CHECKPOINT]));
-
-       if(dev->nErasedBlocks != nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY])
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Erased block count wrong dev %d count %d"TENDSTR),
-                dev->nErasedBlocks, nBlocksPerState[YAFFS_BLOCK_STATE_EMPTY]));
-
-       if(nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING] > 1)
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Too many collecting blocks %d (max is 1)"TENDSTR),
-                nBlocksPerState[YAFFS_BLOCK_STATE_COLLECTING]));
-
-       T(YAFFS_TRACE_VERIFY,(TSTR(""TENDSTR)));
-
-}
-
-/*
- * Verify the object header. oh must be valid, but obj and tags may be NULL in which
- * case those tests will not be performed.
- */
-static void yaffs_VerifyObjectHeader(yaffs_Object *obj, yaffs_ObjectHeader *oh, yaffs_ExtendedTags *tags, int parentCheck)
-{
-       if(yaffs_SkipVerification(obj->myDev))
-               return;
-
-       if(!(tags && obj && oh)){
-               T(YAFFS_TRACE_VERIFY,
-                               (TSTR("Verifying object header tags %x obj %x oh %x"TENDSTR),
-                               (__u32)tags,(__u32)obj,(__u32)oh));
-               return;
-       }
-
-       if(oh->type <= YAFFS_OBJECT_TYPE_UNKNOWN ||
-          oh->type > YAFFS_OBJECT_TYPE_MAX)
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Obj %d header type is illegal value 0x%x"TENDSTR),
-                tags->objectId, oh->type));
-
-       if(tags->objectId != obj->objectId)
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Obj %d header mismatch objectId %d"TENDSTR),
-                tags->objectId, obj->objectId));
-
-
-       /*
-        * Check that the object's parent ids match if parentCheck requested.
-        *
-        * Tests do not apply to the root object.
-        */
-
-       if(parentCheck && tags->objectId > 1 && !obj->parent)
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Obj %d header mismatch parentId %d obj->parent is NULL"TENDSTR),
-                tags->objectId, oh->parentObjectId));
-
-
-       if(parentCheck && obj->parent &&
-          oh->parentObjectId != obj->parent->objectId &&
-          (oh->parentObjectId != YAFFS_OBJECTID_UNLINKED ||
-           obj->parent->objectId != YAFFS_OBJECTID_DELETED))
-               T(YAFFS_TRACE_VERIFY,
-                (TSTR("Obj %d header mismatch parentId %d parentObjectId %d"TENDSTR),
-                tags->objectId, oh->parentObjectId, obj->parent->objectId));
-
-
-       if(tags->objectId > 1 && oh->name[0] == 0) /* Null name */
-               T(YAFFS_TRACE_VERIFY,
-               (TSTR("Obj %d header name is NULL"TENDSTR),
-                obj->objectId));
-
-       if(tags->objectId > 1 && ((__u8)(oh->name[0])) == 0xff) /* Trashed name */
-               T(YAFFS_TRACE_VERIFY,
-               (TSTR("Obj %d header name is 0xFF"TENDSTR),
-                obj->objectId));
-}
-
-
-
-static int yaffs_VerifyTnodeWorker(yaffs_Object * obj, yaffs_Tnode * tn,
-                                       __u32 level, int chunkOffset)
-{
-       int i;
-       yaffs_Device *dev = obj->myDev;
-       int ok = 1;
-       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
-       if (tn) {
-               if (level > 0) {
-
-                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
-                               if (tn->internal[i]) {
-                                       ok = yaffs_VerifyTnodeWorker(obj,
-                                                       tn->internal[i],
-                                                       level - 1,
-                                                       (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
-                               }
-                       }
-               } else if (level == 0) {
-                       int i;
-                       yaffs_ExtendedTags tags;
-                       __u32 objectId = obj->objectId;
-
-                       chunkOffset <<=  YAFFS_TNODES_LEVEL0_BITS;
-
-                       for(i = 0; i < YAFFS_NTNODES_LEVEL0; i++){
-                               __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-
-                               if(theChunk > 0){
-                                       /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),tags.objectId,tags.chunkId,theChunk)); */
-                                       yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
-                                       if(tags.objectId != objectId || tags.chunkId != chunkOffset){
-                                               T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
-                                                       objectId, chunkOffset, theChunk,
-                                                       tags.objectId, tags.chunkId));
-                                       }
-                               }
-                               chunkOffset++;
-                       }
-               }
-       }
-
-       return ok;
-
-}
-
-
-static void yaffs_VerifyFile(yaffs_Object *obj)
-{
-       int requiredTallness;
-       int actualTallness;
-       __u32 lastChunk;
-       __u32 x;
-       __u32 i;
-       int ok;
-       yaffs_Device *dev;
-       yaffs_ExtendedTags tags;
-       yaffs_Tnode *tn;
-       __u32 objectId;
-
-       if(obj && yaffs_SkipVerification(obj->myDev))
-               return;
-
-       dev = obj->myDev;
-       objectId = obj->objectId;
-
-       /* Check file size is consistent with tnode depth */
-       lastChunk =  obj->variant.fileVariant.fileSize / dev->nDataBytesPerChunk + 1;
-       x = lastChunk >> YAFFS_TNODES_LEVEL0_BITS;
-       requiredTallness = 0;
-       while (x> 0) {
-               x >>= YAFFS_TNODES_INTERNAL_BITS;
-               requiredTallness++;
-       }
-
-       actualTallness = obj->variant.fileVariant.topLevel;
-
-       if(requiredTallness > actualTallness )
-               T(YAFFS_TRACE_VERIFY,
-               (TSTR("Obj %d had tnode tallness %d, needs to be %d"TENDSTR),
-                obj->objectId,actualTallness, requiredTallness));
-
-
-       /* Check that the chunks in the tnode tree are all correct.
-        * We do this by scanning through the tnode tree and
-        * checking the tags for every chunk match.
-        */
-
-       if(yaffs_SkipNANDVerification(dev))
-               return;
-
-       for(i = 1; i <= lastChunk; i++){
-               tn = yaffs_FindLevel0Tnode(dev, &obj->variant.fileVariant,i);
-
-               if (tn) {
-                       __u32 theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                       if(theChunk > 0){
-                               /* T(~0,(TSTR("verifying (%d:%d) %d"TENDSTR),objectId,i,theChunk)); */
-                               yaffs_ReadChunkWithTagsFromNAND(dev,theChunk,NULL, &tags);
-                               if(tags.objectId != objectId || tags.chunkId != i){
-                                       T(~0,(TSTR("Object %d chunkId %d NAND mismatch chunk %d tags (%d:%d)"TENDSTR),
-                                               objectId, i, theChunk,
-                                               tags.objectId, tags.chunkId));
-                               }
-                       }
-               }
-
-       }
-
-}
-
-static void yaffs_VerifyDirectory(yaffs_Object *obj)
-{
-       if(obj && yaffs_SkipVerification(obj->myDev))
-               return;
-
-}
-
-static void yaffs_VerifyHardLink(yaffs_Object *obj)
-{
-       if(obj && yaffs_SkipVerification(obj->myDev))
-               return;
-
-       /* Verify sane equivalent object */
-}
-
-static void yaffs_VerifySymlink(yaffs_Object *obj)
-{
-       if(obj && yaffs_SkipVerification(obj->myDev))
-               return;
-
-       /* Verify symlink string */
-}
-
-static void yaffs_VerifySpecial(yaffs_Object *obj)
-{
-       if(obj && yaffs_SkipVerification(obj->myDev))
-               return;
-}
-
-static void yaffs_VerifyObject(yaffs_Object *obj)
-{
-       yaffs_Device *dev;
-
-       __u32 chunkMin;
-       __u32 chunkMax;
-
-       __u32 chunkIdOk;
-       __u32 chunkIsLive;
-
-       if(!obj)
-               return;
-
-       dev = obj->myDev;
-
-       if(yaffs_SkipVerification(dev))
-               return;
-
-       /* Check sane object header chunk */
-
-       chunkMin = dev->internalStartBlock * dev->nChunksPerBlock;
-       chunkMax = (dev->internalEndBlock+1) * dev->nChunksPerBlock - 1;
-
-       chunkIdOk = (obj->chunkId >= chunkMin && obj->chunkId <= chunkMax);
-       chunkIsLive = chunkIdOk &&
-                       yaffs_CheckChunkBit(dev,
-                                           obj->chunkId / dev->nChunksPerBlock,
-                                           obj->chunkId % dev->nChunksPerBlock);
-       if(!obj->fake &&
-           (!chunkIdOk || !chunkIsLive)) {
-          T(YAFFS_TRACE_VERIFY,
-          (TSTR("Obj %d has chunkId %d %s %s"TENDSTR),
-          obj->objectId,obj->chunkId,
-          chunkIdOk ? "" : ",out of range",
-          chunkIsLive || !chunkIdOk ? "" : ",marked as deleted"));
-       }
-
-       if(chunkIdOk && chunkIsLive &&!yaffs_SkipNANDVerification(dev)) {
-               yaffs_ExtendedTags tags;
-               yaffs_ObjectHeader *oh;
-               __u8 *buffer = yaffs_GetTempBuffer(dev,__LINE__);
-
-               oh = (yaffs_ObjectHeader *)buffer;
-
-               yaffs_ReadChunkWithTagsFromNAND(dev, obj->chunkId,buffer, &tags);
-
-               yaffs_VerifyObjectHeader(obj,oh,&tags,1);
-
-               yaffs_ReleaseTempBuffer(dev,buffer,__LINE__);
-       }
-
-       /* Verify it has a parent */
-       if(obj && !obj->fake &&
-          (!obj->parent || obj->parent->myDev != dev)){
-          T(YAFFS_TRACE_VERIFY,
-          (TSTR("Obj %d has parent pointer %p which does not look like an object"TENDSTR),
-          obj->objectId,obj->parent));
-       }
-
-       /* Verify parent is a directory */
-       if(obj->parent && obj->parent->variantType != YAFFS_OBJECT_TYPE_DIRECTORY){
-          T(YAFFS_TRACE_VERIFY,
-          (TSTR("Obj %d's parent is not a directory (type %d)"TENDSTR),
-          obj->objectId,obj->parent->variantType));
-       }
-
-       switch(obj->variantType){
-       case YAFFS_OBJECT_TYPE_FILE:
-               yaffs_VerifyFile(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_SYMLINK:
-               yaffs_VerifySymlink(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_DIRECTORY:
-               yaffs_VerifyDirectory(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_HARDLINK:
-               yaffs_VerifyHardLink(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_SPECIAL:
-               yaffs_VerifySpecial(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_UNKNOWN:
-       default:
-               T(YAFFS_TRACE_VERIFY,
-               (TSTR("Obj %d has illegaltype %d"TENDSTR),
-               obj->objectId,obj->variantType));
-               break;
-       }
-
-
-}
-
-static void yaffs_VerifyObjects(yaffs_Device *dev)
-{
-       yaffs_Object *obj;
-       int i;
-       struct list_head *lh;
-
-       if(yaffs_SkipVerification(dev))
-               return;
-
-       /* Iterate through the objects in each hash entry */
-
-        for(i = 0; i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
-                       if (lh) {
-                               obj = list_entry(lh, yaffs_Object, hashLink);
-                               yaffs_VerifyObject(obj);
-                       }
-               }
-        }
-
-}
-
-
-/*
- *  Simple hash function. Needs to have a reasonable spread
- */
-
-static Y_INLINE int yaffs_HashFunction(int n)
-{
-       n = abs(n);
-       return (n % YAFFS_NOBJECT_BUCKETS);
-}
-
-/*
- * Access functions to useful fake objects
- */
-
-yaffs_Object *yaffs_Root(yaffs_Device * dev)
-{
-       return dev->rootDir;
-}
-
-yaffs_Object *yaffs_LostNFound(yaffs_Device * dev)
-{
-       return dev->lostNFoundDir;
-}
-
-
-/*
- *  Erased NAND checking functions
- */
-
-int yaffs_CheckFF(__u8 * buffer, int nBytes)
-{
-       /* Horrible, slow implementation */
-       while (nBytes--) {
-               if (*buffer != 0xFF)
-                       return 0;
-               buffer++;
-       }
-       return 1;
-}
-
-static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
-                                 int chunkInNAND)
-{
-
-       int retval = YAFFS_OK;
-       __u8 *data = yaffs_GetTempBuffer(dev, __LINE__);
-       yaffs_ExtendedTags tags;
-       int result;
-
-       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunkInNAND, data, &tags);
-
-       if(tags.eccResult > YAFFS_ECC_RESULT_NO_ERROR)
-               retval = YAFFS_FAIL;
-
-
-       if (!yaffs_CheckFF(data, dev->nDataBytesPerChunk) || tags.chunkUsed) {
-               T(YAFFS_TRACE_NANDACCESS,
-                 (TSTR("Chunk %d not erased" TENDSTR), chunkInNAND));
-               retval = YAFFS_FAIL;
-       }
-
-       yaffs_ReleaseTempBuffer(dev, data, __LINE__);
-
-       return retval;
-
-}
-
-
-static int yaffs_WriteNewChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
-                                            const __u8 * data,
-                                            yaffs_ExtendedTags * tags,
-                                            int useReserve)
-{
-       int attempts = 0;
-       int writeOk = 0;
-       int chunk;
-
-       yaffs_InvalidateCheckpoint(dev);
-
-       do {
-               yaffs_BlockInfo *bi = 0;
-               int erasedOk = 0;
-
-               chunk = yaffs_AllocateChunk(dev, useReserve, &bi);
-               if (chunk < 0) {
-                       /* no space */
-                       break;
-               }
-
-               /* First check this chunk is erased, if it needs
-                * checking.  The checking policy (unless forced
-                * always on) is as follows:
-                *
-                * Check the first page we try to write in a block.
-                * If the check passes then we don't need to check any
-                * more.        If the check fails, we check again...
-                * If the block has been erased, we don't need to check.
-                *
-                * However, if the block has been prioritised for gc,
-                * then we think there might be something odd about
-                * this block and stop using it.
-                *
-                * Rationale: We should only ever see chunks that have
-                * not been erased if there was a partially written
-                * chunk due to power loss.  This checking policy should
-                * catch that case with very few checks and thus save a
-                * lot of checks that are most likely not needed.
-                */
-               if (bi->gcPrioritise) {
-                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
-                       /* try another chunk */
-                       continue;
-               }
-
-               /* let's give it a try */
-               attempts++;
-
-#ifdef CONFIG_YAFFS_ALWAYS_CHECK_CHUNK_ERASED
-               bi->skipErasedCheck = 0;
-#endif
-               if (!bi->skipErasedCheck) {
-                       erasedOk = yaffs_CheckChunkErased(dev, chunk);
-                       if (erasedOk != YAFFS_OK) {
-                               T(YAFFS_TRACE_ERROR,
-                               (TSTR ("**>> yaffs chunk %d was not erased"
-                               TENDSTR), chunk));
-
-                               /* try another chunk */
-                               continue;
-                       }
-                       bi->skipErasedCheck = 1;
-               }
-
-               writeOk = yaffs_WriteChunkWithTagsToNAND(dev, chunk,
-                               data, tags);
-               if (writeOk != YAFFS_OK) {
-                       yaffs_HandleWriteChunkError(dev, chunk, erasedOk);
-                       /* try another chunk */
-                       continue;
-               }
-
-               /* Copy the data into the robustification buffer */
-               yaffs_HandleWriteChunkOk(dev, chunk, data, tags);
-
-       } while (writeOk != YAFFS_OK && attempts < yaffs_wr_attempts);
-
-       if (attempts > 1) {
-               T(YAFFS_TRACE_ERROR,
-                       (TSTR("**>> yaffs write required %d attempts" TENDSTR),
-                       attempts));
-
-               dev->nRetriedWrites += (attempts - 1);
-       }
-
-       return chunk;
-}
-
-/*
- * Block retiring for handling a broken block.
- */
-
-static void yaffs_RetireBlock(yaffs_Device * dev, int blockInNAND)
-{
-       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
-
-       yaffs_InvalidateCheckpoint(dev);
-
-       yaffs_MarkBlockBad(dev, blockInNAND);
-
-       bi->blockState = YAFFS_BLOCK_STATE_DEAD;
-       bi->gcPrioritise = 0;
-       bi->needsRetiring = 0;
-
-       dev->nRetiredBlocks++;
-}
-
-/*
- * Functions for robustisizing TODO
- *
- */
-
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_ExtendedTags * tags)
-{
-}
-
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_ExtendedTags * tags)
-{
-}
-
-void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi)
-{
-       if(!bi->gcPrioritise){
-               bi->gcPrioritise = 1;
-               dev->hasPendingPrioritisedGCs = 1;
-               bi->chunkErrorStrikes ++;
-
-               if(bi->chunkErrorStrikes > 3){
-                       bi->needsRetiring = 1; /* Too many stikes, so retire this */
-                       T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Block struck out" TENDSTR)));
-
-               }
-
-       }
-}
-
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND, int erasedOk)
-{
-
-       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
-       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockInNAND);
-
-       yaffs_HandleChunkError(dev,bi);
-
-
-       if(erasedOk ) {
-               /* Was an actual write failure, so mark the block for retirement  */
-               bi->needsRetiring = 1;
-               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("**>> Block %d needs retiring" TENDSTR), blockInNAND));
-
-
-       }
-
-       /* Delete the chunk */
-       yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
-}
-
-
-/*---------------- Name handling functions ------------*/
-
-static __u16 yaffs_CalcNameSum(const YCHAR * name)
-{
-       __u16 sum = 0;
-       __u16 i = 1;
-
-       YUCHAR *bname = (YUCHAR *) name;
-       if (bname) {
-               while ((*bname) && (i < (YAFFS_MAX_NAME_LENGTH/2))) {
-
-#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-                       sum += yaffs_toupper(*bname) * i;
-#else
-                       sum += (*bname) * i;
-#endif
-                       i++;
-                       bname++;
-               }
-       }
-       return sum;
-}
-
-static void yaffs_SetObjectName(yaffs_Object * obj, const YCHAR * name)
-{
-#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
-       if (name && yaffs_strlen(name) <= YAFFS_SHORT_NAME_LENGTH) {
-               yaffs_strcpy(obj->shortName, name);
-       } else {
-               obj->shortName[0] = _Y('\0');
-       }
-#endif
-       obj->sum = yaffs_CalcNameSum(name);
-}
-
-/*-------------------- TNODES -------------------
-
- * List of spare tnodes
- * The list is hooked together using the first pointer
- * in the tnode.
- */
-
-/* yaffs_CreateTnodes creates a bunch more tnodes and
- * adds them to the tnode free list.
- * Don't use this function directly
- */
-
-static int yaffs_CreateTnodes(yaffs_Device * dev, int nTnodes)
-{
-       int i;
-       int tnodeSize;
-       yaffs_Tnode *newTnodes;
-       __u8 *mem;
-       yaffs_Tnode *curr;
-       yaffs_Tnode *next;
-       yaffs_TnodeList *tnl;
-
-       if (nTnodes < 1)
-               return YAFFS_OK;
-
-       /* Calculate the tnode size in bytes for variable width tnode support.
-        * Must be a multiple of 32-bits  */
-       tnodeSize = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
-       /* make these things */
-
-       newTnodes = YMALLOC(nTnodes * tnodeSize);
-       mem = (__u8 *)newTnodes;
-
-       if (!newTnodes) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("yaffs: Could not allocate Tnodes" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       /* Hook them into the free list */
-#if 0
-       for (i = 0; i < nTnodes - 1; i++) {
-               newTnodes[i].internal[0] = &newTnodes[i + 1];
-#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
-               newTnodes[i].internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
-#endif
-       }
-
-       newTnodes[nTnodes - 1].internal[0] = dev->freeTnodes;
-#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
-       newTnodes[nTnodes - 1].internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
-#endif
-       dev->freeTnodes = newTnodes;
-#else
-       /* New hookup for wide tnodes */
-       for(i = 0; i < nTnodes -1; i++) {
-               curr = (yaffs_Tnode *) &mem[i * tnodeSize];
-               next = (yaffs_Tnode *) &mem[(i+1) * tnodeSize];
-               curr->internal[0] = next;
-       }
-
-       curr = (yaffs_Tnode *) &mem[(nTnodes - 1) * tnodeSize];
-       curr->internal[0] = dev->freeTnodes;
-       dev->freeTnodes = (yaffs_Tnode *)mem;
-
-#endif
-
-
-       dev->nFreeTnodes += nTnodes;
-       dev->nTnodesCreated += nTnodes;
-
-       /* Now add this bunch of tnodes to a list for freeing up.
-        * NB If we can't add this to the management list it isn't fatal
-        * but it just means we can't free this bunch of tnodes later.
-        */
-
-       tnl = YMALLOC(sizeof(yaffs_TnodeList));
-       if (!tnl) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("yaffs: Could not add tnodes to management list" TENDSTR)));
-                  return YAFFS_FAIL;
-
-       } else {
-               tnl->tnodes = newTnodes;
-               tnl->next = dev->allocatedTnodeList;
-               dev->allocatedTnodeList = tnl;
-       }
-
-       T(YAFFS_TRACE_ALLOCATE, (TSTR("yaffs: Tnodes added" TENDSTR)));
-
-       return YAFFS_OK;
-}
-
-/* GetTnode gets us a clean tnode. Tries to make allocate more if we run out */
-
-static yaffs_Tnode *yaffs_GetTnodeRaw(yaffs_Device * dev)
-{
-       yaffs_Tnode *tn = NULL;
-
-       /* If there are none left make more */
-       if (!dev->freeTnodes) {
-               yaffs_CreateTnodes(dev, YAFFS_ALLOCATION_NTNODES);
-       }
-
-       if (dev->freeTnodes) {
-               tn = dev->freeTnodes;
-#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
-               if (tn->internal[YAFFS_NTNODES_INTERNAL] != (void *)1) {
-                       /* Hoosterman, this thing looks like it isn't in the list */
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: Tnode list bug 1" TENDSTR)));
-               }
-#endif
-               dev->freeTnodes = dev->freeTnodes->internal[0];
-               dev->nFreeTnodes--;
-       }
-
-       return tn;
-}
-
-static yaffs_Tnode *yaffs_GetTnode(yaffs_Device * dev)
-{
-       yaffs_Tnode *tn = yaffs_GetTnodeRaw(dev);
-
-       if(tn)
-               memset(tn, 0, (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
-
-       return tn;
-}
-
-/* FreeTnode frees up a tnode and puts it back on the free list */
-static void yaffs_FreeTnode(yaffs_Device * dev, yaffs_Tnode * tn)
-{
-       if (tn) {
-#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
-               if (tn->internal[YAFFS_NTNODES_INTERNAL] != 0) {
-                       /* Hoosterman, this thing looks like it is already in the list */
-                       T(YAFFS_TRACE_ALWAYS,
-                         (TSTR("yaffs: Tnode list bug 2" TENDSTR)));
-               }
-               tn->internal[YAFFS_NTNODES_INTERNAL] = (void *)1;
-#endif
-               tn->internal[0] = dev->freeTnodes;
-               dev->freeTnodes = tn;
-               dev->nFreeTnodes++;
-       }
-}
-
-static void yaffs_DeinitialiseTnodes(yaffs_Device * dev)
-{
-       /* Free the list of allocated tnodes */
-       yaffs_TnodeList *tmp;
-
-       while (dev->allocatedTnodeList) {
-               tmp = dev->allocatedTnodeList->next;
-
-               YFREE(dev->allocatedTnodeList->tnodes);
-               YFREE(dev->allocatedTnodeList);
-               dev->allocatedTnodeList = tmp;
-
-       }
-
-       dev->freeTnodes = NULL;
-       dev->nFreeTnodes = 0;
-}
-
-static void yaffs_InitialiseTnodes(yaffs_Device * dev)
-{
-       dev->allocatedTnodeList = NULL;
-       dev->freeTnodes = NULL;
-       dev->nFreeTnodes = 0;
-       dev->nTnodesCreated = 0;
-
-}
-
-
-void yaffs_PutLevel0Tnode(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos, unsigned val)
-{
-  __u32 *map = (__u32 *)tn;
-  __u32 bitInMap;
-  __u32 bitInWord;
-  __u32 wordInMap;
-  __u32 mask;
-
-  pos &= YAFFS_TNODES_LEVEL0_MASK;
-  val >>= dev->chunkGroupBits;
-
-  bitInMap = pos * dev->tnodeWidth;
-  wordInMap = bitInMap /32;
-  bitInWord = bitInMap & (32 -1);
-
-  mask = dev->tnodeMask << bitInWord;
-
-  map[wordInMap] &= ~mask;
-  map[wordInMap] |= (mask & (val << bitInWord));
-
-  if(dev->tnodeWidth > (32-bitInWord)) {
-    bitInWord = (32 - bitInWord);
-    wordInMap++;;
-    mask = dev->tnodeMask >> (/*dev->tnodeWidth -*/ bitInWord);
-    map[wordInMap] &= ~mask;
-    map[wordInMap] |= (mask & (val >> bitInWord));
-  }
-}
-
-static __u32 yaffs_GetChunkGroupBase(yaffs_Device *dev, yaffs_Tnode *tn, unsigned pos)
-{
-  __u32 *map = (__u32 *)tn;
-  __u32 bitInMap;
-  __u32 bitInWord;
-  __u32 wordInMap;
-  __u32 val;
-
-  pos &= YAFFS_TNODES_LEVEL0_MASK;
-
-  bitInMap = pos * dev->tnodeWidth;
-  wordInMap = bitInMap /32;
-  bitInWord = bitInMap & (32 -1);
-
-  val = map[wordInMap] >> bitInWord;
-
-  if(dev->tnodeWidth > (32-bitInWord)) {
-    bitInWord = (32 - bitInWord);
-    wordInMap++;;
-    val |= (map[wordInMap] << bitInWord);
-  }
-
-  val &= dev->tnodeMask;
-  val <<= dev->chunkGroupBits;
-
-  return val;
-}
-
-/* ------------------- End of individual tnode manipulation -----------------*/
-
-/* ---------Functions to manipulate the look-up tree (made up of tnodes) ------
- * The look up tree is represented by the top tnode and the number of topLevel
- * in the tree. 0 means only the level 0 tnode is in the tree.
- */
-
-/* FindLevel0Tnode finds the level 0 tnode, if one exists. */
-static yaffs_Tnode *yaffs_FindLevel0Tnode(yaffs_Device * dev,
-                                         yaffs_FileStructure * fStruct,
-                                         __u32 chunkId)
-{
-
-       yaffs_Tnode *tn = fStruct->top;
-       __u32 i;
-       int requiredTallness;
-       int level = fStruct->topLevel;
-
-       /* Check sane level and chunk Id */
-       if (level < 0 || level > YAFFS_TNODES_MAX_LEVEL) {
-               return NULL;
-       }
-
-       if (chunkId > YAFFS_MAX_CHUNK_ID) {
-               return NULL;
-       }
-
-       /* First check we're tall enough (ie enough topLevel) */
-
-       i = chunkId >> YAFFS_TNODES_LEVEL0_BITS;
-       requiredTallness = 0;
-       while (i) {
-               i >>= YAFFS_TNODES_INTERNAL_BITS;
-               requiredTallness++;
-       }
-
-       if (requiredTallness > fStruct->topLevel) {
-               /* Not tall enough, so we can't find it, return NULL. */
-               return NULL;
-       }
-
-       /* Traverse down to level 0 */
-       while (level > 0 && tn) {
-               tn = tn->
-                   internal[(chunkId >>
-                              ( YAFFS_TNODES_LEVEL0_BITS +
-                                (level - 1) *
-                                YAFFS_TNODES_INTERNAL_BITS)
-                             ) &
-                            YAFFS_TNODES_INTERNAL_MASK];
-               level--;
-
-       }
-
-       return tn;
-}
-
-/* AddOrFindLevel0Tnode finds the level 0 tnode if it exists, otherwise first expands the tree.
- * This happens in two steps:
- *  1. If the tree isn't tall enough, then make it taller.
- *  2. Scan down the tree towards the level 0 tnode adding tnodes if required.
- *
- * Used when modifying the tree.
- *
- *  If the tn argument is NULL, then a fresh tnode will be added otherwise the specified tn will
- *  be plugged into the ttree.
- */
-
-static yaffs_Tnode *yaffs_AddOrFindLevel0Tnode(yaffs_Device * dev,
-                                              yaffs_FileStructure * fStruct,
-                                              __u32 chunkId,
-                                              yaffs_Tnode *passedTn)
-{
-
-       int requiredTallness;
-       int i;
-       int l;
-       yaffs_Tnode *tn;
-
-       __u32 x;
-
-
-       /* Check sane level and page Id */
-       if (fStruct->topLevel < 0 || fStruct->topLevel > YAFFS_TNODES_MAX_LEVEL) {
-               return NULL;
-       }
-
-       if (chunkId > YAFFS_MAX_CHUNK_ID) {
-               return NULL;
-       }
-
-       /* First check we're tall enough (ie enough topLevel) */
-
-       x = chunkId >> YAFFS_TNODES_LEVEL0_BITS;
-       requiredTallness = 0;
-       while (x) {
-               x >>= YAFFS_TNODES_INTERNAL_BITS;
-               requiredTallness++;
-       }
-
-
-       if (requiredTallness > fStruct->topLevel) {
-               /* Not tall enough,gotta make the tree taller */
-               for (i = fStruct->topLevel; i < requiredTallness; i++) {
-
-                       tn = yaffs_GetTnode(dev);
-
-                       if (tn) {
-                               tn->internal[0] = fStruct->top;
-                               fStruct->top = tn;
-                       } else {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR("yaffs: no more tnodes" TENDSTR)));
-                       }
-               }
-
-               fStruct->topLevel = requiredTallness;
-       }
-
-       /* Traverse down to level 0, adding anything we need */
-
-       l = fStruct->topLevel;
-       tn = fStruct->top;
-
-       if(l > 0) {
-               while (l > 0 && tn) {
-                       x = (chunkId >>
-                            ( YAFFS_TNODES_LEVEL0_BITS +
-                             (l - 1) * YAFFS_TNODES_INTERNAL_BITS)) &
-                           YAFFS_TNODES_INTERNAL_MASK;
-
-
-                       if((l>1) && !tn->internal[x]){
-                               /* Add missing non-level-zero tnode */
-                               tn->internal[x] = yaffs_GetTnode(dev);
-
-                       } else if(l == 1) {
-                               /* Looking from level 1 at level 0 */
-                               if (passedTn) {
-                                       /* If we already have one, then release it.*/
-                                       if(tn->internal[x])
-                                               yaffs_FreeTnode(dev,tn->internal[x]);
-                                       tn->internal[x] = passedTn;
-
-                               } else if(!tn->internal[x]) {
-                                       /* Don't have one, none passed in */
-                                       tn->internal[x] = yaffs_GetTnode(dev);
-                               }
-                       }
-
-                       tn = tn->internal[x];
-                       l--;
-               }
-       } else {
-               /* top is level 0 */
-               if(passedTn) {
-                       memcpy(tn,passedTn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
-                       yaffs_FreeTnode(dev,passedTn);
-               }
-       }
-
-       return tn;
-}
-
-static int yaffs_FindChunkInGroup(yaffs_Device * dev, int theChunk,
-                                 yaffs_ExtendedTags * tags, int objectId,
-                                 int chunkInInode)
-{
-       int j;
-
-       for (j = 0; theChunk && j < dev->chunkGroupSize; j++) {
-               if (yaffs_CheckChunkBit
-                   (dev, theChunk / dev->nChunksPerBlock,
-                    theChunk % dev->nChunksPerBlock)) {
-                       yaffs_ReadChunkWithTagsFromNAND(dev, theChunk, NULL,
-                                                       tags);
-                       if (yaffs_TagsMatch(tags, objectId, chunkInInode)) {
-                               /* found it; */
-                               return theChunk;
-
-                       }
-               }
-               theChunk++;
-       }
-       return -1;
-}
-
-
-/* DeleteWorker scans backwards through the tnode tree and deletes all the
- * chunks and tnodes in the file
- * Returns 1 if the tree was deleted.
- * Returns 0 if it stopped early due to hitting the limit and the delete is incomplete.
- */
-
-static int yaffs_DeleteWorker(yaffs_Object * in, yaffs_Tnode * tn, __u32 level,
-                             int chunkOffset, int *limit)
-{
-       int i;
-       int chunkInInode;
-       int theChunk;
-       yaffs_ExtendedTags tags;
-       int foundChunk;
-       yaffs_Device *dev = in->myDev;
-
-       int allDone = 1;
-
-       if (tn) {
-               if (level > 0) {
-
-                       for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
-                            i--) {
-                               if (tn->internal[i]) {
-                                       if (limit && (*limit) < 0) {
-                                               allDone = 0;
-                                       } else {
-                                               allDone =
-                                                   yaffs_DeleteWorker(in,
-                                                                      tn->
-                                                                      internal
-                                                                      [i],
-                                                                      level -
-                                                                      1,
-                                                                      (chunkOffset
-                                                                       <<
-                                                                       YAFFS_TNODES_INTERNAL_BITS)
-                                                                      + i,
-                                                                      limit);
-                                       }
-                                       if (allDone) {
-                                               yaffs_FreeTnode(dev,
-                                                               tn->
-                                                               internal[i]);
-                                               tn->internal[i] = NULL;
-                                       }
-                               }
-
-                       }
-                       return (allDone) ? 1 : 0;
-               } else if (level == 0) {
-                       int hitLimit = 0;
-
-                       for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0 && !hitLimit;
-                            i--) {
-                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                               if (theChunk) {
-
-                                       chunkInInode =
-                                           (chunkOffset <<
-                                            YAFFS_TNODES_LEVEL0_BITS) + i;
-
-                                       foundChunk =
-                                           yaffs_FindChunkInGroup(dev,
-                                                                  theChunk,
-                                                                  &tags,
-                                                                  in->objectId,
-                                                                  chunkInInode);
-
-                                       if (foundChunk > 0) {
-                                               yaffs_DeleteChunk(dev,
-                                                                 foundChunk, 1,
-                                                                 __LINE__);
-                                               in->nDataChunks--;
-                                               if (limit) {
-                                                       *limit = *limit - 1;
-                                                       if (*limit <= 0) {
-                                                               hitLimit = 1;
-                                                       }
-                                               }
-
-                                       }
-
-                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
-                               }
-
-                       }
-                       return (i < 0) ? 1 : 0;
-
-               }
-
-       }
-
-       return 1;
-
-}
-
-static void yaffs_SoftDeleteChunk(yaffs_Device * dev, int chunk)
-{
-
-       yaffs_BlockInfo *theBlock;
-
-       T(YAFFS_TRACE_DELETION, (TSTR("soft delete chunk %d" TENDSTR), chunk));
-
-       theBlock = yaffs_GetBlockInfo(dev, chunk / dev->nChunksPerBlock);
-       if (theBlock) {
-               theBlock->softDeletions++;
-               dev->nFreeChunks++;
-       }
-}
-
-/* SoftDeleteWorker scans backwards through the tnode tree and soft deletes all the chunks in the file.
- * All soft deleting does is increment the block's softdelete count and pulls the chunk out
- * of the tnode.
- * Thus, essentially this is the same as DeleteWorker except that the chunks are soft deleted.
- */
-
-static int yaffs_SoftDeleteWorker(yaffs_Object * in, yaffs_Tnode * tn,
-                                 __u32 level, int chunkOffset)
-{
-       int i;
-       int theChunk;
-       int allDone = 1;
-       yaffs_Device *dev = in->myDev;
-
-       if (tn) {
-               if (level > 0) {
-
-                       for (i = YAFFS_NTNODES_INTERNAL - 1; allDone && i >= 0;
-                            i--) {
-                               if (tn->internal[i]) {
-                                       allDone =
-                                           yaffs_SoftDeleteWorker(in,
-                                                                  tn->
-                                                                  internal[i],
-                                                                  level - 1,
-                                                                  (chunkOffset
-                                                                   <<
-                                                                   YAFFS_TNODES_INTERNAL_BITS)
-                                                                  + i);
-                                       if (allDone) {
-                                               yaffs_FreeTnode(dev,
-                                                               tn->
-                                                               internal[i]);
-                                               tn->internal[i] = NULL;
-                                       } else {
-                                               /* Hoosterman... how could this happen? */
-                                       }
-                               }
-                       }
-                       return (allDone) ? 1 : 0;
-               } else if (level == 0) {
-
-                       for (i = YAFFS_NTNODES_LEVEL0 - 1; i >= 0; i--) {
-                               theChunk = yaffs_GetChunkGroupBase(dev,tn,i);
-                               if (theChunk) {
-                                       /* Note this does not find the real chunk, only the chunk group.
-                                        * We make an assumption that a chunk group is not larger than
-                                        * a block.
-                                        */
-                                       yaffs_SoftDeleteChunk(dev, theChunk);
-                                       yaffs_PutLevel0Tnode(dev,tn,i,0);
-                               }
-
-                       }
-                       return 1;
-
-               }
-
-       }
-
-       return 1;
-
-}
-
-static void yaffs_SoftDeleteFile(yaffs_Object * obj)
-{
-       if (obj->deleted &&
-           obj->variantType == YAFFS_OBJECT_TYPE_FILE && !obj->softDeleted) {
-               if (obj->nDataChunks <= 0) {
-                       /* Empty file with no duplicate object headers, just delete it immediately */
-                       yaffs_FreeTnode(obj->myDev,
-                                       obj->variant.fileVariant.top);
-                       obj->variant.fileVariant.top = NULL;
-                       T(YAFFS_TRACE_TRACING,
-                         (TSTR("yaffs: Deleting empty file %d" TENDSTR),
-                          obj->objectId));
-                       yaffs_DoGenericObjectDeletion(obj);
-               } else {
-                       yaffs_SoftDeleteWorker(obj,
-                                              obj->variant.fileVariant.top,
-                                              obj->variant.fileVariant.
-                                              topLevel, 0);
-                       obj->softDeleted = 1;
-               }
-       }
-}
-
-/* Pruning removes any part of the file structure tree that is beyond the
- * bounds of the file (ie that does not point to chunks).
- *
- * A file should only get pruned when its size is reduced.
- *
- * Before pruning, the chunks must be pulled from the tree and the
- * level 0 tnode entries must be zeroed out.
- * Could also use this for file deletion, but that's probably better handled
- * by a special case.
- */
-
-static yaffs_Tnode *yaffs_PruneWorker(yaffs_Device * dev, yaffs_Tnode * tn,
-                                     __u32 level, int del0)
-{
-       int i;
-       int hasData;
-
-       if (tn) {
-               hasData = 0;
-
-               for (i = 0; i < YAFFS_NTNODES_INTERNAL; i++) {
-                       if (tn->internal[i] && level > 0) {
-                               tn->internal[i] =
-                                   yaffs_PruneWorker(dev, tn->internal[i],
-                                                     level - 1,
-                                                     (i == 0) ? del0 : 1);
-                       }
-
-                       if (tn->internal[i]) {
-                               hasData++;
-                       }
-               }
-
-               if (hasData == 0 && del0) {
-                       /* Free and return NULL */
-
-                       yaffs_FreeTnode(dev, tn);
-                       tn = NULL;
-               }
-
-       }
-
-       return tn;
-
-}
-
-static int yaffs_PruneFileStructure(yaffs_Device * dev,
-                                   yaffs_FileStructure * fStruct)
-{
-       int i;
-       int hasData;
-       int done = 0;
-       yaffs_Tnode *tn;
-
-       if (fStruct->topLevel > 0) {
-               fStruct->top =
-                   yaffs_PruneWorker(dev, fStruct->top, fStruct->topLevel, 0);
-
-               /* Now we have a tree with all the non-zero branches NULL but the height
-                * is the same as it was.
-                * Let's see if we can trim internal tnodes to shorten the tree.
-                * We can do this if only the 0th element in the tnode is in use
-                * (ie all the non-zero are NULL)
-                */
-
-               while (fStruct->topLevel && !done) {
-                       tn = fStruct->top;
-
-                       hasData = 0;
-                       for (i = 1; i < YAFFS_NTNODES_INTERNAL; i++) {
-                               if (tn->internal[i]) {
-                                       hasData++;
-                               }
-                       }
-
-                       if (!hasData) {
-                               fStruct->top = tn->internal[0];
-                               fStruct->topLevel--;
-                               yaffs_FreeTnode(dev, tn);
-                       } else {
-                               done = 1;
-                       }
-               }
-       }
-
-       return YAFFS_OK;
-}
-
-/*-------------------- End of File Structure functions.-------------------*/
-
-/* yaffs_CreateFreeObjects creates a bunch more objects and
- * adds them to the object free list.
- */
-static int yaffs_CreateFreeObjects(yaffs_Device * dev, int nObjects)
-{
-       int i;
-       yaffs_Object *newObjects;
-       yaffs_ObjectList *list;
-
-       if (nObjects < 1)
-               return YAFFS_OK;
-
-       /* make these things */
-       newObjects = YMALLOC(nObjects * sizeof(yaffs_Object));
-       list = YMALLOC(sizeof(yaffs_ObjectList));
-
-       if (!newObjects || !list) {
-               if(newObjects)
-                       YFREE(newObjects);
-               if(list)
-                       YFREE(list);
-               T(YAFFS_TRACE_ALLOCATE,
-                 (TSTR("yaffs: Could not allocate more objects" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       /* Hook them into the free list */
-       for (i = 0; i < nObjects - 1; i++) {
-               newObjects[i].siblings.next =
-                   (struct list_head *)(&newObjects[i + 1]);
-       }
-
-       newObjects[nObjects - 1].siblings.next = (void *)dev->freeObjects;
-       dev->freeObjects = newObjects;
-       dev->nFreeObjects += nObjects;
-       dev->nObjectsCreated += nObjects;
-
-       /* Now add this bunch of Objects to a list for freeing up. */
-
-       list->objects = newObjects;
-       list->next = dev->allocatedObjectList;
-       dev->allocatedObjectList = list;
-
-       return YAFFS_OK;
-}
-
-
-/* AllocateEmptyObject gets us a clean Object. Tries to make allocate more if we run out */
-static yaffs_Object *yaffs_AllocateEmptyObject(yaffs_Device * dev)
-{
-       yaffs_Object *tn = NULL;
-
-       /* If there are none left make more */
-       if (!dev->freeObjects) {
-               yaffs_CreateFreeObjects(dev, YAFFS_ALLOCATION_NOBJECTS);
-       }
-
-       if (dev->freeObjects) {
-               tn = dev->freeObjects;
-               dev->freeObjects =
-                   (yaffs_Object *) (dev->freeObjects->siblings.next);
-               dev->nFreeObjects--;
-
-               /* Now sweeten it up... */
-
-               memset(tn, 0, sizeof(yaffs_Object));
-               tn->myDev = dev;
-               tn->chunkId = -1;
-               tn->variantType = YAFFS_OBJECT_TYPE_UNKNOWN;
-               INIT_LIST_HEAD(&(tn->hardLinks));
-               INIT_LIST_HEAD(&(tn->hashLink));
-               INIT_LIST_HEAD(&tn->siblings);
-
-               /* Add it to the lost and found directory.
-                * NB Can't put root or lostNFound in lostNFound so
-                * check if lostNFound exists first
-                */
-               if (dev->lostNFoundDir) {
-                       yaffs_AddObjectToDirectory(dev->lostNFoundDir, tn);
-               }
-       }
-
-       return tn;
-}
-
-static yaffs_Object *yaffs_CreateFakeDirectory(yaffs_Device * dev, int number,
-                                              __u32 mode)
-{
-
-       yaffs_Object *obj =
-           yaffs_CreateNewObject(dev, number, YAFFS_OBJECT_TYPE_DIRECTORY);
-       if (obj) {
-               obj->fake = 1;          /* it is fake so it has no NAND presence... */
-               obj->renameAllowed = 0; /* ... and we're not allowed to rename it... */
-               obj->unlinkAllowed = 0; /* ... or unlink it */
-               obj->deleted = 0;
-               obj->unlinked = 0;
-               obj->yst_mode = mode;
-               obj->myDev = dev;
-               obj->chunkId = 0;       /* Not a valid chunk. */
-       }
-
-       return obj;
-
-}
-
-static void yaffs_UnhashObject(yaffs_Object * tn)
-{
-       int bucket;
-       yaffs_Device *dev = tn->myDev;
-
-       /* If it is still linked into the bucket list, free from the list */
-       if (!list_empty(&tn->hashLink)) {
-               list_del_init(&tn->hashLink);
-               bucket = yaffs_HashFunction(tn->objectId);
-               dev->objectBucket[bucket].count--;
-       }
-
-}
-
-/*  FreeObject frees up a Object and puts it back on the free list */
-static void yaffs_FreeObject(yaffs_Object * tn)
-{
-
-       yaffs_Device *dev = tn->myDev;
-
-#ifdef  __KERNEL__
-       if (tn->myInode) {
-               /* We're still hooked up to a cached inode.
-                * Don't delete now, but mark for later deletion
-                */
-               tn->deferedFree = 1;
-               return;
-       }
-#endif
-
-       yaffs_UnhashObject(tn);
-
-       /* Link into the free list. */
-       tn->siblings.next = (struct list_head *)(dev->freeObjects);
-       dev->freeObjects = tn;
-       dev->nFreeObjects++;
-}
-
-#ifdef __KERNEL__
-
-void yaffs_HandleDeferedFree(yaffs_Object * obj)
-{
-       if (obj->deferedFree) {
-               yaffs_FreeObject(obj);
-       }
-}
-
-#endif
-
-static void yaffs_DeinitialiseObjects(yaffs_Device * dev)
-{
-       /* Free the list of allocated Objects */
-
-       yaffs_ObjectList *tmp;
-
-       while (dev->allocatedObjectList) {
-               tmp = dev->allocatedObjectList->next;
-               YFREE(dev->allocatedObjectList->objects);
-               YFREE(dev->allocatedObjectList);
-
-               dev->allocatedObjectList = tmp;
-       }
-
-       dev->freeObjects = NULL;
-       dev->nFreeObjects = 0;
-}
-
-static void yaffs_InitialiseObjects(yaffs_Device * dev)
-{
-       int i;
-
-       dev->allocatedObjectList = NULL;
-       dev->freeObjects = NULL;
-       dev->nFreeObjects = 0;
-
-       for (i = 0; i < YAFFS_NOBJECT_BUCKETS; i++) {
-               INIT_LIST_HEAD(&dev->objectBucket[i].list);
-               dev->objectBucket[i].count = 0;
-       }
-
-}
-
-static int yaffs_FindNiceObjectBucket(yaffs_Device * dev)
-{
-       static int x = 0;
-       int i;
-       int l = 999;
-       int lowest = 999999;
-
-       /* First let's see if we can find one that's empty. */
-
-       for (i = 0; i < 10 && lowest > 0; i++) {
-               x++;
-               x %= YAFFS_NOBJECT_BUCKETS;
-               if (dev->objectBucket[x].count < lowest) {
-                       lowest = dev->objectBucket[x].count;
-                       l = x;
-               }
-
-       }
-
-       /* If we didn't find an empty list, then try
-        * looking a bit further for a short one
-        */
-
-       for (i = 0; i < 10 && lowest > 3; i++) {
-               x++;
-               x %= YAFFS_NOBJECT_BUCKETS;
-               if (dev->objectBucket[x].count < lowest) {
-                       lowest = dev->objectBucket[x].count;
-                       l = x;
-               }
-
-       }
-
-       return l;
-}
-
-static int yaffs_CreateNewObjectNumber(yaffs_Device * dev)
-{
-       int bucket = yaffs_FindNiceObjectBucket(dev);
-
-       /* Now find an object value that has not already been taken
-        * by scanning the list.
-        */
-
-       int found = 0;
-       struct list_head *i;
-
-       __u32 n = (__u32) bucket;
-
-       /* yaffs_CheckObjectHashSanity();  */
-
-       while (!found) {
-               found = 1;
-               n += YAFFS_NOBJECT_BUCKETS;
-               if (1 || dev->objectBucket[bucket].count > 0) {
-                       list_for_each(i, &dev->objectBucket[bucket].list) {
-                               /* If there is already one in the list */
-                               if (i
-                                   && list_entry(i, yaffs_Object,
-                                                 hashLink)->objectId == n) {
-                                       found = 0;
-                               }
-                       }
-               }
-       }
-
-
-       return n;
-}
-
-static void yaffs_HashObject(yaffs_Object * in)
-{
-       int bucket = yaffs_HashFunction(in->objectId);
-       yaffs_Device *dev = in->myDev;
-
-       list_add(&in->hashLink, &dev->objectBucket[bucket].list);
-       dev->objectBucket[bucket].count++;
-
-}
-
-yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number)
-{
-       int bucket = yaffs_HashFunction(number);
-       struct list_head *i;
-       yaffs_Object *in;
-
-       list_for_each(i, &dev->objectBucket[bucket].list) {
-               /* Look if it is in the list */
-               if (i) {
-                       in = list_entry(i, yaffs_Object, hashLink);
-                       if (in->objectId == number) {
-#ifdef __KERNEL__
-                               /* Don't tell the VFS about this one if it is defered free */
-                               if (in->deferedFree)
-                                       return NULL;
-#endif
-
-                               return in;
-                       }
-               }
-       }
-
-       return NULL;
-}
-
-yaffs_Object *yaffs_CreateNewObject(yaffs_Device * dev, int number,
-                                   yaffs_ObjectType type)
-{
-
-       yaffs_Object *theObject;
-       yaffs_Tnode *tn;
-
-       if (number < 0) {
-               number = yaffs_CreateNewObjectNumber(dev);
-       }
-
-       theObject = yaffs_AllocateEmptyObject(dev);
-       if(!theObject)
-               return NULL;
-
-       if(type == YAFFS_OBJECT_TYPE_FILE){
-               tn = yaffs_GetTnode(dev);
-               if(!tn){
-                       yaffs_FreeObject(theObject);
-                       return NULL;
-               }
-       }
-
-
-
-       if (theObject) {
-               theObject->fake = 0;
-               theObject->renameAllowed = 1;
-               theObject->unlinkAllowed = 1;
-               theObject->objectId = number;
-               yaffs_HashObject(theObject);
-               theObject->variantType = type;
-#ifdef CONFIG_YAFFS_WINCE
-               yfsd_WinFileTimeNow(theObject->win_atime);
-               theObject->win_ctime[0] = theObject->win_mtime[0] =
-                   theObject->win_atime[0];
-               theObject->win_ctime[1] = theObject->win_mtime[1] =
-                   theObject->win_atime[1];
-
-#else
-
-               theObject->yst_atime = theObject->yst_mtime =
-                   theObject->yst_ctime = Y_CURRENT_TIME;
-#endif
-               switch (type) {
-               case YAFFS_OBJECT_TYPE_FILE:
-                       theObject->variant.fileVariant.fileSize = 0;
-                       theObject->variant.fileVariant.scannedFileSize = 0;
-                       theObject->variant.fileVariant.shrinkSize = 0xFFFFFFFF; /* max __u32 */
-                       theObject->variant.fileVariant.topLevel = 0;
-                       theObject->variant.fileVariant.top = tn;
-                       break;
-               case YAFFS_OBJECT_TYPE_DIRECTORY:
-                       INIT_LIST_HEAD(&theObject->variant.directoryVariant.
-                                      children);
-                       break;
-               case YAFFS_OBJECT_TYPE_SYMLINK:
-               case YAFFS_OBJECT_TYPE_HARDLINK:
-               case YAFFS_OBJECT_TYPE_SPECIAL:
-                       /* No action required */
-                       break;
-               case YAFFS_OBJECT_TYPE_UNKNOWN:
-                       /* todo this should not happen */
-                       break;
-               }
-       }
-
-       return theObject;
-}
-
-static yaffs_Object *yaffs_FindOrCreateObjectByNumber(yaffs_Device * dev,
-                                                     int number,
-                                                     yaffs_ObjectType type)
-{
-       yaffs_Object *theObject = NULL;
-
-       if (number > 0) {
-               theObject = yaffs_FindObjectByNumber(dev, number);
-       }
-
-       if (!theObject) {
-               theObject = yaffs_CreateNewObject(dev, number, type);
-       }
-
-       return theObject;
-
-}
-
-
-static YCHAR *yaffs_CloneString(const YCHAR * str)
-{
-       YCHAR *newStr = NULL;
-
-       if (str && *str) {
-               newStr = YMALLOC((yaffs_strlen(str) + 1) * sizeof(YCHAR));
-               if(newStr)
-                       yaffs_strcpy(newStr, str);
-       }
-
-       return newStr;
-
-}
-
-/*
- * Mknod (create) a new object.
- * equivalentObject only has meaning for a hard link;
- * aliasString only has meaning for a sumlink.
- * rdev only has meaning for devices (a subset of special objects)
- */
-
-static yaffs_Object *yaffs_MknodObject(yaffs_ObjectType type,
-                                      yaffs_Object * parent,
-                                      const YCHAR * name,
-                                      __u32 mode,
-                                      __u32 uid,
-                                      __u32 gid,
-                                      yaffs_Object * equivalentObject,
-                                      const YCHAR * aliasString, __u32 rdev)
-{
-       yaffs_Object *in;
-       YCHAR *str;
-
-       yaffs_Device *dev = parent->myDev;
-
-       /* Check if the entry exists. If it does then fail the call since we don't want a dup.*/
-       if (yaffs_FindObjectByName(parent, name)) {
-               return NULL;
-       }
-
-       in = yaffs_CreateNewObject(dev, -1, type);
-
-       if(type == YAFFS_OBJECT_TYPE_SYMLINK){
-               str = yaffs_CloneString(aliasString);
-               if(!str){
-                       yaffs_FreeObject(in);
-                       return NULL;
-               }
-       }
-
-
-
-       if (in) {
-               in->chunkId = -1;
-               in->valid = 1;
-               in->variantType = type;
-
-               in->yst_mode = mode;
-
-#ifdef CONFIG_YAFFS_WINCE
-               yfsd_WinFileTimeNow(in->win_atime);
-               in->win_ctime[0] = in->win_mtime[0] = in->win_atime[0];
-               in->win_ctime[1] = in->win_mtime[1] = in->win_atime[1];
-
-#else
-               in->yst_atime = in->yst_mtime = in->yst_ctime = Y_CURRENT_TIME;
-
-               in->yst_rdev = rdev;
-               in->yst_uid = uid;
-               in->yst_gid = gid;
-#endif
-               in->nDataChunks = 0;
-
-               yaffs_SetObjectName(in, name);
-               in->dirty = 1;
-
-               yaffs_AddObjectToDirectory(parent, in);
-
-               in->myDev = parent->myDev;
-
-               switch (type) {
-               case YAFFS_OBJECT_TYPE_SYMLINK:
-                       in->variant.symLinkVariant.alias = str;
-                       break;
-               case YAFFS_OBJECT_TYPE_HARDLINK:
-                       in->variant.hardLinkVariant.equivalentObject =
-                           equivalentObject;
-                       in->variant.hardLinkVariant.equivalentObjectId =
-                           equivalentObject->objectId;
-                       list_add(&in->hardLinks, &equivalentObject->hardLinks);
-                       break;
-               case YAFFS_OBJECT_TYPE_FILE:
-               case YAFFS_OBJECT_TYPE_DIRECTORY:
-               case YAFFS_OBJECT_TYPE_SPECIAL:
-               case YAFFS_OBJECT_TYPE_UNKNOWN:
-                       /* do nothing */
-                       break;
-               }
-
-               if (yaffs_UpdateObjectHeader(in, name, 0, 0, 0) < 0) {
-                       /* Could not create the object header, fail the creation */
-                       yaffs_DestroyObject(in);
-                       in = NULL;
-               }
-
-       }
-
-       return in;
-}
-
-yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
-                             __u32 mode, __u32 uid, __u32 gid)
-{
-       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_FILE, parent, name, mode,
-                                uid, gid, NULL, NULL, 0);
-}
-
-yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
-                                  __u32 mode, __u32 uid, __u32 gid)
-{
-       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_DIRECTORY, parent, name,
-                                mode, uid, gid, NULL, NULL, 0);
-}
-
-yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
-                                __u32 mode, __u32 uid, __u32 gid, __u32 rdev)
-{
-       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SPECIAL, parent, name, mode,
-                                uid, gid, NULL, NULL, rdev);
-}
-
-yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
-                                __u32 mode, __u32 uid, __u32 gid,
-                                const YCHAR * alias)
-{
-       return yaffs_MknodObject(YAFFS_OBJECT_TYPE_SYMLINK, parent, name, mode,
-                                uid, gid, NULL, alias, 0);
-}
-
-/* yaffs_Link returns the object id of the equivalent object.*/
-yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
-                        yaffs_Object * equivalentObject)
-{
-       /* Get the real object in case we were fed a hard link as an equivalent object */
-       equivalentObject = yaffs_GetEquivalentObject(equivalentObject);
-
-       if (yaffs_MknodObject
-           (YAFFS_OBJECT_TYPE_HARDLINK, parent, name, 0, 0, 0,
-            equivalentObject, NULL, 0)) {
-               return equivalentObject;
-       } else {
-               return NULL;
-       }
-
-}
-
-static int yaffs_ChangeObjectName(yaffs_Object * obj, yaffs_Object * newDir,
-                                 const YCHAR * newName, int force, int shadows)
-{
-       int unlinkOp;
-       int deleteOp;
-
-       yaffs_Object *existingTarget;
-
-       if (newDir == NULL) {
-               newDir = obj->parent;   /* use the old directory */
-       }
-
-       if (newDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragendy: yaffs_ChangeObjectName: newDir is not a directory"
-                   TENDSTR)));
-               YBUG();
-       }
-
-       /* TODO: Do we need this different handling for YAFFS2 and YAFFS1?? */
-       if (obj->myDev->isYaffs2) {
-               unlinkOp = (newDir == obj->myDev->unlinkedDir);
-       } else {
-               unlinkOp = (newDir == obj->myDev->unlinkedDir
-                           && obj->variantType == YAFFS_OBJECT_TYPE_FILE);
-       }
-
-       deleteOp = (newDir == obj->myDev->deletedDir);
-
-       existingTarget = yaffs_FindObjectByName(newDir, newName);
-
-       /* If the object is a file going into the unlinked directory,
-        *   then it is OK to just stuff it in since duplicate names are allowed.
-        *   else only proceed if the new name does not exist and if we're putting
-        *   it into a directory.
-        */
-       if ((unlinkOp ||
-            deleteOp ||
-            force ||
-            (shadows > 0) ||
-            !existingTarget) &&
-           newDir->variantType == YAFFS_OBJECT_TYPE_DIRECTORY) {
-               yaffs_SetObjectName(obj, newName);
-               obj->dirty = 1;
-
-               yaffs_AddObjectToDirectory(newDir, obj);
-
-               if (unlinkOp)
-                       obj->unlinked = 1;
-
-               /* If it is a deletion then we mark it as a shrink for gc purposes. */
-               if (yaffs_UpdateObjectHeader(obj, newName, 0, deleteOp, shadows)>= 0)
-                       return YAFFS_OK;
-       }
-
-       return YAFFS_FAIL;
-}
-
-int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
-                      yaffs_Object * newDir, const YCHAR * newName)
-{
-       yaffs_Object *obj;
-       yaffs_Object *existingTarget;
-       int force = 0;
-
-#ifdef CONFIG_YAFFS_CASE_INSENSITIVE
-       /* Special case for case insemsitive systems (eg. WinCE).
-        * While look-up is case insensitive, the name isn't.
-        * Therefore we might want to change x.txt to X.txt
-       */
-       if (oldDir == newDir && yaffs_strcmp(oldName, newName) == 0) {
-               force = 1;
-       }
-#endif
-
-       obj = yaffs_FindObjectByName(oldDir, oldName);
-       /* Check new name to long. */
-       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK &&
-           yaffs_strlen(newName) > YAFFS_MAX_ALIAS_LENGTH)
-         /* ENAMETOOLONG */
-         return YAFFS_FAIL;
-       else if (obj->variantType != YAFFS_OBJECT_TYPE_SYMLINK &&
-                yaffs_strlen(newName) > YAFFS_MAX_NAME_LENGTH)
-         /* ENAMETOOLONG */
-         return YAFFS_FAIL;
-
-       if (obj && obj->renameAllowed) {
-
-               /* Now do the handling for an existing target, if there is one */
-
-               existingTarget = yaffs_FindObjectByName(newDir, newName);
-               if (existingTarget &&
-                   existingTarget->variantType == YAFFS_OBJECT_TYPE_DIRECTORY &&
-                   !list_empty(&existingTarget->variant.directoryVariant.children)) {
-                       /* There is a target that is a non-empty directory, so we fail */
-                       return YAFFS_FAIL;      /* EEXIST or ENOTEMPTY */
-               } else if (existingTarget && existingTarget != obj) {
-                       /* Nuke the target first, using shadowing,
-                        * but only if it isn't the same object
-                        */
-                       yaffs_ChangeObjectName(obj, newDir, newName, force,
-                                              existingTarget->objectId);
-                       yaffs_UnlinkObject(existingTarget);
-               }
-
-               return yaffs_ChangeObjectName(obj, newDir, newName, 1, 0);
-       }
-       return YAFFS_FAIL;
-}
-
-/*------------------------- Block Management and Page Allocation ----------------*/
-
-static int yaffs_InitialiseBlocks(yaffs_Device * dev)
-{
-       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-
-       dev->blockInfo = NULL;
-       dev->chunkBits = NULL;
-
-       dev->allocationBlock = -1;      /* force it to get a new one */
-
-       /* If the first allocation strategy fails, thry the alternate one */
-       dev->blockInfo = YMALLOC(nBlocks * sizeof(yaffs_BlockInfo));
-       if(!dev->blockInfo){
-               dev->blockInfo = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockInfo));
-               dev->blockInfoAlt = 1;
-       }
-       else
-               dev->blockInfoAlt = 0;
-
-       if(dev->blockInfo){
-
-               /* Set up dynamic blockinfo stuff. */
-               dev->chunkBitmapStride = (dev->nChunksPerBlock + 7) / 8; /* round up bytes */
-               dev->chunkBits = YMALLOC(dev->chunkBitmapStride * nBlocks);
-               if(!dev->chunkBits){
-                       dev->chunkBits = YMALLOC_ALT(dev->chunkBitmapStride * nBlocks);
-                       dev->chunkBitsAlt = 1;
-               }
-               else
-                       dev->chunkBitsAlt = 0;
-       }
-
-       if (dev->blockInfo && dev->chunkBits) {
-               memset(dev->blockInfo, 0, nBlocks * sizeof(yaffs_BlockInfo));
-               memset(dev->chunkBits, 0, dev->chunkBitmapStride * nBlocks);
-               return YAFFS_OK;
-       }
-
-       return YAFFS_FAIL;
-
-}
-
-static void yaffs_DeinitialiseBlocks(yaffs_Device * dev)
-{
-       if(dev->blockInfoAlt && dev->blockInfo)
-               YFREE_ALT(dev->blockInfo);
-       else if(dev->blockInfo)
-               YFREE(dev->blockInfo);
-
-       dev->blockInfoAlt = 0;
-
-       dev->blockInfo = NULL;
-
-       if(dev->chunkBitsAlt && dev->chunkBits)
-               YFREE_ALT(dev->chunkBits);
-       else if(dev->chunkBits)
-               YFREE(dev->chunkBits);
-       dev->chunkBitsAlt = 0;
-       dev->chunkBits = NULL;
-}
-
-static int yaffs_BlockNotDisqualifiedFromGC(yaffs_Device * dev,
-                                           yaffs_BlockInfo * bi)
-{
-       int i;
-       __u32 seq;
-       yaffs_BlockInfo *b;
-
-       if (!dev->isYaffs2)
-               return 1;       /* disqualification only applies to yaffs2. */
-
-       if (!bi->hasShrinkHeader)
-               return 1;       /* can gc */
-
-       /* Find the oldest dirty sequence number if we don't know it and save it
-        * so we don't have to keep recomputing it.
-        */
-       if (!dev->oldestDirtySequence) {
-               seq = dev->sequenceNumber;
-
-               for (i = dev->internalStartBlock; i <= dev->internalEndBlock;
-                    i++) {
-                       b = yaffs_GetBlockInfo(dev, i);
-                       if (b->blockState == YAFFS_BLOCK_STATE_FULL &&
-                           (b->pagesInUse - b->softDeletions) <
-                           dev->nChunksPerBlock && b->sequenceNumber < seq) {
-                               seq = b->sequenceNumber;
-                       }
-               }
-               dev->oldestDirtySequence = seq;
-       }
-
-       /* Can't do gc of this block if there are any blocks older than this one that have
-        * discarded pages.
-        */
-       return (bi->sequenceNumber <= dev->oldestDirtySequence);
-
-}
-
-/* FindDiretiestBlock is used to select the dirtiest block (or close enough)
- * for garbage collection.
- */
-
-static int yaffs_FindBlockForGarbageCollection(yaffs_Device * dev,
-                                              int aggressive)
-{
-
-       int b = dev->currentDirtyChecker;
-
-       int i;
-       int iterations;
-       int dirtiest = -1;
-       int pagesInUse = 0;
-       int prioritised=0;
-       yaffs_BlockInfo *bi;
-       int pendingPrioritisedExist = 0;
-
-       /* First let's see if we need to grab a prioritised block */
-       if(dev->hasPendingPrioritisedGCs){
-               for(i = dev->internalStartBlock; i < dev->internalEndBlock && !prioritised; i++){
-
-                       bi = yaffs_GetBlockInfo(dev, i);
-                       //yaffs_VerifyBlock(dev,bi,i);
-
-                       if(bi->gcPrioritise) {
-                               pendingPrioritisedExist = 1;
-                               if(bi->blockState == YAFFS_BLOCK_STATE_FULL &&
-                                  yaffs_BlockNotDisqualifiedFromGC(dev, bi)){
-                                       pagesInUse = (bi->pagesInUse - bi->softDeletions);
-                                       dirtiest = i;
-                                       prioritised = 1;
-                                       aggressive = 1; /* Fool the non-aggressive skip logiv below */
-                               }
-                       }
-               }
-
-               if(!pendingPrioritisedExist) /* None found, so we can clear this */
-                       dev->hasPendingPrioritisedGCs = 0;
-       }
-
-       /* If we're doing aggressive GC then we are happy to take a less-dirty block, and
-        * search harder.
-        * else (we're doing a leasurely gc), then we only bother to do this if the
-        * block has only a few pages in use.
-        */
-
-       dev->nonAggressiveSkip--;
-
-       if (!aggressive && (dev->nonAggressiveSkip > 0)) {
-               return -1;
-       }
-
-       if(!prioritised)
-               pagesInUse =
-                       (aggressive) ? dev->nChunksPerBlock : YAFFS_PASSIVE_GC_CHUNKS + 1;
-
-       if (aggressive) {
-               iterations =
-                   dev->internalEndBlock - dev->internalStartBlock + 1;
-       } else {
-               iterations =
-                   dev->internalEndBlock - dev->internalStartBlock + 1;
-               iterations = iterations / 16;
-               if (iterations > 200) {
-                       iterations = 200;
-               }
-       }
-
-       for (i = 0; i <= iterations && pagesInUse > 0 && !prioritised; i++) {
-               b++;
-               if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
-                       b = dev->internalStartBlock;
-               }
-
-               if (b < dev->internalStartBlock || b > dev->internalEndBlock) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR("**>> Block %d is not valid" TENDSTR), b));
-                       YBUG();
-               }
-
-               bi = yaffs_GetBlockInfo(dev, b);
-
-#if 0
-               if (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT) {
-                       dirtiest = b;
-                       pagesInUse = 0;
-               }
-               else
-#endif
-
-               if (bi->blockState == YAFFS_BLOCK_STATE_FULL &&
-                      (bi->pagesInUse - bi->softDeletions) < pagesInUse &&
-                       yaffs_BlockNotDisqualifiedFromGC(dev, bi)) {
-                       dirtiest = b;
-                       pagesInUse = (bi->pagesInUse - bi->softDeletions);
-               }
-       }
-
-       dev->currentDirtyChecker = b;
-
-       if (dirtiest > 0) {
-               T(YAFFS_TRACE_GC,
-                 (TSTR("GC Selected block %d with %d free, prioritised:%d" TENDSTR), dirtiest,
-                  dev->nChunksPerBlock - pagesInUse,prioritised));
-       }
-
-       dev->oldestDirtySequence = 0;
-
-       if (dirtiest > 0) {
-               dev->nonAggressiveSkip = 4;
-       }
-
-       return dirtiest;
-}
-
-static void yaffs_BlockBecameDirty(yaffs_Device * dev, int blockNo)
-{
-       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, blockNo);
-
-       int erasedOk = 0;
-
-       /* If the block is still healthy erase it and mark as clean.
-        * If the block has had a data failure, then retire it.
-        */
-
-       T(YAFFS_TRACE_GC | YAFFS_TRACE_ERASE,
-               (TSTR("yaffs_BlockBecameDirty block %d state %d %s"TENDSTR),
-               blockNo, bi->blockState, (bi->needsRetiring) ? "needs retiring" : ""));
-
-       bi->blockState = YAFFS_BLOCK_STATE_DIRTY;
-
-       if (!bi->needsRetiring) {
-               yaffs_InvalidateCheckpoint(dev);
-               erasedOk = yaffs_EraseBlockInNAND(dev, blockNo);
-               if (!erasedOk) {
-                       dev->nErasureFailures++;
-                       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("**>> Erasure failed %d" TENDSTR), blockNo));
-               }
-       }
-
-       if (erasedOk &&
-           ((yaffs_traceMask & YAFFS_TRACE_ERASE) || !yaffs_SkipVerification(dev))) {
-               int i;
-               for (i = 0; i < dev->nChunksPerBlock; i++) {
-                       if (!yaffs_CheckChunkErased
-                           (dev, blockNo * dev->nChunksPerBlock + i)) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  (">>Block %d erasure supposedly OK, but chunk %d not erased"
-                                   TENDSTR), blockNo, i));
-                       }
-               }
-       }
-
-       if (erasedOk) {
-               /* Clean it up... */
-               bi->blockState = YAFFS_BLOCK_STATE_EMPTY;
-               dev->nErasedBlocks++;
-               bi->pagesInUse = 0;
-               bi->softDeletions = 0;
-               bi->hasShrinkHeader = 0;
-               bi->skipErasedCheck = 1;  /* This is clean, so no need to check */
-               bi->gcPrioritise = 0;
-               yaffs_ClearChunkBits(dev, blockNo);
-
-               T(YAFFS_TRACE_ERASE,
-                 (TSTR("Erased block %d" TENDSTR), blockNo));
-       } else {
-               dev->nFreeChunks -= dev->nChunksPerBlock;       /* We lost a block of free space */
-
-               yaffs_RetireBlock(dev, blockNo);
-               T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-                 (TSTR("**>> Block %d retired" TENDSTR), blockNo));
-       }
-}
-
-static int yaffs_FindBlockForAllocation(yaffs_Device * dev)
-{
-       int i;
-
-       yaffs_BlockInfo *bi;
-
-       if (dev->nErasedBlocks < 1) {
-               /* Hoosterman we've got a problem.
-                * Can't get space to gc
-                */
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("yaffs tragedy: no more eraased blocks" TENDSTR)));
-
-               return -1;
-       }
-
-       /* Find an empty block. */
-
-       for (i = dev->internalStartBlock; i <= dev->internalEndBlock; i++) {
-               dev->allocationBlockFinder++;
-               if (dev->allocationBlockFinder < dev->internalStartBlock
-                   || dev->allocationBlockFinder > dev->internalEndBlock) {
-                       dev->allocationBlockFinder = dev->internalStartBlock;
-               }
-
-               bi = yaffs_GetBlockInfo(dev, dev->allocationBlockFinder);
-
-               if (bi->blockState == YAFFS_BLOCK_STATE_EMPTY) {
-                       bi->blockState = YAFFS_BLOCK_STATE_ALLOCATING;
-                       dev->sequenceNumber++;
-                       bi->sequenceNumber = dev->sequenceNumber;
-                       dev->nErasedBlocks--;
-                       T(YAFFS_TRACE_ALLOCATE,
-                         (TSTR("Allocated block %d, seq  %d, %d left" TENDSTR),
-                          dev->allocationBlockFinder, dev->sequenceNumber,
-                          dev->nErasedBlocks));
-                       return dev->allocationBlockFinder;
-               }
-       }
-
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR
-          ("yaffs tragedy: no more eraased blocks, but there should have been %d"
-           TENDSTR), dev->nErasedBlocks));
-
-       return -1;
-}
-
-
-// Check if there's space to allocate...
-// Thinks.... do we need top make this ths same as yaffs_GetFreeChunks()?
-static int yaffs_CheckSpaceForAllocation(yaffs_Device * dev)
-{
-       int reservedChunks;
-       int reservedBlocks = dev->nReservedBlocks;
-       int checkpointBlocks;
-
-       checkpointBlocks =  dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
-       if(checkpointBlocks < 0)
-               checkpointBlocks = 0;
-
-       reservedChunks = ((reservedBlocks + checkpointBlocks) * dev->nChunksPerBlock);
-
-       return (dev->nFreeChunks > reservedChunks);
-}
-
-static int yaffs_AllocateChunk(yaffs_Device * dev, int useReserve, yaffs_BlockInfo **blockUsedPtr)
-{
-       int retVal;
-       yaffs_BlockInfo *bi;
-
-       if (dev->allocationBlock < 0) {
-               /* Get next block to allocate off */
-               dev->allocationBlock = yaffs_FindBlockForAllocation(dev);
-               dev->allocationPage = 0;
-       }
-
-       if (!useReserve && !yaffs_CheckSpaceForAllocation(dev)) {
-               /* Not enough space to allocate unless we're allowed to use the reserve. */
-               return -1;
-       }
-
-       if (dev->nErasedBlocks < dev->nReservedBlocks
-           && dev->allocationPage == 0) {
-               T(YAFFS_TRACE_ALLOCATE, (TSTR("Allocating reserve" TENDSTR)));
-       }
-
-       /* Next page please.... */
-       if (dev->allocationBlock >= 0) {
-               bi = yaffs_GetBlockInfo(dev, dev->allocationBlock);
-
-               retVal = (dev->allocationBlock * dev->nChunksPerBlock) +
-                   dev->allocationPage;
-               bi->pagesInUse++;
-               yaffs_SetChunkBit(dev, dev->allocationBlock,
-                                 dev->allocationPage);
-
-               dev->allocationPage++;
-
-               dev->nFreeChunks--;
-
-               /* If the block is full set the state to full */
-               if (dev->allocationPage >= dev->nChunksPerBlock) {
-                       bi->blockState = YAFFS_BLOCK_STATE_FULL;
-                       dev->allocationBlock = -1;
-               }
-
-               if(blockUsedPtr)
-                       *blockUsedPtr = bi;
-
-               return retVal;
-       }
-
-       T(YAFFS_TRACE_ERROR,
-         (TSTR("!!!!!!!!! Allocator out !!!!!!!!!!!!!!!!!" TENDSTR)));
-
-       return -1;
-}
-
-static int yaffs_GetErasedChunks(yaffs_Device * dev)
-{
-       int n;
-
-       n = dev->nErasedBlocks * dev->nChunksPerBlock;
-
-       if (dev->allocationBlock > 0) {
-               n += (dev->nChunksPerBlock - dev->allocationPage);
-       }
-
-       return n;
-
-}
-
-static int yaffs_GarbageCollectBlock(yaffs_Device * dev, int block)
-{
-       int oldChunk;
-       int newChunk;
-       int chunkInBlock;
-       int markNAND;
-       int retVal = YAFFS_OK;
-       int cleanups = 0;
-       int i;
-       int isCheckpointBlock;
-       int matchingChunk;
-
-       int chunksBefore = yaffs_GetErasedChunks(dev);
-       int chunksAfter;
-
-       yaffs_ExtendedTags tags;
-
-       yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, block);
-
-       yaffs_Object *object;
-
-       isCheckpointBlock = (bi->blockState == YAFFS_BLOCK_STATE_CHECKPOINT);
-
-       bi->blockState = YAFFS_BLOCK_STATE_COLLECTING;
-
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("Collecting block %d, in use %d, shrink %d, " TENDSTR), block,
-          bi->pagesInUse, bi->hasShrinkHeader));
-
-       /*yaffs_VerifyFreeChunks(dev); */
-
-       bi->hasShrinkHeader = 0;        /* clear the flag so that the block can erase */
-
-       /* Take off the number of soft deleted entries because
-        * they're going to get really deleted during GC.
-        */
-       dev->nFreeChunks -= bi->softDeletions;
-
-       dev->isDoingGC = 1;
-
-       if (isCheckpointBlock ||
-           !yaffs_StillSomeChunkBits(dev, block)) {
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR
-                  ("Collecting block %d that has no chunks in use" TENDSTR),
-                  block));
-               yaffs_BlockBecameDirty(dev, block);
-       } else {
-
-               __u8 *buffer = yaffs_GetTempBuffer(dev, __LINE__);
-
-               yaffs_VerifyBlock(dev,bi,block);
-
-               for (chunkInBlock = 0, oldChunk = block * dev->nChunksPerBlock;
-                    chunkInBlock < dev->nChunksPerBlock
-                    && yaffs_StillSomeChunkBits(dev, block);
-                    chunkInBlock++, oldChunk++) {
-                       if (yaffs_CheckChunkBit(dev, block, chunkInBlock)) {
-
-                               /* This page is in use and might need to be copied off */
-
-                               markNAND = 1;
-
-                               yaffs_InitialiseTags(&tags);
-
-                               yaffs_ReadChunkWithTagsFromNAND(dev, oldChunk,
-                                                               buffer, &tags);
-
-                               object =
-                                   yaffs_FindObjectByNumber(dev,
-                                                            tags.objectId);
-
-                               T(YAFFS_TRACE_GC_DETAIL,
-                                 (TSTR
-                                  ("Collecting page %d, %d %d %d " TENDSTR),
-                                  chunkInBlock, tags.objectId, tags.chunkId,
-                                  tags.byteCount));
-
-                               if(object && !yaffs_SkipVerification(dev)){
-                                       if(tags.chunkId == 0)
-                                               matchingChunk = object->chunkId;
-                                       else if(object->softDeleted)
-                                               matchingChunk = oldChunk; /* Defeat the test */
-                                       else
-                                               matchingChunk = yaffs_FindChunkInFile(object,tags.chunkId,NULL);
-
-                                       if(oldChunk != matchingChunk)
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR("gc: page in gc mismatch: %d %d %d %d"TENDSTR),
-                                                 oldChunk,matchingChunk,tags.objectId, tags.chunkId));
-
-                               }
-
-                               if (!object) {
-                                       T(YAFFS_TRACE_ERROR,
-                                         (TSTR
-                                          ("page %d in gc has no object: %d %d %d "
-                                           TENDSTR), oldChunk,
-                                           tags.objectId, tags.chunkId, tags.byteCount));
-                               }
-
-                               if (object && object->deleted
-                                   && tags.chunkId != 0) {
-                                       /* Data chunk in a deleted file, throw it away
-                                        * It's a soft deleted data chunk,
-                                        * No need to copy this, just forget about it and
-                                        * fix up the object.
-                                        */
-
-                                       object->nDataChunks--;
-
-                                       if (object->nDataChunks <= 0) {
-                                               /* remeber to clean up the object */
-                                               dev->gcCleanupList[cleanups] =
-                                                   tags.objectId;
-                                               cleanups++;
-                                       }
-                                       markNAND = 0;
-                               } else if (0
-                                          /* Todo object && object->deleted && object->nDataChunks == 0 */
-                                          ) {
-                                       /* Deleted object header with no data chunks.
-                                        * Can be discarded and the file deleted.
-                                        */
-                                       object->chunkId = 0;
-                                       yaffs_FreeTnode(object->myDev,
-                                                       object->variant.
-                                                       fileVariant.top);
-                                       object->variant.fileVariant.top = NULL;
-                                       yaffs_DoGenericObjectDeletion(object);
-
-                               } else if (object) {
-                                       /* It's either a data chunk in a live file or
-                                        * an ObjectHeader, so we're interested in it.
-                                        * NB Need to keep the ObjectHeaders of deleted files
-                                        * until the whole file has been deleted off
-                                        */
-                                       tags.serialNumber++;
-
-                                       dev->nGCCopies++;
-
-                                       if (tags.chunkId == 0) {
-                                               /* It is an object Id,
-                                                * We need to nuke the shrinkheader flags first
-                                                * We no longer want the shrinkHeader flag since its work is done
-                                                * and if it is left in place it will mess up scanning.
-                                                * Also, clear out any shadowing stuff
-                                                */
-
-                                               yaffs_ObjectHeader *oh;
-                                               oh = (yaffs_ObjectHeader *)buffer;
-                                               oh->isShrink = 0;
-                                               oh->shadowsObject = -1;
-                                               tags.extraShadows = 0;
-                                               tags.extraIsShrinkHeader = 0;
-
-                                               yaffs_VerifyObjectHeader(object,oh,&tags,1);
-                                       }
-
-                                       newChunk =
-                                           yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &tags, 1);
-
-                                       if (newChunk < 0) {
-                                               retVal = YAFFS_FAIL;
-                                       } else {
-
-                                               /* Ok, now fix up the Tnodes etc. */
-
-                                               if (tags.chunkId == 0) {
-                                                       /* It's a header */
-                                                       object->chunkId =  newChunk;
-                                                       object->serial =   tags.serialNumber;
-                                               } else {
-                                                       /* It's a data chunk */
-                                                       yaffs_PutChunkIntoFile
-                                                           (object,
-                                                            tags.chunkId,
-                                                            newChunk, 0);
-                                               }
-                                       }
-                               }
-
-                               yaffs_DeleteChunk(dev, oldChunk, markNAND, __LINE__);
-
-                       }
-               }
-
-               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
-
-
-               /* Do any required cleanups */
-               for (i = 0; i < cleanups; i++) {
-                       /* Time to delete the file too */
-                       object =
-                           yaffs_FindObjectByNumber(dev,
-                                                    dev->gcCleanupList[i]);
-                       if (object) {
-                               yaffs_FreeTnode(dev,
-                                               object->variant.fileVariant.
-                                               top);
-                               object->variant.fileVariant.top = NULL;
-                               T(YAFFS_TRACE_GC,
-                                 (TSTR
-                                  ("yaffs: About to finally delete object %d"
-                                   TENDSTR), object->objectId));
-                               yaffs_DoGenericObjectDeletion(object);
-                               object->myDev->nDeletedFiles--;
-                       }
-
-               }
-
-       }
-
-       yaffs_VerifyCollectedBlock(dev,bi,block);
-
-       if (chunksBefore >= (chunksAfter = yaffs_GetErasedChunks(dev))) {
-               T(YAFFS_TRACE_GC,
-                 (TSTR
-                  ("gc did not increase free chunks before %d after %d"
-                   TENDSTR), chunksBefore, chunksAfter));
-       }
-
-       dev->isDoingGC = 0;
-
-       return YAFFS_OK;
-}
-
-/* New garbage collector
- * If we're very low on erased blocks then we do aggressive garbage collection
- * otherwise we do "leasurely" garbage collection.
- * Aggressive gc looks further (whole array) and will accept less dirty blocks.
- * Passive gc only inspects smaller areas and will only accept more dirty blocks.
- *
- * The idea is to help clear out space in a more spread-out manner.
- * Dunno if it really does anything useful.
- */
-static int yaffs_CheckGarbageCollection(yaffs_Device * dev)
-{
-       int block;
-       int aggressive;
-       int gcOk = YAFFS_OK;
-       int maxTries = 0;
-
-       int checkpointBlockAdjust;
-
-       if (dev->isDoingGC) {
-               /* Bail out so we don't get recursive gc */
-               return YAFFS_OK;
-       }
-
-       /* This loop should pass the first time.
-        * We'll only see looping here if the erase of the collected block fails.
-        */
-
-       do {
-               maxTries++;
-
-               checkpointBlockAdjust = (dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint);
-               if(checkpointBlockAdjust < 0)
-                       checkpointBlockAdjust = 0;
-
-               if (dev->nErasedBlocks < (dev->nReservedBlocks + checkpointBlockAdjust + 2)) {
-                       /* We need a block soon...*/
-                       aggressive = 1;
-               } else {
-                       /* We're in no hurry */
-                       aggressive = 0;
-               }
-
-               block = yaffs_FindBlockForGarbageCollection(dev, aggressive);
-
-               if (block > 0) {
-                       dev->garbageCollections++;
-                       if (!aggressive) {
-                               dev->passiveGarbageCollections++;
-                       }
-
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC erasedBlocks %d aggressive %d" TENDSTR),
-                          dev->nErasedBlocks, aggressive));
-
-                       gcOk = yaffs_GarbageCollectBlock(dev, block);
-               }
-
-               if (dev->nErasedBlocks < (dev->nReservedBlocks) && block > 0) {
-                       T(YAFFS_TRACE_GC,
-                         (TSTR
-                          ("yaffs: GC !!!no reclaim!!! erasedBlocks %d after try %d block %d"
-                           TENDSTR), dev->nErasedBlocks, maxTries, block));
-               }
-       } while ((dev->nErasedBlocks < dev->nReservedBlocks) && (block > 0)
-                && (maxTries < 2));
-
-       return aggressive ? gcOk : YAFFS_OK;
-}
-
-/*-------------------------  TAGS --------------------------------*/
-
-static int yaffs_TagsMatch(const yaffs_ExtendedTags * tags, int objectId,
-                          int chunkInObject)
-{
-       return (tags->chunkId == chunkInObject &&
-               tags->objectId == objectId && !tags->chunkDeleted) ? 1 : 0;
-
-}
-
-
-/*-------------------- Data file manipulation -----------------*/
-
-static int yaffs_FindChunkInFile(yaffs_Object * in, int chunkInInode,
-                                yaffs_ExtendedTags * tags)
-{
-       /*Get the Tnode, then get the level 0 offset chunk offset */
-       yaffs_Tnode *tn;
-       int theChunk = -1;
-       yaffs_ExtendedTags localTags;
-       int retVal = -1;
-
-       yaffs_Device *dev = in->myDev;
-
-       if (!tags) {
-               /* Passed a NULL, so use our own tags space */
-               tags = &localTags;
-       }
-
-       tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
-
-       if (tn) {
-               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
-
-               retVal =
-                   yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
-                                          chunkInInode);
-       }
-       return retVal;
-}
-
-static int yaffs_FindAndDeleteChunkInFile(yaffs_Object * in, int chunkInInode,
-                                         yaffs_ExtendedTags * tags)
-{
-       /* Get the Tnode, then get the level 0 offset chunk offset */
-       yaffs_Tnode *tn;
-       int theChunk = -1;
-       yaffs_ExtendedTags localTags;
-
-       yaffs_Device *dev = in->myDev;
-       int retVal = -1;
-
-       if (!tags) {
-               /* Passed a NULL, so use our own tags space */
-               tags = &localTags;
-       }
-
-       tn = yaffs_FindLevel0Tnode(dev, &in->variant.fileVariant, chunkInInode);
-
-       if (tn) {
-
-               theChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
-
-               retVal =
-                   yaffs_FindChunkInGroup(dev, theChunk, tags, in->objectId,
-                                          chunkInInode);
-
-               /* Delete the entry in the filestructure (if found) */
-               if (retVal != -1) {
-                       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,0);
-               }
-       } else {
-               /*T(("No level 0 found for %d\n", chunkInInode)); */
-       }
-
-       if (retVal == -1) {
-               /* T(("Could not find %d to delete\n",chunkInInode)); */
-       }
-       return retVal;
-}
-
-#ifdef YAFFS_PARANOID
-
-static int yaffs_CheckFileSanity(yaffs_Object * in)
-{
-       int chunk;
-       int nChunks;
-       int fSize;
-       int failed = 0;
-       int objId;
-       yaffs_Tnode *tn;
-       yaffs_Tags localTags;
-       yaffs_Tags *tags = &localTags;
-       int theChunk;
-       int chunkDeleted;
-
-       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
-               /* T(("Object not a file\n")); */
-               return YAFFS_FAIL;
-       }
-
-       objId = in->objectId;
-       fSize = in->variant.fileVariant.fileSize;
-       nChunks =
-           (fSize + in->myDev->nDataBytesPerChunk - 1) / in->myDev->nDataBytesPerChunk;
-
-       for (chunk = 1; chunk <= nChunks; chunk++) {
-               tn = yaffs_FindLevel0Tnode(in->myDev, &in->variant.fileVariant,
-                                          chunk);
-
-               if (tn) {
-
-                       theChunk = yaffs_GetChunkGroupBase(dev,tn,chunk);
-
-                       if (yaffs_CheckChunkBits
-                           (dev, theChunk / dev->nChunksPerBlock,
-                            theChunk % dev->nChunksPerBlock)) {
-
-                               yaffs_ReadChunkTagsFromNAND(in->myDev, theChunk,
-                                                           tags,
-                                                           &chunkDeleted);
-                               if (yaffs_TagsMatch
-                                   (tags, in->objectId, chunk, chunkDeleted)) {
-                                       /* found it; */
-
-                               }
-                       } else {
-
-                               failed = 1;
-                       }
-
-               } else {
-                       /* T(("No level 0 found for %d\n", chunk)); */
-               }
-       }
-
-       return failed ? YAFFS_FAIL : YAFFS_OK;
-}
-
-#endif
-
-static int yaffs_PutChunkIntoFile(yaffs_Object * in, int chunkInInode,
-                                 int chunkInNAND, int inScan)
-{
-       /* NB inScan is zero unless scanning.
-        * For forward scanning, inScan is > 0;
-        * for backward scanning inScan is < 0
-        */
-
-       yaffs_Tnode *tn;
-       yaffs_Device *dev = in->myDev;
-       int existingChunk;
-       yaffs_ExtendedTags existingTags;
-       yaffs_ExtendedTags newTags;
-       unsigned existingSerial, newSerial;
-
-       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
-               /* Just ignore an attempt at putting a chunk into a non-file during scanning
-                * If it is not during Scanning then something went wrong!
-                */
-               if (!inScan) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR
-                          ("yaffs tragedy:attempt to put data chunk into a non-file"
-                           TENDSTR)));
-                       YBUG();
-               }
-
-               yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
-               return YAFFS_OK;
-       }
-
-       tn = yaffs_AddOrFindLevel0Tnode(dev,
-                                       &in->variant.fileVariant,
-                                       chunkInInode,
-                                       NULL);
-       if (!tn) {
-               return YAFFS_FAIL;
-       }
-
-       existingChunk = yaffs_GetChunkGroupBase(dev,tn,chunkInInode);
-
-       if (inScan != 0) {
-               /* If we're scanning then we need to test for duplicates
-                * NB This does not need to be efficient since it should only ever
-                * happen when the power fails during a write, then only one
-                * chunk should ever be affected.
-                *
-                * Correction for YAFFS2: This could happen quite a lot and we need to think about efficiency! TODO
-                * Update: For backward scanning we don't need to re-read tags so this is quite cheap.
-                */
-
-               if (existingChunk != 0) {
-                       /* NB Right now existing chunk will not be real chunkId if the device >= 32MB
-                        *    thus we have to do a FindChunkInFile to get the real chunk id.
-                        *
-                        * We have a duplicate now we need to decide which one to use:
-                        *
-                        * Backwards scanning YAFFS2: The old one is what we use, dump the new one.
-                        * Forward scanning YAFFS2: The new one is what we use, dump the old one.
-                        * YAFFS1: Get both sets of tags and compare serial numbers.
-                        */
-
-                       if (inScan > 0) {
-                               /* Only do this for forward scanning */
-                               yaffs_ReadChunkWithTagsFromNAND(dev,
-                                                               chunkInNAND,
-                                                               NULL, &newTags);
-
-                               /* Do a proper find */
-                               existingChunk =
-                                   yaffs_FindChunkInFile(in, chunkInInode,
-                                                         &existingTags);
-                       }
-
-                       if (existingChunk <= 0) {
-                               /*Hoosterman - how did this happen? */
-
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("yaffs tragedy: existing chunk < 0 in scan"
-                                   TENDSTR)));
-
-                       }
-
-                       /* NB The deleted flags should be false, otherwise the chunks will
-                        * not be loaded during a scan
-                        */
-
-                       newSerial = newTags.serialNumber;
-                       existingSerial = existingTags.serialNumber;
-
-                       if ((inScan > 0) &&
-                           (in->myDev->isYaffs2 ||
-                            existingChunk <= 0 ||
-                            ((existingSerial + 1) & 3) == newSerial)) {
-                               /* Forward scanning.
-                                * Use new
-                                * Delete the old one and drop through to update the tnode
-                                */
-                               yaffs_DeleteChunk(dev, existingChunk, 1,
-                                                 __LINE__);
-                       } else {
-                               /* Backward scanning or we want to use the existing one
-                                * Use existing.
-                                * Delete the new one and return early so that the tnode isn't changed
-                                */
-                               yaffs_DeleteChunk(dev, chunkInNAND, 1,
-                                                 __LINE__);
-                               return YAFFS_OK;
-                       }
-               }
-
-       }
-
-       if (existingChunk == 0) {
-               in->nDataChunks++;
-       }
-
-       yaffs_PutLevel0Tnode(dev,tn,chunkInInode,chunkInNAND);
-
-       return YAFFS_OK;
-}
-
-static int yaffs_ReadChunkDataFromObject(yaffs_Object * in, int chunkInInode,
-                                        __u8 * buffer)
-{
-       int chunkInNAND = yaffs_FindChunkInFile(in, chunkInInode, NULL);
-
-       if (chunkInNAND >= 0) {
-               return yaffs_ReadChunkWithTagsFromNAND(in->myDev, chunkInNAND,
-                                                      buffer,NULL);
-       } else {
-               T(YAFFS_TRACE_NANDACCESS,
-                 (TSTR("Chunk %d not found zero instead" TENDSTR),
-                  chunkInNAND));
-               /* get sane (zero) data if you read a hole */
-               memset(buffer, 0, in->myDev->nDataBytesPerChunk);
-               return 0;
-       }
-
-}
-
-void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn)
-{
-       int block;
-       int page;
-       yaffs_ExtendedTags tags;
-       yaffs_BlockInfo *bi;
-
-       if (chunkId <= 0)
-               return;
-
-
-       dev->nDeletions++;
-       block = chunkId / dev->nChunksPerBlock;
-       page = chunkId % dev->nChunksPerBlock;
-
-
-       if(!yaffs_CheckChunkBit(dev,block,page))
-               T(YAFFS_TRACE_VERIFY,
-                       (TSTR("Deleting invalid chunk %d"TENDSTR),
-                        chunkId));
-
-       bi = yaffs_GetBlockInfo(dev, block);
-
-       T(YAFFS_TRACE_DELETION,
-         (TSTR("line %d delete of chunk %d" TENDSTR), lyn, chunkId));
-
-       if (markNAND &&
-           bi->blockState != YAFFS_BLOCK_STATE_COLLECTING && !dev->isYaffs2) {
-
-               yaffs_InitialiseTags(&tags);
-
-               tags.chunkDeleted = 1;
-
-               yaffs_WriteChunkWithTagsToNAND(dev, chunkId, NULL, &tags);
-               yaffs_HandleUpdateChunk(dev, chunkId, &tags);
-       } else {
-               dev->nUnmarkedDeletions++;
-       }
-
-       /* Pull out of the management area.
-        * If the whole block became dirty, this will kick off an erasure.
-        */
-       if (bi->blockState == YAFFS_BLOCK_STATE_ALLOCATING ||
-           bi->blockState == YAFFS_BLOCK_STATE_FULL ||
-           bi->blockState == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
-           bi->blockState == YAFFS_BLOCK_STATE_COLLECTING) {
-               dev->nFreeChunks++;
-
-               yaffs_ClearChunkBit(dev, block, page);
-
-               bi->pagesInUse--;
-
-               if (bi->pagesInUse == 0 &&
-                   !bi->hasShrinkHeader &&
-                   bi->blockState != YAFFS_BLOCK_STATE_ALLOCATING &&
-                   bi->blockState != YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-                       yaffs_BlockBecameDirty(dev, block);
-               }
-
-       } else {
-               /* T(("Bad news deleting chunk %d\n",chunkId)); */
-       }
-
-}
-
-static int yaffs_WriteChunkDataToObject(yaffs_Object * in, int chunkInInode,
-                                       const __u8 * buffer, int nBytes,
-                                       int useReserve)
-{
-       /* Find old chunk Need to do this to get serial number
-        * Write new one and patch into tree.
-        * Invalidate old tags.
-        */
-
-       int prevChunkId;
-       yaffs_ExtendedTags prevTags;
-
-       int newChunkId;
-       yaffs_ExtendedTags newTags;
-
-       yaffs_Device *dev = in->myDev;
-
-       yaffs_CheckGarbageCollection(dev);
-
-       /* Get the previous chunk at this location in the file if it exists */
-       prevChunkId = yaffs_FindChunkInFile(in, chunkInInode, &prevTags);
-
-       /* Set up new tags */
-       yaffs_InitialiseTags(&newTags);
-
-       newTags.chunkId = chunkInInode;
-       newTags.objectId = in->objectId;
-       newTags.serialNumber =
-           (prevChunkId >= 0) ? prevTags.serialNumber + 1 : 1;
-       newTags.byteCount = nBytes;
-
-       newChunkId =
-           yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
-                                             useReserve);
-
-       if (newChunkId >= 0) {
-               yaffs_PutChunkIntoFile(in, chunkInInode, newChunkId, 0);
-
-               if (prevChunkId >= 0) {
-                       yaffs_DeleteChunk(dev, prevChunkId, 1, __LINE__);
-
-               }
-
-               yaffs_CheckFileSanity(in);
-       }
-       return newChunkId;
-
-}
-
-/* UpdateObjectHeader updates the header on NAND for an object.
- * If name is not NULL, then that new name is used.
- */
-int yaffs_UpdateObjectHeader(yaffs_Object * in, const YCHAR * name, int force,
-                            int isShrink, int shadows)
-{
-
-       yaffs_BlockInfo *bi;
-
-       yaffs_Device *dev = in->myDev;
-
-       int prevChunkId;
-       int retVal = 0;
-       int result = 0;
-
-       int newChunkId;
-       yaffs_ExtendedTags newTags;
-       yaffs_ExtendedTags oldTags;
-
-       __u8 *buffer = NULL;
-       YCHAR oldName[YAFFS_MAX_NAME_LENGTH + 1];
-
-       yaffs_ObjectHeader *oh = NULL;
-
-       yaffs_strcpy(oldName,"silly old name");
-
-       if (!in->fake || force) {
-
-               yaffs_CheckGarbageCollection(dev);
-               yaffs_CheckObjectDetailsLoaded(in);
-
-               buffer = yaffs_GetTempBuffer(in->myDev, __LINE__);
-               oh = (yaffs_ObjectHeader *) buffer;
-
-               prevChunkId = in->chunkId;
-
-               if (prevChunkId >= 0) {
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, prevChunkId,
-                                                       buffer, &oldTags);
-
-                       yaffs_VerifyObjectHeader(in,oh,&oldTags,0);
-
-                       memcpy(oldName, oh->name, sizeof(oh->name));
-               }
-
-               memset(buffer, 0xFF, dev->nDataBytesPerChunk);
-
-               oh->type = in->variantType;
-               oh->yst_mode = in->yst_mode;
-               oh->shadowsObject = shadows;
-
-#ifdef CONFIG_YAFFS_WINCE
-               oh->win_atime[0] = in->win_atime[0];
-               oh->win_ctime[0] = in->win_ctime[0];
-               oh->win_mtime[0] = in->win_mtime[0];
-               oh->win_atime[1] = in->win_atime[1];
-               oh->win_ctime[1] = in->win_ctime[1];
-               oh->win_mtime[1] = in->win_mtime[1];
-#else
-               oh->yst_uid = in->yst_uid;
-               oh->yst_gid = in->yst_gid;
-               oh->yst_atime = in->yst_atime;
-               oh->yst_mtime = in->yst_mtime;
-               oh->yst_ctime = in->yst_ctime;
-               oh->yst_rdev = in->yst_rdev;
-#endif
-               if (in->parent) {
-                       oh->parentObjectId = in->parent->objectId;
-               } else {
-                       oh->parentObjectId = 0;
-               }
-
-               if (name && *name) {
-                       memset(oh->name, 0, sizeof(oh->name));
-                       yaffs_strncpy(oh->name, name, YAFFS_MAX_NAME_LENGTH);
-               } else if (prevChunkId>=0) {
-                       memcpy(oh->name, oldName, sizeof(oh->name));
-               } else {
-                       memset(oh->name, 0, sizeof(oh->name));
-               }
-
-               oh->isShrink = isShrink;
-
-               switch (in->variantType) {
-               case YAFFS_OBJECT_TYPE_UNKNOWN:
-                       /* Should not happen */
-                       break;
-               case YAFFS_OBJECT_TYPE_FILE:
-                       oh->fileSize =
-                           (oh->parentObjectId == YAFFS_OBJECTID_DELETED
-                            || oh->parentObjectId ==
-                            YAFFS_OBJECTID_UNLINKED) ? 0 : in->variant.
-                           fileVariant.fileSize;
-                       break;
-               case YAFFS_OBJECT_TYPE_HARDLINK:
-                       oh->equivalentObjectId =
-                           in->variant.hardLinkVariant.equivalentObjectId;
-                       break;
-               case YAFFS_OBJECT_TYPE_SPECIAL:
-                       /* Do nothing */
-                       break;
-               case YAFFS_OBJECT_TYPE_DIRECTORY:
-                       /* Do nothing */
-                       break;
-               case YAFFS_OBJECT_TYPE_SYMLINK:
-                       yaffs_strncpy(oh->alias,
-                                     in->variant.symLinkVariant.alias,
-                                     YAFFS_MAX_ALIAS_LENGTH);
-                       oh->alias[YAFFS_MAX_ALIAS_LENGTH] = 0;
-                       break;
-               }
-
-               /* Tags */
-               yaffs_InitialiseTags(&newTags);
-               in->serial++;
-               newTags.chunkId = 0;
-               newTags.objectId = in->objectId;
-               newTags.serialNumber = in->serial;
-
-               /* Add extra info for file header */
-
-               newTags.extraHeaderInfoAvailable = 1;
-               newTags.extraParentObjectId = oh->parentObjectId;
-               newTags.extraFileLength = oh->fileSize;
-               newTags.extraIsShrinkHeader = oh->isShrink;
-               newTags.extraEquivalentObjectId = oh->equivalentObjectId;
-               newTags.extraShadows = (oh->shadowsObject > 0) ? 1 : 0;
-               newTags.extraObjectType = in->variantType;
-
-               yaffs_VerifyObjectHeader(in,oh,&newTags,1);
-
-               /* Create new chunk in NAND */
-               newChunkId =
-                   yaffs_WriteNewChunkWithTagsToNAND(dev, buffer, &newTags,
-                                                     (prevChunkId >= 0) ? 1 : 0);
-
-               if (newChunkId >= 0) {
-
-                       in->chunkId = newChunkId;
-
-                       if (prevChunkId >= 0) {
-                               yaffs_DeleteChunk(dev, prevChunkId, 1,
-                                                 __LINE__);
-                       }
-
-                       if(!yaffs_ObjectHasCachedWriteData(in))
-                               in->dirty = 0;
-
-                       /* If this was a shrink, then mark the block that the chunk lives on */
-                       if (isShrink) {
-                               bi = yaffs_GetBlockInfo(in->myDev,
-                                                       newChunkId /in->myDev-> nChunksPerBlock);
-                               bi->hasShrinkHeader = 1;
-                       }
-
-               }
-
-               retVal = newChunkId;
-
-       }
-
-       if (buffer)
-               yaffs_ReleaseTempBuffer(dev, buffer, __LINE__);
-
-       return retVal;
-}
-
-/*------------------------ Short Operations Cache ----------------------------------------
- *   In many situations where there is no high level buffering (eg WinCE) a lot of
- *   reads might be short sequential reads, and a lot of writes may be short
- *   sequential writes. eg. scanning/writing a jpeg file.
- *   In these cases, a short read/write cache can provide a huge perfomance benefit
- *   with dumb-as-a-rock code.
- *   In Linux, the page cache provides read buffering aand the short op cache provides write
- *   buffering.
- *
- *   There are a limited number (~10) of cache chunks per device so that we don't
- *   need a very intelligent search.
- */
-
-static int yaffs_ObjectHasCachedWriteData(yaffs_Object *obj)
-{
-       yaffs_Device *dev = obj->myDev;
-       int i;
-       yaffs_ChunkCache *cache;
-       int nCaches = obj->myDev->nShortOpCaches;
-
-       for(i = 0; i < nCaches; i++){
-               cache = &dev->srCache[i];
-               if (cache->object == obj &&
-                   cache->dirty)
-                       return 1;
-       }
-
-       return 0;
-}
-
-
-static void yaffs_FlushFilesChunkCache(yaffs_Object * obj)
-{
-       yaffs_Device *dev = obj->myDev;
-       int lowest = -99;       /* Stop compiler whining. */
-       int i;
-       yaffs_ChunkCache *cache;
-       int chunkWritten = 0;
-       int nCaches = obj->myDev->nShortOpCaches;
-
-       if (nCaches > 0) {
-               do {
-                       cache = NULL;
-
-                       /* Find the dirty cache for this object with the lowest chunk id. */
-                       for (i = 0; i < nCaches; i++) {
-                               if (dev->srCache[i].object == obj &&
-                                   dev->srCache[i].dirty) {
-                                       if (!cache
-                                           || dev->srCache[i].chunkId <
-                                           lowest) {
-                                               cache = &dev->srCache[i];
-                                               lowest = cache->chunkId;
-                                       }
-                               }
-                       }
-
-                       if (cache && !cache->locked) {
-                               /* Write it out and free it up */
-
-                               chunkWritten =
-                                   yaffs_WriteChunkDataToObject(cache->object,
-                                                                cache->chunkId,
-                                                                cache->data,
-                                                                cache->nBytes,
-                                                                1);
-                               cache->dirty = 0;
-                               cache->object = NULL;
-                       }
-
-               } while (cache && chunkWritten > 0);
-
-               if (cache) {
-                       /* Hoosterman, disk full while writing cache out. */
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR("yaffs tragedy: no space during cache write" TENDSTR)));
-
-               }
-       }
-
-}
-
-/*yaffs_FlushEntireDeviceCache(dev)
- *
- *
- */
-
-void yaffs_FlushEntireDeviceCache(yaffs_Device *dev)
-{
-       yaffs_Object *obj;
-       int nCaches = dev->nShortOpCaches;
-       int i;
-
-       /* Find a dirty object in the cache and flush it...
-        * until there are no further dirty objects.
-        */
-       do {
-               obj = NULL;
-               for( i = 0; i < nCaches && !obj; i++) {
-                       if (dev->srCache[i].object &&
-                           dev->srCache[i].dirty)
-                               obj = dev->srCache[i].object;
-
-               }
-               if(obj)
-                       yaffs_FlushFilesChunkCache(obj);
-
-       } while(obj);
-
-}
-
-
-/* Grab us a cache chunk for use.
- * First look for an empty one.
- * Then look for the least recently used non-dirty one.
- * Then look for the least recently used dirty one...., flush and look again.
- */
-static yaffs_ChunkCache *yaffs_GrabChunkCacheWorker(yaffs_Device * dev)
-{
-       int i;
-       int usage;
-       int theOne;
-
-       if (dev->nShortOpCaches > 0) {
-               for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (!dev->srCache[i].object)
-                               return &dev->srCache[i];
-               }
-
-               return NULL;
-
-               theOne = -1;
-               usage = 0;      /* just to stop the compiler grizzling */
-
-               for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (!dev->srCache[i].dirty &&
-                           ((dev->srCache[i].lastUse < usage && theOne >= 0) ||
-                            theOne < 0)) {
-                               usage = dev->srCache[i].lastUse;
-                               theOne = i;
-                       }
-               }
-
-
-               return theOne >= 0 ? &dev->srCache[theOne] : NULL;
-       } else {
-               return NULL;
-       }
-
-}
-
-static yaffs_ChunkCache *yaffs_GrabChunkCache(yaffs_Device * dev)
-{
-       yaffs_ChunkCache *cache;
-       yaffs_Object *theObj;
-       int usage;
-       int i;
-       int pushout;
-
-       if (dev->nShortOpCaches > 0) {
-               /* Try find a non-dirty one... */
-
-               cache = yaffs_GrabChunkCacheWorker(dev);
-
-               if (!cache) {
-                       /* They were all dirty, find the last recently used object and flush
-                        * its cache, then  find again.
-                        * NB what's here is not very accurate, we actually flush the object
-                        * the last recently used page.
-                        */
-
-                       /* With locking we can't assume we can use entry zero */
-
-                       theObj = NULL;
-                       usage = -1;
-                       cache = NULL;
-                       pushout = -1;
-
-                       for (i = 0; i < dev->nShortOpCaches; i++) {
-                               if (dev->srCache[i].object &&
-                                   !dev->srCache[i].locked &&
-                                   (dev->srCache[i].lastUse < usage || !cache))
-                               {
-                                       usage = dev->srCache[i].lastUse;
-                                       theObj = dev->srCache[i].object;
-                                       cache = &dev->srCache[i];
-                                       pushout = i;
-                               }
-                       }
-
-                       if (!cache || cache->dirty) {
-                               /* Flush and try again */
-                               yaffs_FlushFilesChunkCache(theObj);
-                               cache = yaffs_GrabChunkCacheWorker(dev);
-                       }
-
-               }
-               return cache;
-       } else
-               return NULL;
-
-}
-
-/* Find a cached chunk */
-static yaffs_ChunkCache *yaffs_FindChunkCache(const yaffs_Object * obj,
-                                             int chunkId)
-{
-       yaffs_Device *dev = obj->myDev;
-       int i;
-       if (dev->nShortOpCaches > 0) {
-               for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (dev->srCache[i].object == obj &&
-                           dev->srCache[i].chunkId == chunkId) {
-                               dev->cacheHits++;
-
-                               return &dev->srCache[i];
-                       }
-               }
-       }
-       return NULL;
-}
-
-/* Mark the chunk for the least recently used algorithym */
-static void yaffs_UseChunkCache(yaffs_Device * dev, yaffs_ChunkCache * cache,
-                               int isAWrite)
-{
-
-       if (dev->nShortOpCaches > 0) {
-               if (dev->srLastUse < 0 || dev->srLastUse > 100000000) {
-                       /* Reset the cache usages */
-                       int i;
-                       for (i = 1; i < dev->nShortOpCaches; i++) {
-                               dev->srCache[i].lastUse = 0;
-                       }
-                       dev->srLastUse = 0;
-               }
-
-               dev->srLastUse++;
-
-               cache->lastUse = dev->srLastUse;
-
-               if (isAWrite) {
-                       cache->dirty = 1;
-               }
-       }
-}
-
-/* Invalidate a single cache page.
- * Do this when a whole page gets written,
- * ie the short cache for this page is no longer valid.
- */
-static void yaffs_InvalidateChunkCache(yaffs_Object * object, int chunkId)
-{
-       if (object->myDev->nShortOpCaches > 0) {
-               yaffs_ChunkCache *cache = yaffs_FindChunkCache(object, chunkId);
-
-               if (cache) {
-                       cache->object = NULL;
-               }
-       }
-}
-
-/* Invalidate all the cache pages associated with this object
- * Do this whenever ther file is deleted or resized.
- */
-static void yaffs_InvalidateWholeChunkCache(yaffs_Object * in)
-{
-       int i;
-       yaffs_Device *dev = in->myDev;
-
-       if (dev->nShortOpCaches > 0) {
-               /* Invalidate it. */
-               for (i = 0; i < dev->nShortOpCaches; i++) {
-                       if (dev->srCache[i].object == in) {
-                               dev->srCache[i].object = NULL;
-                       }
-               }
-       }
-}
-
-/*--------------------- Checkpointing --------------------*/
-
-
-static int yaffs_WriteCheckpointValidityMarker(yaffs_Device *dev,int head)
-{
-       yaffs_CheckpointValidity cp;
-
-       memset(&cp,0,sizeof(cp));
-
-       cp.structType = sizeof(cp);
-       cp.magic = YAFFS_MAGIC;
-       cp.version = YAFFS_CHECKPOINT_VERSION;
-       cp.head = (head) ? 1 : 0;
-
-       return (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp))?
-               1 : 0;
-}
-
-static int yaffs_ReadCheckpointValidityMarker(yaffs_Device *dev, int head)
-{
-       yaffs_CheckpointValidity cp;
-       int ok;
-
-       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-
-       if(ok)
-               ok = (cp.structType == sizeof(cp)) &&
-                    (cp.magic == YAFFS_MAGIC) &&
-                    (cp.version == YAFFS_CHECKPOINT_VERSION) &&
-                    (cp.head == ((head) ? 1 : 0));
-       return ok ? 1 : 0;
-}
-
-static void yaffs_DeviceToCheckpointDevice(yaffs_CheckpointDevice *cp,
-                                          yaffs_Device *dev)
-{
-       cp->nErasedBlocks = dev->nErasedBlocks;
-       cp->allocationBlock = dev->allocationBlock;
-       cp->allocationPage = dev->allocationPage;
-       cp->nFreeChunks = dev->nFreeChunks;
-
-       cp->nDeletedFiles = dev->nDeletedFiles;
-       cp->nUnlinkedFiles = dev->nUnlinkedFiles;
-       cp->nBackgroundDeletions = dev->nBackgroundDeletions;
-       cp->sequenceNumber = dev->sequenceNumber;
-       cp->oldestDirtySequence = dev->oldestDirtySequence;
-
-}
-
-static void yaffs_CheckpointDeviceToDevice(yaffs_Device *dev,
-                                          yaffs_CheckpointDevice *cp)
-{
-       dev->nErasedBlocks = cp->nErasedBlocks;
-       dev->allocationBlock = cp->allocationBlock;
-       dev->allocationPage = cp->allocationPage;
-       dev->nFreeChunks = cp->nFreeChunks;
-
-       dev->nDeletedFiles = cp->nDeletedFiles;
-       dev->nUnlinkedFiles = cp->nUnlinkedFiles;
-       dev->nBackgroundDeletions = cp->nBackgroundDeletions;
-       dev->sequenceNumber = cp->sequenceNumber;
-       dev->oldestDirtySequence = cp->oldestDirtySequence;
-}
-
-
-static int yaffs_WriteCheckpointDevice(yaffs_Device *dev)
-{
-       yaffs_CheckpointDevice cp;
-       __u32 nBytes;
-       __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
-
-       int ok;
-
-       /* Write device runtime values*/
-       yaffs_DeviceToCheckpointDevice(&cp,dev);
-       cp.structType = sizeof(cp);
-
-       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
-       /* Write block info */
-       if(ok) {
-               nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-               ok = (yaffs_CheckpointWrite(dev,dev->blockInfo,nBytes) == nBytes);
-       }
-
-       /* Write chunk bits */
-       if(ok) {
-               nBytes = nBlocks * dev->chunkBitmapStride;
-               ok = (yaffs_CheckpointWrite(dev,dev->chunkBits,nBytes) == nBytes);
-       }
-       return   ok ? 1 : 0;
-
-}
-
-static int yaffs_ReadCheckpointDevice(yaffs_Device *dev)
-{
-       yaffs_CheckpointDevice cp;
-       __u32 nBytes;
-       __u32 nBlocks = (dev->internalEndBlock - dev->internalStartBlock + 1);
-
-       int ok;
-
-       ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-       if(!ok)
-               return 0;
-
-       if(cp.structType != sizeof(cp))
-               return 0;
-
-
-       yaffs_CheckpointDeviceToDevice(dev,&cp);
-
-       nBytes = nBlocks * sizeof(yaffs_BlockInfo);
-
-       ok = (yaffs_CheckpointRead(dev,dev->blockInfo,nBytes) == nBytes);
-
-       if(!ok)
-               return 0;
-       nBytes = nBlocks * dev->chunkBitmapStride;
-
-       ok = (yaffs_CheckpointRead(dev,dev->chunkBits,nBytes) == nBytes);
-
-       return ok ? 1 : 0;
-}
-
-static void yaffs_ObjectToCheckpointObject(yaffs_CheckpointObject *cp,
-                                          yaffs_Object *obj)
-{
-
-       cp->objectId = obj->objectId;
-       cp->parentId = (obj->parent) ? obj->parent->objectId : 0;
-       cp->chunkId = obj->chunkId;
-       cp->variantType = obj->variantType;
-       cp->deleted = obj->deleted;
-       cp->softDeleted = obj->softDeleted;
-       cp->unlinked = obj->unlinked;
-       cp->fake = obj->fake;
-       cp->renameAllowed = obj->renameAllowed;
-       cp->unlinkAllowed = obj->unlinkAllowed;
-       cp->serial = obj->serial;
-       cp->nDataChunks = obj->nDataChunks;
-
-       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
-               cp->fileSizeOrEquivalentObjectId = obj->variant.fileVariant.fileSize;
-       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
-               cp->fileSizeOrEquivalentObjectId = obj->variant.hardLinkVariant.equivalentObjectId;
-}
-
-static void yaffs_CheckpointObjectToObject( yaffs_Object *obj,yaffs_CheckpointObject *cp)
-{
-
-       yaffs_Object *parent;
-
-       obj->objectId = cp->objectId;
-
-       if(cp->parentId)
-               parent = yaffs_FindOrCreateObjectByNumber(
-                                       obj->myDev,
-                                       cp->parentId,
-                                       YAFFS_OBJECT_TYPE_DIRECTORY);
-       else
-               parent = NULL;
-
-       if(parent)
-               yaffs_AddObjectToDirectory(parent, obj);
-
-       obj->chunkId = cp->chunkId;
-       obj->variantType = cp->variantType;
-       obj->deleted = cp->deleted;
-       obj->softDeleted = cp->softDeleted;
-       obj->unlinked = cp->unlinked;
-       obj->fake = cp->fake;
-       obj->renameAllowed = cp->renameAllowed;
-       obj->unlinkAllowed = cp->unlinkAllowed;
-       obj->serial = cp->serial;
-       obj->nDataChunks = cp->nDataChunks;
-
-       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE)
-               obj->variant.fileVariant.fileSize = cp->fileSizeOrEquivalentObjectId;
-       else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK)
-               obj->variant.hardLinkVariant.equivalentObjectId = cp->fileSizeOrEquivalentObjectId;
-
-       if(obj->objectId >= YAFFS_NOBJECT_BUCKETS)
-               obj->lazyLoaded = 1;
-}
-
-
-
-static int yaffs_CheckpointTnodeWorker(yaffs_Object * in, yaffs_Tnode * tn,
-                                       __u32 level, int chunkOffset)
-{
-       int i;
-       yaffs_Device *dev = in->myDev;
-       int ok = 1;
-       int nTnodeBytes = (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8;
-
-       if (tn) {
-               if (level > 0) {
-
-                       for (i = 0; i < YAFFS_NTNODES_INTERNAL && ok; i++){
-                               if (tn->internal[i]) {
-                                       ok = yaffs_CheckpointTnodeWorker(in,
-                                                       tn->internal[i],
-                                                       level - 1,
-                                                       (chunkOffset<<YAFFS_TNODES_INTERNAL_BITS) + i);
-                               }
-                       }
-               } else if (level == 0) {
-                       __u32 baseOffset = chunkOffset <<  YAFFS_TNODES_LEVEL0_BITS;
-                       /* printf("write tnode at %d\n",baseOffset); */
-                       ok = (yaffs_CheckpointWrite(dev,&baseOffset,sizeof(baseOffset)) == sizeof(baseOffset));
-                       if(ok)
-                               ok = (yaffs_CheckpointWrite(dev,tn,nTnodeBytes) == nTnodeBytes);
-               }
-       }
-
-       return ok;
-
-}
-
-static int yaffs_WriteCheckpointTnodes(yaffs_Object *obj)
-{
-       __u32 endMarker = ~0;
-       int ok = 1;
-
-       if(obj->variantType == YAFFS_OBJECT_TYPE_FILE){
-               ok = yaffs_CheckpointTnodeWorker(obj,
-                                           obj->variant.fileVariant.top,
-                                           obj->variant.fileVariant.topLevel,
-                                           0);
-               if(ok)
-                       ok = (yaffs_CheckpointWrite(obj->myDev,&endMarker,sizeof(endMarker)) ==
-                               sizeof(endMarker));
-       }
-
-       return ok ? 1 : 0;
-}
-
-static int yaffs_ReadCheckpointTnodes(yaffs_Object *obj)
-{
-       __u32 baseChunk;
-       int ok = 1;
-       yaffs_Device *dev = obj->myDev;
-       yaffs_FileStructure *fileStructPtr = &obj->variant.fileVariant;
-       yaffs_Tnode *tn;
-       int nread = 0;
-
-       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-
-       while(ok && (~baseChunk)){
-               nread++;
-               /* Read level 0 tnode */
-
-
-               /* printf("read  tnode at %d\n",baseChunk); */
-               tn = yaffs_GetTnodeRaw(dev);
-               if(tn)
-                       ok = (yaffs_CheckpointRead(dev,tn,(dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8) ==
-                             (dev->tnodeWidth * YAFFS_NTNODES_LEVEL0)/8);
-               else
-                       ok = 0;
-
-               if(tn && ok){
-                       ok = yaffs_AddOrFindLevel0Tnode(dev,
-                                                       fileStructPtr,
-                                                       baseChunk,
-                                                       tn) ? 1 : 0;
-
-               }
-
-               if(ok)
-                       ok = (yaffs_CheckpointRead(dev,&baseChunk,sizeof(baseChunk)) == sizeof(baseChunk));
-
-       }
-
-       T(YAFFS_TRACE_CHECKPOINT,(
-               TSTR("Checkpoint read tnodes %d records, last %d. ok %d" TENDSTR),
-               nread,baseChunk,ok));
-
-       return ok ? 1 : 0;
-}
-
-
-static int yaffs_WriteCheckpointObjects(yaffs_Device *dev)
-{
-       yaffs_Object *obj;
-       yaffs_CheckpointObject cp;
-       int i;
-       int ok = 1;
-       struct list_head *lh;
-
-
-       /* Iterate through the objects in each hash entry,
-        * dumping them to the checkpointing stream.
-        */
-
-        for(i = 0; ok &&  i <  YAFFS_NOBJECT_BUCKETS; i++){
-               list_for_each(lh, &dev->objectBucket[i].list) {
-                       if (lh) {
-                               obj = list_entry(lh, yaffs_Object, hashLink);
-                               if (!obj->deferedFree) {
-                                       yaffs_ObjectToCheckpointObject(&cp,obj);
-                                       cp.structType = sizeof(cp);
-
-                                       T(YAFFS_TRACE_CHECKPOINT,(
-                                               TSTR("Checkpoint write object %d parent %d type %d chunk %d obj addr %x" TENDSTR),
-                                               cp.objectId,cp.parentId,cp.variantType,cp.chunkId,(unsigned) obj));
-
-                                       ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
-                                       if(ok && obj->variantType == YAFFS_OBJECT_TYPE_FILE){
-                                               ok = yaffs_WriteCheckpointTnodes(obj);
-                                       }
-                               }
-                       }
-               }
-        }
-
-        /* Dump end of list */
-       memset(&cp,0xFF,sizeof(yaffs_CheckpointObject));
-       cp.structType = sizeof(cp);
-
-       if(ok)
-               ok = (yaffs_CheckpointWrite(dev,&cp,sizeof(cp)) == sizeof(cp));
-
-       return ok ? 1 : 0;
-}
-
-static int yaffs_ReadCheckpointObjects(yaffs_Device *dev)
-{
-       yaffs_Object *obj;
-       yaffs_CheckpointObject cp;
-       int ok = 1;
-       int done = 0;
-       yaffs_Object *hardList = NULL;
-
-       while(ok && !done) {
-               ok = (yaffs_CheckpointRead(dev,&cp,sizeof(cp)) == sizeof(cp));
-               if(cp.structType != sizeof(cp)) {
-                       T(YAFFS_TRACE_CHECKPOINT,(TSTR("struct size %d instead of %d ok %d"TENDSTR),
-                               cp.structType,sizeof(cp),ok));
-                       ok = 0;
-               }
-
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("Checkpoint read object %d parent %d type %d chunk %d " TENDSTR),
-                       cp.objectId,cp.parentId,cp.variantType,cp.chunkId));
-
-               if(ok && cp.objectId == ~0)
-                       done = 1;
-               else if(ok){
-                       obj = yaffs_FindOrCreateObjectByNumber(dev,cp.objectId, cp.variantType);
-                       if(obj) {
-                               yaffs_CheckpointObjectToObject(obj,&cp);
-                               if(obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
-                                       ok = yaffs_ReadCheckpointTnodes(obj);
-                               } else if(obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
-                                       obj->hardLinks.next =
-                                                   (struct list_head *)
-                                                   hardList;
-                                       hardList = obj;
-                               }
-
-                       }
-               }
-       }
-
-       if(ok)
-               yaffs_HardlinkFixup(dev,hardList);
-
-       return ok ? 1 : 0;
-}
-
-static int yaffs_WriteCheckpointSum(yaffs_Device *dev)
-{
-       __u32 checkpointSum;
-       int ok;
-
-       yaffs_GetCheckpointSum(dev,&checkpointSum);
-
-       ok = (yaffs_CheckpointWrite(dev,&checkpointSum,sizeof(checkpointSum)) == sizeof(checkpointSum));
-
-       if(!ok)
-               return 0;
-
-       return 1;
-}
-
-static int yaffs_ReadCheckpointSum(yaffs_Device *dev)
-{
-       __u32 checkpointSum0;
-       __u32 checkpointSum1;
-       int ok;
-
-       yaffs_GetCheckpointSum(dev,&checkpointSum0);
-
-       ok = (yaffs_CheckpointRead(dev,&checkpointSum1,sizeof(checkpointSum1)) == sizeof(checkpointSum1));
-
-       if(!ok)
-               return 0;
-
-       if(checkpointSum0 != checkpointSum1)
-               return 0;
-
-       return 1;
-}
-
-
-static int yaffs_WriteCheckpointData(yaffs_Device *dev)
-{
-
-       int ok = 1;
-
-       if(dev->skipCheckpointWrite || !dev->isYaffs2){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint write" TENDSTR)));
-               ok = 0;
-       }
-
-       if(ok)
-               ok = yaffs_CheckpointOpen(dev,1);
-
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
-               ok = yaffs_WriteCheckpointValidityMarker(dev,1);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint device" TENDSTR)));
-               ok = yaffs_WriteCheckpointDevice(dev);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint objects" TENDSTR)));
-               ok = yaffs_WriteCheckpointObjects(dev);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("write checkpoint validity" TENDSTR)));
-               ok = yaffs_WriteCheckpointValidityMarker(dev,0);
-       }
-
-       if(ok){
-               ok = yaffs_WriteCheckpointSum(dev);
-       }
-
-
-       if(!yaffs_CheckpointClose(dev))
-                ok = 0;
-
-       if(ok)
-               dev->isCheckpointed = 1;
-        else
-               dev->isCheckpointed = 0;
-
-       return dev->isCheckpointed;
-}
-
-static int yaffs_ReadCheckpointData(yaffs_Device *dev)
-{
-       int ok = 1;
-
-       if(dev->skipCheckpointRead || !dev->isYaffs2){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("skipping checkpoint read" TENDSTR)));
-               ok = 0;
-       }
-
-       if(ok)
-               ok = yaffs_CheckpointOpen(dev,0); /* open for read */
-
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
-               ok = yaffs_ReadCheckpointValidityMarker(dev,1);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint device" TENDSTR)));
-               ok = yaffs_ReadCheckpointDevice(dev);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint objects" TENDSTR)));
-               ok = yaffs_ReadCheckpointObjects(dev);
-       }
-       if(ok){
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint validity" TENDSTR)));
-               ok = yaffs_ReadCheckpointValidityMarker(dev,0);
-       }
-
-       if(ok){
-               ok = yaffs_ReadCheckpointSum(dev);
-               T(YAFFS_TRACE_CHECKPOINT,(TSTR("read checkpoint checksum %d" TENDSTR),ok));
-       }
-
-       if(!yaffs_CheckpointClose(dev))
-               ok = 0;
-
-       if(ok)
-               dev->isCheckpointed = 1;
-        else
-               dev->isCheckpointed = 0;
-
-       return ok ? 1 : 0;
-
-}
-
-static void yaffs_InvalidateCheckpoint(yaffs_Device *dev)
-{
-       if(dev->isCheckpointed ||
-          dev->blocksInCheckpoint > 0){
-               dev->isCheckpointed = 0;
-               yaffs_CheckpointInvalidateStream(dev);
-               if(dev->superBlock && dev->markSuperBlockDirty)
-                       dev->markSuperBlockDirty(dev->superBlock);
-       }
-}
-
-
-int yaffs_CheckpointSave(yaffs_Device *dev)
-{
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("save entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
-       yaffs_VerifyObjects(dev);
-       yaffs_VerifyBlocks(dev);
-       yaffs_VerifyFreeChunks(dev);
-
-       if(!dev->isCheckpointed) {
-               yaffs_InvalidateCheckpoint(dev);
-               yaffs_WriteCheckpointData(dev);
-       }
-
-       T(YAFFS_TRACE_ALWAYS,(TSTR("save exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
-       return dev->isCheckpointed;
-}
-
-int yaffs_CheckpointRestore(yaffs_Device *dev)
-{
-       int retval;
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore entry: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
-       retval = yaffs_ReadCheckpointData(dev);
-
-       if(dev->isCheckpointed){
-               yaffs_VerifyObjects(dev);
-               yaffs_VerifyBlocks(dev);
-               yaffs_VerifyFreeChunks(dev);
-       }
-
-       T(YAFFS_TRACE_CHECKPOINT,(TSTR("restore exit: isCheckpointed %d"TENDSTR),dev->isCheckpointed));
-
-       return retval;
-}
-
-/*--------------------- File read/write ------------------------
- * Read and write have very similar structures.
- * In general the read/write has three parts to it
- * An incomplete chunk to start with (if the read/write is not chunk-aligned)
- * Some complete chunks
- * An incomplete chunk to end off with
- *
- * Curve-balls: the first chunk might also be the last chunk.
- */
-
-int yaffs_ReadDataFromFile(yaffs_Object * in, __u8 * buffer, loff_t offset,
-                          int nBytes)
-{
-
-       int chunk;
-       int start;
-       int nToCopy;
-       int n = nBytes;
-       int nDone = 0;
-       yaffs_ChunkCache *cache;
-
-       yaffs_Device *dev;
-
-       dev = in->myDev;
-
-       while (n > 0) {
-               //chunk = offset / dev->nDataBytesPerChunk + 1;
-               //start = offset % dev->nDataBytesPerChunk;
-               yaffs_AddrToChunk(dev,offset,&chunk,&start);
-               chunk++;
-
-               /* OK now check for the curveball where the start and end are in
-                * the same chunk.
-                */
-               if ((start + n) < dev->nDataBytesPerChunk) {
-                       nToCopy = n;
-               } else {
-                       nToCopy = dev->nDataBytesPerChunk - start;
-               }
-
-               cache = yaffs_FindChunkCache(in, chunk);
-
-               /* If the chunk is already in the cache or it is less than a whole chunk
-                * then use the cache (if there is caching)
-                * else bypass the cache.
-                */
-               if (cache || nToCopy != dev->nDataBytesPerChunk) {
-                       if (dev->nShortOpCaches > 0) {
-
-                               /* If we can't find the data in the cache, then load it up. */
-
-                               if (!cache) {
-                                       cache = yaffs_GrabChunkCache(in->myDev);
-                                       cache->object = in;
-                                       cache->chunkId = chunk;
-                                       cache->dirty = 0;
-                                       cache->locked = 0;
-                                       yaffs_ReadChunkDataFromObject(in, chunk,
-                                                                     cache->
-                                                                     data);
-                                       cache->nBytes = 0;
-                               }
-
-                               yaffs_UseChunkCache(dev, cache, 0);
-
-                               cache->locked = 1;
-
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_UnlockYAFFS(TRUE);
-#endif
-                               memcpy(buffer, &cache->data[start], nToCopy);
-
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_LockYAFFS(TRUE);
-#endif
-                               cache->locked = 0;
-                       } else {
-                               /* Read into the local buffer then copy..*/
-
-                               __u8 *localBuffer =
-                                   yaffs_GetTempBuffer(dev, __LINE__);
-                               yaffs_ReadChunkDataFromObject(in, chunk,
-                                                             localBuffer);
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_UnlockYAFFS(TRUE);
-#endif
-                               memcpy(buffer, &localBuffer[start], nToCopy);
-
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_LockYAFFS(TRUE);
-#endif
-                               yaffs_ReleaseTempBuffer(dev, localBuffer,
-                                                       __LINE__);
-                       }
-
-               } else {
-#ifdef CONFIG_YAFFS_WINCE
-                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
-
-                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
-                        * This is because we otherwise screw up WinCE's memory mapper
-                        */
-                       yaffs_ReadChunkDataFromObject(in, chunk, localBuffer);
-
-#ifdef CONFIG_YAFFS_WINCE
-                       yfsd_UnlockYAFFS(TRUE);
-#endif
-                       memcpy(buffer, localBuffer, dev->nDataBytesPerChunk);
-
-#ifdef CONFIG_YAFFS_WINCE
-                       yfsd_LockYAFFS(TRUE);
-                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
-#endif
-
-#else
-                       /* A full chunk. Read directly into the supplied buffer. */
-                       yaffs_ReadChunkDataFromObject(in, chunk, buffer);
-#endif
-               }
-
-               n -= nToCopy;
-               offset += nToCopy;
-               buffer += nToCopy;
-               nDone += nToCopy;
-
-       }
-
-       return nDone;
-}
-
-int yaffs_WriteDataToFile(yaffs_Object * in, const __u8 * buffer, loff_t offset,
-                         int nBytes, int writeThrough)
-{
-
-       int chunk;
-       int start;
-       int nToCopy;
-       int n = nBytes;
-       int nDone = 0;
-       int nToWriteBack;
-       int startOfWrite = offset;
-       int chunkWritten = 0;
-       int nBytesRead;
-
-       yaffs_Device *dev;
-
-       dev = in->myDev;
-
-       while (n > 0 && chunkWritten >= 0) {
-               //chunk = offset / dev->nDataBytesPerChunk + 1;
-               //start = offset % dev->nDataBytesPerChunk;
-               yaffs_AddrToChunk(dev,offset,&chunk,&start);
-               chunk++;
-
-               /* OK now check for the curveball where the start and end are in
-                * the same chunk.
-                */
-
-               if ((start + n) < dev->nDataBytesPerChunk) {
-                       nToCopy = n;
-
-                       /* Now folks, to calculate how many bytes to write back....
-                        * If we're overwriting and not writing to then end of file then
-                        * we need to write back as much as was there before.
-                        */
-
-                       nBytesRead =
-                           in->variant.fileVariant.fileSize -
-                           ((chunk - 1) * dev->nDataBytesPerChunk);
-
-                       if (nBytesRead > dev->nDataBytesPerChunk) {
-                               nBytesRead = dev->nDataBytesPerChunk;
-                       }
-
-                       nToWriteBack =
-                           (nBytesRead >
-                            (start + n)) ? nBytesRead : (start + n);
-
-               } else {
-                       nToCopy = dev->nDataBytesPerChunk - start;
-                       nToWriteBack = dev->nDataBytesPerChunk;
-               }
-
-               if (nToCopy != dev->nDataBytesPerChunk) {
-                       /* An incomplete start or end chunk (or maybe both start and end chunk) */
-                       if (dev->nShortOpCaches > 0) {
-                               yaffs_ChunkCache *cache;
-                               /* If we can't find the data in the cache, then load the cache */
-                               cache = yaffs_FindChunkCache(in, chunk);
-
-                               if (!cache
-                                   && yaffs_CheckSpaceForAllocation(in->
-                                                                    myDev)) {
-                                       cache = yaffs_GrabChunkCache(in->myDev);
-                                       cache->object = in;
-                                       cache->chunkId = chunk;
-                                       cache->dirty = 0;
-                                       cache->locked = 0;
-                                       yaffs_ReadChunkDataFromObject(in, chunk,
-                                                                     cache->
-                                                                     data);
-                               }
-                               else if(cache &&
-                                       !cache->dirty &&
-                                       !yaffs_CheckSpaceForAllocation(in->myDev)){
-                                       /* Drop the cache if it was a read cache item and
-                                        * no space check has been made for it.
-                                        */
-                                        cache = NULL;
-                               }
-
-                               if (cache) {
-                                       yaffs_UseChunkCache(dev, cache, 1);
-                                       cache->locked = 1;
-#ifdef CONFIG_YAFFS_WINCE
-                                       yfsd_UnlockYAFFS(TRUE);
-#endif
-
-                                       memcpy(&cache->data[start], buffer,
-                                              nToCopy);
-
-#ifdef CONFIG_YAFFS_WINCE
-                                       yfsd_LockYAFFS(TRUE);
-#endif
-                                       cache->locked = 0;
-                                       cache->nBytes = nToWriteBack;
-
-                                       if (writeThrough) {
-                                               chunkWritten =
-                                                   yaffs_WriteChunkDataToObject
-                                                   (cache->object,
-                                                    cache->chunkId,
-                                                    cache->data, cache->nBytes,
-                                                    1);
-                                               cache->dirty = 0;
-                                       }
-
-                               } else {
-                                       chunkWritten = -1;      /* fail the write */
-                               }
-                       } else {
-                               /* An incomplete start or end chunk (or maybe both start and end chunk)
-                                * Read into the local buffer then copy, then copy over and write back.
-                                */
-
-                               __u8 *localBuffer =
-                                   yaffs_GetTempBuffer(dev, __LINE__);
-
-                               yaffs_ReadChunkDataFromObject(in, chunk,
-                                                             localBuffer);
-
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_UnlockYAFFS(TRUE);
-#endif
-
-                               memcpy(&localBuffer[start], buffer, nToCopy);
-
-#ifdef CONFIG_YAFFS_WINCE
-                               yfsd_LockYAFFS(TRUE);
-#endif
-                               chunkWritten =
-                                   yaffs_WriteChunkDataToObject(in, chunk,
-                                                                localBuffer,
-                                                                nToWriteBack,
-                                                                0);
-
-                               yaffs_ReleaseTempBuffer(dev, localBuffer,
-                                                       __LINE__);
-
-                       }
-
-               } else {
-
-#ifdef CONFIG_YAFFS_WINCE
-                       /* Under WinCE can't do direct transfer. Need to use a local buffer.
-                        * This is because we otherwise screw up WinCE's memory mapper
-                        */
-                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
-#ifdef CONFIG_YAFFS_WINCE
-                       yfsd_UnlockYAFFS(TRUE);
-#endif
-                       memcpy(localBuffer, buffer, dev->nDataBytesPerChunk);
-#ifdef CONFIG_YAFFS_WINCE
-                       yfsd_LockYAFFS(TRUE);
-#endif
-                       chunkWritten =
-                           yaffs_WriteChunkDataToObject(in, chunk, localBuffer,
-                                                        dev->nDataBytesPerChunk,
-                                                        0);
-                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
-#else
-                       /* A full chunk. Write directly from the supplied buffer. */
-                       chunkWritten =
-                           yaffs_WriteChunkDataToObject(in, chunk, buffer,
-                                                        dev->nDataBytesPerChunk,
-                                                        0);
-#endif
-                       /* Since we've overwritten the cached data, we better invalidate it. */
-                       yaffs_InvalidateChunkCache(in, chunk);
-               }
-
-               if (chunkWritten >= 0) {
-                       n -= nToCopy;
-                       offset += nToCopy;
-                       buffer += nToCopy;
-                       nDone += nToCopy;
-               }
-
-       }
-
-       /* Update file object */
-
-       if ((startOfWrite + nDone) > in->variant.fileVariant.fileSize) {
-               in->variant.fileVariant.fileSize = (startOfWrite + nDone);
-       }
-
-       in->dirty = 1;
-
-       return nDone;
-}
-
-
-/* ---------------------- File resizing stuff ------------------ */
-
-static void yaffs_PruneResizedChunks(yaffs_Object * in, int newSize)
-{
-
-       yaffs_Device *dev = in->myDev;
-       int oldFileSize = in->variant.fileVariant.fileSize;
-
-       int lastDel = 1 + (oldFileSize - 1) / dev->nDataBytesPerChunk;
-
-       int startDel = 1 + (newSize + dev->nDataBytesPerChunk - 1) /
-           dev->nDataBytesPerChunk;
-       int i;
-       int chunkId;
-
-       /* Delete backwards so that we don't end up with holes if
-        * power is lost part-way through the operation.
-        */
-       for (i = lastDel; i >= startDel; i--) {
-               /* NB this could be optimised somewhat,
-                * eg. could retrieve the tags and write them without
-                * using yaffs_DeleteChunk
-                */
-
-               chunkId = yaffs_FindAndDeleteChunkInFile(in, i, NULL);
-               if (chunkId > 0) {
-                       if (chunkId <
-                           (dev->internalStartBlock * dev->nChunksPerBlock)
-                           || chunkId >=
-                           ((dev->internalEndBlock +
-                             1) * dev->nChunksPerBlock)) {
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR("Found daft chunkId %d for %d" TENDSTR),
-                                  chunkId, i));
-                       } else {
-                               in->nDataChunks--;
-                               yaffs_DeleteChunk(dev, chunkId, 1, __LINE__);
-                       }
-               }
-       }
-
-}
-
-int yaffs_ResizeFile(yaffs_Object * in, loff_t newSize)
-{
-
-       int oldFileSize = in->variant.fileVariant.fileSize;
-       int newSizeOfPartialChunk;
-       int newFullChunks;
-
-       yaffs_Device *dev = in->myDev;
-
-       yaffs_AddrToChunk(dev, newSize, &newFullChunks, &newSizeOfPartialChunk);
-
-       yaffs_FlushFilesChunkCache(in);
-       yaffs_InvalidateWholeChunkCache(in);
-
-       yaffs_CheckGarbageCollection(dev);
-
-       if (in->variantType != YAFFS_OBJECT_TYPE_FILE) {
-               return yaffs_GetFileSize(in);
-       }
-
-       if (newSize == oldFileSize) {
-               return oldFileSize;
-       }
-
-       if (newSize < oldFileSize) {
-
-               yaffs_PruneResizedChunks(in, newSize);
-
-               if (newSizeOfPartialChunk != 0) {
-                       int lastChunk = 1 + newFullChunks;
-
-                       __u8 *localBuffer = yaffs_GetTempBuffer(dev, __LINE__);
-
-                       /* Got to read and rewrite the last chunk with its new size and zero pad */
-                       yaffs_ReadChunkDataFromObject(in, lastChunk,
-                                                     localBuffer);
-
-                       memset(localBuffer + newSizeOfPartialChunk, 0,
-                              dev->nDataBytesPerChunk - newSizeOfPartialChunk);
-
-                       yaffs_WriteChunkDataToObject(in, lastChunk, localBuffer,
-                                                    newSizeOfPartialChunk, 1);
-
-                       yaffs_ReleaseTempBuffer(dev, localBuffer, __LINE__);
-               }
-
-               in->variant.fileVariant.fileSize = newSize;
-
-               yaffs_PruneFileStructure(dev, &in->variant.fileVariant);
-       } else {
-               /* newsSize > oldFileSize */
-               in->variant.fileVariant.fileSize = newSize;
-       }
-
-
-
-       /* Write a new object header.
-        * show we've shrunk the file, if need be
-        * Do this only if the file is not in the deleted directories.
-        */
-       if (in->parent->objectId != YAFFS_OBJECTID_UNLINKED &&
-           in->parent->objectId != YAFFS_OBJECTID_DELETED) {
-               yaffs_UpdateObjectHeader(in, NULL, 0,
-                                        (newSize < oldFileSize) ? 1 : 0, 0);
-       }
-
-       return newSize;
-}
-
-loff_t yaffs_GetFileSize(yaffs_Object * obj)
-{
-       obj = yaffs_GetEquivalentObject(obj);
-
-       switch (obj->variantType) {
-       case YAFFS_OBJECT_TYPE_FILE:
-               return obj->variant.fileVariant.fileSize;
-       case YAFFS_OBJECT_TYPE_SYMLINK:
-               return yaffs_strlen(obj->variant.symLinkVariant.alias);
-       default:
-               return 0;
-       }
-}
-
-
-
-int yaffs_FlushFile(yaffs_Object * in, int updateTime)
-{
-       int retVal;
-       if (in->dirty) {
-               yaffs_FlushFilesChunkCache(in);
-               if (updateTime) {
-#ifdef CONFIG_YAFFS_WINCE
-                       yfsd_WinFileTimeNow(in->win_mtime);
-#else
-
-                       in->yst_mtime = Y_CURRENT_TIME;
-
-#endif
-               }
-
-               retVal =
-                   (yaffs_UpdateObjectHeader(in, NULL, 0, 0, 0) >=
-                    0) ? YAFFS_OK : YAFFS_FAIL;
-       } else {
-               retVal = YAFFS_OK;
-       }
-
-       return retVal;
-
-}
-
-static int yaffs_DoGenericObjectDeletion(yaffs_Object * in)
-{
-
-       /* First off, invalidate the file's data in the cache, without flushing. */
-       yaffs_InvalidateWholeChunkCache(in);
-
-       if (in->myDev->isYaffs2 && (in->parent != in->myDev->deletedDir)) {
-               /* Move to the unlinked directory so we have a record that it was deleted. */
-               yaffs_ChangeObjectName(in, in->myDev->deletedDir,"deleted", 0, 0);
-
-       }
-
-       yaffs_RemoveObjectFromDirectory(in);
-       yaffs_DeleteChunk(in->myDev, in->chunkId, 1, __LINE__);
-       in->chunkId = -1;
-
-       yaffs_FreeObject(in);
-       return YAFFS_OK;
-
-}
-
-/* yaffs_DeleteFile deletes the whole file data
- * and the inode associated with the file.
- * It does not delete the links associated with the file.
- */
-static int yaffs_UnlinkFile(yaffs_Object * in)
-{
-
-       int retVal;
-       int immediateDeletion = 0;
-
-       if (1) {
-#ifdef __KERNEL__
-               if (!in->myInode) {
-                       immediateDeletion = 1;
-
-               }
-#else
-               if (in->inUse <= 0) {
-                       immediateDeletion = 1;
-
-               }
-#endif
-               if (immediateDeletion) {
-                       retVal =
-                           yaffs_ChangeObjectName(in, in->myDev->deletedDir,
-                                                  "deleted", 0, 0);
-                       T(YAFFS_TRACE_TRACING,
-                         (TSTR("yaffs: immediate deletion of file %d" TENDSTR),
-                          in->objectId));
-                       in->deleted = 1;
-                       in->myDev->nDeletedFiles++;
-                       if (0 && in->myDev->isYaffs2) {
-                               yaffs_ResizeFile(in, 0);
-                       }
-                       yaffs_SoftDeleteFile(in);
-               } else {
-                       retVal =
-                           yaffs_ChangeObjectName(in, in->myDev->unlinkedDir,
-                                                  "unlinked", 0, 0);
-               }
-
-       }
-       return retVal;
-}
-
-int yaffs_DeleteFile(yaffs_Object * in)
-{
-       int retVal = YAFFS_OK;
-
-       if (in->nDataChunks > 0) {
-               /* Use soft deletion if there is data in the file */
-               if (!in->unlinked) {
-                       retVal = yaffs_UnlinkFile(in);
-               }
-               if (retVal == YAFFS_OK && in->unlinked && !in->deleted) {
-                       in->deleted = 1;
-                       in->myDev->nDeletedFiles++;
-                       yaffs_SoftDeleteFile(in);
-               }
-               return in->deleted ? YAFFS_OK : YAFFS_FAIL;
-       } else {
-               /* The file has no data chunks so we toss it immediately */
-               yaffs_FreeTnode(in->myDev, in->variant.fileVariant.top);
-               in->variant.fileVariant.top = NULL;
-               yaffs_DoGenericObjectDeletion(in);
-
-               return YAFFS_OK;
-       }
-}
-
-static int yaffs_DeleteDirectory(yaffs_Object * in)
-{
-       /* First check that the directory is empty. */
-       if (list_empty(&in->variant.directoryVariant.children)) {
-               return yaffs_DoGenericObjectDeletion(in);
-       }
-
-       return YAFFS_FAIL;
-
-}
-
-static int yaffs_DeleteSymLink(yaffs_Object * in)
-{
-       YFREE(in->variant.symLinkVariant.alias);
-
-       return yaffs_DoGenericObjectDeletion(in);
-}
-
-static int yaffs_DeleteHardLink(yaffs_Object * in)
-{
-       /* remove this hardlink from the list assocaited with the equivalent
-        * object
-        */
-       list_del(&in->hardLinks);
-       return yaffs_DoGenericObjectDeletion(in);
-}
-
-static void yaffs_DestroyObject(yaffs_Object * obj)
-{
-       switch (obj->variantType) {
-       case YAFFS_OBJECT_TYPE_FILE:
-               yaffs_DeleteFile(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_DIRECTORY:
-               yaffs_DeleteDirectory(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_SYMLINK:
-               yaffs_DeleteSymLink(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_HARDLINK:
-               yaffs_DeleteHardLink(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_SPECIAL:
-               yaffs_DoGenericObjectDeletion(obj);
-               break;
-       case YAFFS_OBJECT_TYPE_UNKNOWN:
-               break;          /* should not happen. */
-       }
-}
-
-static int yaffs_UnlinkWorker(yaffs_Object * obj)
-{
-
-       if (obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
-               return yaffs_DeleteHardLink(obj);
-       } else if (!list_empty(&obj->hardLinks)) {
-               /* Curve ball: We're unlinking an object that has a hardlink.
-                *
-                * This problem arises because we are not strictly following
-                * The Linux link/inode model.
-                *
-                * We can't really delete the object.
-                * Instead, we do the following:
-                * - Select a hardlink.
-                * - Unhook it from the hard links
-                * - Unhook it from its parent directory (so that the rename can work)
-                * - Rename the object to the hardlink's name.
-                * - Delete the hardlink
-                */
-
-               yaffs_Object *hl;
-               int retVal;
-               YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
-
-               hl = list_entry(obj->hardLinks.next, yaffs_Object, hardLinks);
-
-               list_del_init(&hl->hardLinks);
-               list_del_init(&hl->siblings);
-
-               yaffs_GetObjectName(hl, name, YAFFS_MAX_NAME_LENGTH + 1);
-
-               retVal = yaffs_ChangeObjectName(obj, hl->parent, name, 0, 0);
-
-               if (retVal == YAFFS_OK) {
-                       retVal = yaffs_DoGenericObjectDeletion(hl);
-               }
-               return retVal;
-
-       } else {
-               switch (obj->variantType) {
-               case YAFFS_OBJECT_TYPE_FILE:
-                       return yaffs_UnlinkFile(obj);
-                       break;
-               case YAFFS_OBJECT_TYPE_DIRECTORY:
-                       return yaffs_DeleteDirectory(obj);
-                       break;
-               case YAFFS_OBJECT_TYPE_SYMLINK:
-                       return yaffs_DeleteSymLink(obj);
-                       break;
-               case YAFFS_OBJECT_TYPE_SPECIAL:
-                       return yaffs_DoGenericObjectDeletion(obj);
-                       break;
-               case YAFFS_OBJECT_TYPE_HARDLINK:
-               case YAFFS_OBJECT_TYPE_UNKNOWN:
-               default:
-                       return YAFFS_FAIL;
-               }
-       }
-}
-
-
-static int yaffs_UnlinkObject( yaffs_Object *obj)
-{
-
-       if (obj && obj->unlinkAllowed) {
-               return yaffs_UnlinkWorker(obj);
-       }
-
-       return YAFFS_FAIL;
-
-}
-int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name)
-{
-       yaffs_Object *obj;
-
-       obj = yaffs_FindObjectByName(dir, name);
-       return yaffs_UnlinkObject(obj);
-}
-
-/*----------------------- Initialisation Scanning ---------------------- */
-
-static void yaffs_HandleShadowedObject(yaffs_Device * dev, int objId,
-                                      int backwardScanning)
-{
-       yaffs_Object *obj;
-
-       if (!backwardScanning) {
-               /* Handle YAFFS1 forward scanning case
-                * For YAFFS1 we always do the deletion
-                */
-
-       } else {
-               /* Handle YAFFS2 case (backward scanning)
-                * If the shadowed object exists then ignore.
-                */
-               if (yaffs_FindObjectByNumber(dev, objId)) {
-                       return;
-               }
-       }
-
-       /* Let's create it (if it does not exist) assuming it is a file so that it can do shrinking etc.
-        * We put it in unlinked dir to be cleaned up after the scanning
-        */
-       obj =
-           yaffs_FindOrCreateObjectByNumber(dev, objId,
-                                            YAFFS_OBJECT_TYPE_FILE);
-       yaffs_AddObjectToDirectory(dev->unlinkedDir, obj);
-       obj->variant.fileVariant.shrinkSize = 0;
-       obj->valid = 1;         /* So that we don't read any other info for this file */
-
-}
-
-typedef struct {
-       int seq;
-       int block;
-} yaffs_BlockIndex;
-
-
-static void yaffs_HardlinkFixup(yaffs_Device *dev, yaffs_Object *hardList)
-{
-       yaffs_Object *hl;
-       yaffs_Object *in;
-
-       while (hardList) {
-               hl = hardList;
-               hardList = (yaffs_Object *) (hardList->hardLinks.next);
-
-               in = yaffs_FindObjectByNumber(dev,
-                                             hl->variant.hardLinkVariant.
-                                             equivalentObjectId);
-
-               if (in) {
-                       /* Add the hardlink pointers */
-                       hl->variant.hardLinkVariant.equivalentObject = in;
-                       list_add(&hl->hardLinks, &in->hardLinks);
-               } else {
-                       /* Todo Need to report/handle this better.
-                        * Got a problem... hardlink to a non-existant object
-                        */
-                       hl->variant.hardLinkVariant.equivalentObject = NULL;
-                       INIT_LIST_HEAD(&hl->hardLinks);
-
-               }
-
-       }
-
-}
-
-
-
-
-
-static int ybicmp(const void *a, const void *b){
-    register int aseq = ((yaffs_BlockIndex *)a)->seq;
-    register int bseq = ((yaffs_BlockIndex *)b)->seq;
-    register int ablock = ((yaffs_BlockIndex *)a)->block;
-    register int bblock = ((yaffs_BlockIndex *)b)->block;
-    if( aseq == bseq )
-        return ablock - bblock;
-    else
-        return aseq - bseq;
-
-}
-
-static int yaffs_Scan(yaffs_Device * dev)
-{
-       yaffs_ExtendedTags tags;
-       int blk;
-       int blockIterator;
-       int startIterator;
-       int endIterator;
-       int nBlocksToScan = 0;
-       int result;
-
-       int chunk;
-       int c;
-       int deleted;
-       yaffs_BlockState state;
-       yaffs_Object *hardList = NULL;
-       yaffs_BlockInfo *bi;
-       int sequenceNumber;
-       yaffs_ObjectHeader *oh;
-       yaffs_Object *in;
-       yaffs_Object *parent;
-       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-
-       int alloc_failed = 0;
-
-
-       __u8 *chunkData;
-
-       yaffs_BlockIndex *blockIndex = NULL;
-
-       if (dev->isYaffs2) {
-               T(YAFFS_TRACE_SCAN,
-                 (TSTR("yaffs_Scan is not for YAFFS2!" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       //TODO  Throw all the yaffs2 stuuf out of yaffs_Scan since it is only for yaffs1 format.
-
-       T(YAFFS_TRACE_SCAN,
-         (TSTR("yaffs_Scan starts  intstartblk %d intendblk %d..." TENDSTR),
-          dev->internalStartBlock, dev->internalEndBlock));
-
-       chunkData = yaffs_GetTempBuffer(dev, __LINE__);
-
-       dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
-
-       if (dev->isYaffs2) {
-               blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
-               if(!blockIndex)
-                       return YAFFS_FAIL;
-       }
-
-       /* Scan all the blocks to determine their state */
-       for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
-               bi = yaffs_GetBlockInfo(dev, blk);
-               yaffs_ClearChunkBits(dev, blk);
-               bi->pagesInUse = 0;
-               bi->softDeletions = 0;
-
-               yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber);
-
-               bi->blockState = state;
-               bi->sequenceNumber = sequenceNumber;
-
-               T(YAFFS_TRACE_SCAN_DEBUG,
-                 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
-                  state, sequenceNumber));
-
-               if (state == YAFFS_BLOCK_STATE_DEAD) {
-                       T(YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("block %d is bad" TENDSTR), blk));
-               } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
-                       T(YAFFS_TRACE_SCAN_DEBUG,
-                         (TSTR("Block empty " TENDSTR)));
-                       dev->nErasedBlocks++;
-                       dev->nFreeChunks += dev->nChunksPerBlock;
-               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-
-                       /* Determine the highest sequence number */
-                       if (dev->isYaffs2 &&
-                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
-                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
-
-                               blockIndex[nBlocksToScan].seq = sequenceNumber;
-                               blockIndex[nBlocksToScan].block = blk;
-
-                               nBlocksToScan++;
-
-                               if (sequenceNumber >= dev->sequenceNumber) {
-                                       dev->sequenceNumber = sequenceNumber;
-                               }
-                       } else if (dev->isYaffs2) {
-                               /* TODO: Nasty sequence number! */
-                               T(YAFFS_TRACE_SCAN,
-                                 (TSTR
-                                  ("Block scanning block %d has bad sequence number %d"
-                                   TENDSTR), blk, sequenceNumber));
-
-                       }
-               }
-       }
-
-       /* Sort the blocks
-        * Dungy old bubble sort for now...
-        */
-       if (dev->isYaffs2) {
-               yaffs_BlockIndex temp;
-               int i;
-               int j;
-
-               for (i = 0; i < nBlocksToScan; i++)
-                       for (j = i + 1; j < nBlocksToScan; j++)
-                               if (blockIndex[i].seq > blockIndex[j].seq) {
-                                       temp = blockIndex[j];
-                                       blockIndex[j] = blockIndex[i];
-                                       blockIndex[i] = temp;
-                               }
-       }
-
-       /* Now scan the blocks looking at the data. */
-       if (dev->isYaffs2) {
-               startIterator = 0;
-               endIterator = nBlocksToScan - 1;
-               T(YAFFS_TRACE_SCAN_DEBUG,
-                 (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
-       } else {
-               startIterator = dev->internalStartBlock;
-               endIterator = dev->internalEndBlock;
-       }
-
-       /* For each block.... */
-       for (blockIterator = startIterator; !alloc_failed && blockIterator <= endIterator;
-            blockIterator++) {
-
-               if (dev->isYaffs2) {
-                       /* get the block to scan in the correct order */
-                       blk = blockIndex[blockIterator].block;
-               } else {
-                       blk = blockIterator;
-               }
-
-               bi = yaffs_GetBlockInfo(dev, blk);
-               state = bi->blockState;
-
-               deleted = 0;
-
-               /* For each chunk in each block that needs scanning....*/
-               for (c = 0; !alloc_failed && c < dev->nChunksPerBlock &&
-                    state == YAFFS_BLOCK_STATE_NEEDS_SCANNING; c++) {
-                       /* Read the tags and decide what to do */
-                       chunk = blk * dev->nChunksPerBlock + c;
-
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
-                                                       &tags);
-
-                       /* Let's have a good look at this chunk... */
-
-                       if (!dev->isYaffs2 && tags.chunkDeleted) {
-                               /* YAFFS1 only...
-                                * A deleted chunk
-                                */
-                               deleted++;
-                               dev->nFreeChunks++;
-                               /*T((" %d %d deleted\n",blk,c)); */
-                       } else if (!tags.chunkUsed) {
-                               /* An unassigned chunk in the block
-                                * This means that either the block is empty or
-                                * this is the one being allocated from
-                                */
-
-                               if (c == 0) {
-                                       /* We're looking at the first chunk in the block so the block is unused */
-                                       state = YAFFS_BLOCK_STATE_EMPTY;
-                                       dev->nErasedBlocks++;
-                               } else {
-                                       /* this is the block being allocated from */
-                                       T(YAFFS_TRACE_SCAN,
-                                         (TSTR
-                                          (" Allocating from %d %d" TENDSTR),
-                                          blk, c));
-                                       state = YAFFS_BLOCK_STATE_ALLOCATING;
-                                       dev->allocationBlock = blk;
-                                       dev->allocationPage = c;
-                                       dev->allocationBlockFinder = blk;
-                                       /* Set it to here to encourage the allocator to go forth from here. */
-
-                                       /* Yaffs2 sanity check:
-                                        * This should be the one with the highest sequence number
-                                        */
-                                       if (dev->isYaffs2
-                                           && (dev->sequenceNumber !=
-                                               bi->sequenceNumber)) {
-                                               T(YAFFS_TRACE_ALWAYS,
-                                                 (TSTR
-                                                  ("yaffs: Allocation block %d was not highest sequence id:"
-                                                   " block seq = %d, dev seq = %d"
-                                                   TENDSTR), blk,bi->sequenceNumber,dev->sequenceNumber));
-                                       }
-                               }
-
-                               dev->nFreeChunks += (dev->nChunksPerBlock - c);
-                       } else if (tags.chunkId > 0) {
-                               /* chunkId > 0 so it is a data chunk... */
-                               unsigned int endpos;
-
-                               yaffs_SetChunkBit(dev, blk, c);
-                               bi->pagesInUse++;
-
-                               in = yaffs_FindOrCreateObjectByNumber(dev,
-                                                                     tags.
-                                                                     objectId,
-                                                                     YAFFS_OBJECT_TYPE_FILE);
-                               /* PutChunkIntoFile checks for a clash (two data chunks with
-                                * the same chunkId).
-                                */
-
-                               if(!in)
-                                       alloc_failed = 1;
-
-                               if(in){
-                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId, chunk,1))
-                                               alloc_failed = 1;
-                               }
-
-                               endpos =
-                                   (tags.chunkId - 1) * dev->nDataBytesPerChunk +
-                                   tags.byteCount;
-                               if (in &&
-                                   in->variantType == YAFFS_OBJECT_TYPE_FILE
-                                   && in->variant.fileVariant.scannedFileSize <
-                                   endpos) {
-                                       in->variant.fileVariant.
-                                           scannedFileSize = endpos;
-                                       if (!dev->useHeaderFileSize) {
-                                               in->variant.fileVariant.
-                                                   fileSize =
-                                                   in->variant.fileVariant.
-                                                   scannedFileSize;
-                                       }
-
-                               }
-                               /* T((" %d %d data %d %d\n",blk,c,tags.objectId,tags.chunkId));   */
-                       } else {
-                               /* chunkId == 0, so it is an ObjectHeader.
-                                * Thus, we read in the object header and make the object
-                                */
-                               yaffs_SetChunkBit(dev, blk, c);
-                               bi->pagesInUse++;
-
-                               result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk,
-                                                               chunkData,
-                                                               NULL);
-
-                               oh = (yaffs_ObjectHeader *) chunkData;
-
-                               in = yaffs_FindObjectByNumber(dev,
-                                                             tags.objectId);
-                               if (in && in->variantType != oh->type) {
-                                       /* This should not happen, but somehow
-                                        * Wev'e ended up with an objectId that has been reused but not yet
-                                        * deleted, and worse still it has changed type. Delete the old object.
-                                        */
-
-                                       yaffs_DestroyObject(in);
-
-                                       in = 0;
-                               }
-
-                               in = yaffs_FindOrCreateObjectByNumber(dev,
-                                                                     tags.
-                                                                     objectId,
-                                                                     oh->type);
-
-                               if(!in)
-                                       alloc_failed = 1;
-
-                               if (in && oh->shadowsObject > 0) {
-                                       yaffs_HandleShadowedObject(dev,
-                                                                  oh->
-                                                                  shadowsObject,
-                                                                  0);
-                               }
-
-                               if (in && in->valid) {
-                                       /* We have already filled this one. We have a duplicate and need to resolve it. */
-
-                                       unsigned existingSerial = in->serial;
-                                       unsigned newSerial = tags.serialNumber;
-
-                                       if (dev->isYaffs2 ||
-                                           ((existingSerial + 1) & 3) ==
-                                           newSerial) {
-                                               /* Use new one - destroy the exisiting one */
-                                               yaffs_DeleteChunk(dev,
-                                                                 in->chunkId,
-                                                                 1, __LINE__);
-                                               in->valid = 0;
-                                       } else {
-                                               /* Use existing - destroy this one. */
-                                               yaffs_DeleteChunk(dev, chunk, 1,
-                                                                 __LINE__);
-                                       }
-                               }
-
-                               if (in && !in->valid &&
-                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
-                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND)) {
-                                       /* We only load some info, don't fiddle with directory structure */
-                                       in->valid = 1;
-                                       in->variantType = oh->type;
-
-                                       in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-                                       in->win_atime[0] = oh->win_atime[0];
-                                       in->win_ctime[0] = oh->win_ctime[0];
-                                       in->win_mtime[0] = oh->win_mtime[0];
-                                       in->win_atime[1] = oh->win_atime[1];
-                                       in->win_ctime[1] = oh->win_ctime[1];
-                                       in->win_mtime[1] = oh->win_mtime[1];
-#else
-                                       in->yst_uid = oh->yst_uid;
-                                       in->yst_gid = oh->yst_gid;
-                                       in->yst_atime = oh->yst_atime;
-                                       in->yst_mtime = oh->yst_mtime;
-                                       in->yst_ctime = oh->yst_ctime;
-                                       in->yst_rdev = oh->yst_rdev;
-#endif
-                                       in->chunkId = chunk;
-
-                               } else if (in && !in->valid) {
-                                       /* we need to load this info */
-
-                                       in->valid = 1;
-                                       in->variantType = oh->type;
-
-                                       in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-                                       in->win_atime[0] = oh->win_atime[0];
-                                       in->win_ctime[0] = oh->win_ctime[0];
-                                       in->win_mtime[0] = oh->win_mtime[0];
-                                       in->win_atime[1] = oh->win_atime[1];
-                                       in->win_ctime[1] = oh->win_ctime[1];
-                                       in->win_mtime[1] = oh->win_mtime[1];
-#else
-                                       in->yst_uid = oh->yst_uid;
-                                       in->yst_gid = oh->yst_gid;
-                                       in->yst_atime = oh->yst_atime;
-                                       in->yst_mtime = oh->yst_mtime;
-                                       in->yst_ctime = oh->yst_ctime;
-                                       in->yst_rdev = oh->yst_rdev;
-#endif
-                                       in->chunkId = chunk;
-
-                                       yaffs_SetObjectName(in, oh->name);
-                                       in->dirty = 0;
-
-                                       /* directory stuff...
-                                        * hook up to parent
-                                        */
-
-                                       parent =
-                                           yaffs_FindOrCreateObjectByNumber
-                                           (dev, oh->parentObjectId,
-                                            YAFFS_OBJECT_TYPE_DIRECTORY);
-                                       if (parent->variantType ==
-                                           YAFFS_OBJECT_TYPE_UNKNOWN) {
-                                               /* Set up as a directory */
-                                               parent->variantType =
-                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
-                                                              directoryVariant.
-                                                              children);
-                                       } else if (parent->variantType !=
-                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
-                                       {
-                                               /* Hoosterman, another problem....
-                                                * We're trying to use a non-directory as a directory
-                                                */
-
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as"
-                                                   " a directory in scan. Put in lost+found."
-                                                   TENDSTR)));
-                                               parent = dev->lostNFoundDir;
-                                       }
-
-                                       yaffs_AddObjectToDirectory(parent, in);
-
-                                       if (0 && (parent == dev->deletedDir ||
-                                                 parent == dev->unlinkedDir)) {
-                                               in->deleted = 1;        /* If it is unlinked at start up then it wants deleting */
-                                               dev->nDeletedFiles++;
-                                       }
-                                       /* Note re hardlinks.
-                                        * Since we might scan a hardlink before its equivalent object is scanned
-                                        * we put them all in a list.
-                                        * After scanning is complete, we should have all the objects, so we run through this
-                                        * list and fix up all the chains.
-                                        */
-
-                                       switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
-                                               /* Todo got a problem */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_FILE:
-                                               if (dev->isYaffs2
-                                                   && oh->isShrink) {
-                                                       /* Prune back the shrunken chunks */
-                                                       yaffs_PruneResizedChunks
-                                                           (in, oh->fileSize);
-                                                       /* Mark the block as having a shrinkHeader */
-                                                       bi->hasShrinkHeader = 1;
-                                               }
-
-                                               if (dev->useHeaderFileSize)
-
-                                                       in->variant.fileVariant.
-                                                           fileSize =
-                                                           oh->fileSize;
-
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_HARDLINK:
-                                               in->variant.hardLinkVariant.
-                                                   equivalentObjectId =
-                                                   oh->equivalentObjectId;
-                                               in->hardLinks.next =
-                                                   (struct list_head *)
-                                                   hardList;
-                                               hardList = in;
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_DIRECTORY:
-                                               /* Do nothing */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_SPECIAL:
-                                               /* Do nothing */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_SYMLINK:
-                                               in->variant.symLinkVariant.alias =
-                                                   yaffs_CloneString(oh->alias);
-                                               if(!in->variant.symLinkVariant.alias)
-                                                       alloc_failed = 1;
-                                               break;
-                                       }
-
-                                       if (parent == dev->deletedDir) {
-                                               yaffs_DestroyObject(in);
-                                               bi->hasShrinkHeader = 1;
-                                       }
-                               }
-                       }
-               }
-
-               if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-                       /* If we got this far while scanning, then the block is fully allocated.*/
-                       state = YAFFS_BLOCK_STATE_FULL;
-               }
-
-               bi->blockState = state;
-
-               /* Now let's see if it was dirty */
-               if (bi->pagesInUse == 0 &&
-                   !bi->hasShrinkHeader &&
-                   bi->blockState == YAFFS_BLOCK_STATE_FULL) {
-                       yaffs_BlockBecameDirty(dev, blk);
-               }
-
-       }
-
-       if (blockIndex) {
-               YFREE(blockIndex);
-       }
-
-
-       /* Ok, we've done all the scanning.
-        * Fix up the hard link chains.
-        * We should now have scanned all the objects, now it's time to add these
-        * hardlinks.
-        */
-
-       yaffs_HardlinkFixup(dev,hardList);
-
-       /* Handle the unlinked files. Since they were left in an unlinked state we should
-        * just delete them.
-        */
-       {
-               struct list_head *i;
-               struct list_head *n;
-
-               yaffs_Object *l;
-               /* Soft delete all the unlinked files */
-               list_for_each_safe(i, n,
-                                  &dev->unlinkedDir->variant.directoryVariant.
-                                  children) {
-                       if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
-                               yaffs_DestroyObject(l);
-                       }
-               }
-       }
-
-       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-
-       if(alloc_failed){
-               return YAFFS_FAIL;
-       }
-
-       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_Scan ends" TENDSTR)));
-
-
-       return YAFFS_OK;
-}
-
-static void yaffs_CheckObjectDetailsLoaded(yaffs_Object *in)
-{
-       __u8 *chunkData;
-       yaffs_ObjectHeader *oh;
-       yaffs_Device *dev = in->myDev;
-       yaffs_ExtendedTags tags;
-       int result;
-       int alloc_failed = 0;
-
-       if(!in)
-               return;
-
-#if 0
-       T(YAFFS_TRACE_SCAN,(TSTR("details for object %d %s loaded" TENDSTR),
-               in->objectId,
-               in->lazyLoaded ? "not yet" : "already"));
-#endif
-
-       if(in->lazyLoaded){
-               in->lazyLoaded = 0;
-               chunkData = yaffs_GetTempBuffer(dev, __LINE__);
-
-               result = yaffs_ReadChunkWithTagsFromNAND(dev,in->chunkId,chunkData,&tags);
-               oh = (yaffs_ObjectHeader *) chunkData;
-
-               in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-               in->win_atime[0] = oh->win_atime[0];
-               in->win_ctime[0] = oh->win_ctime[0];
-               in->win_mtime[0] = oh->win_mtime[0];
-               in->win_atime[1] = oh->win_atime[1];
-               in->win_ctime[1] = oh->win_ctime[1];
-               in->win_mtime[1] = oh->win_mtime[1];
-#else
-               in->yst_uid = oh->yst_uid;
-               in->yst_gid = oh->yst_gid;
-               in->yst_atime = oh->yst_atime;
-               in->yst_mtime = oh->yst_mtime;
-               in->yst_ctime = oh->yst_ctime;
-               in->yst_rdev = oh->yst_rdev;
-
-#endif
-               yaffs_SetObjectName(in, oh->name);
-
-               if(in->variantType == YAFFS_OBJECT_TYPE_SYMLINK){
-                        in->variant.symLinkVariant.alias =
-                                                   yaffs_CloneString(oh->alias);
-                       if(!in->variant.symLinkVariant.alias)
-                               alloc_failed = 1; /* Not returned to caller */
-               }
-
-               yaffs_ReleaseTempBuffer(dev,chunkData, __LINE__);
-       }
-}
-
-static int yaffs_ScanBackwards(yaffs_Device * dev)
-{
-       yaffs_ExtendedTags tags;
-       int blk;
-       int blockIterator;
-       int startIterator;
-       int endIterator;
-       int nBlocksToScan = 0;
-
-       int chunk;
-       int result;
-       int c;
-       int deleted;
-       yaffs_BlockState state;
-       yaffs_Object *hardList = NULL;
-       yaffs_BlockInfo *bi;
-       int sequenceNumber;
-       yaffs_ObjectHeader *oh;
-       yaffs_Object *in;
-       yaffs_Object *parent;
-       int nBlocks = dev->internalEndBlock - dev->internalStartBlock + 1;
-       int itsUnlinked;
-       __u8 *chunkData;
-
-       int fileSize;
-       int isShrink;
-       int foundChunksInBlock;
-       int equivalentObjectId;
-       int alloc_failed = 0;
-
-
-       yaffs_BlockIndex *blockIndex = NULL;
-       int altBlockIndex = 0;
-
-       if (!dev->isYaffs2) {
-               T(YAFFS_TRACE_SCAN,
-                 (TSTR("yaffs_ScanBackwards is only for YAFFS2!" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       T(YAFFS_TRACE_SCAN,
-         (TSTR
-          ("yaffs_ScanBackwards starts  intstartblk %d intendblk %d..."
-           TENDSTR), dev->internalStartBlock, dev->internalEndBlock));
-
-
-       dev->sequenceNumber = YAFFS_LOWEST_SEQUENCE_NUMBER;
-
-       blockIndex = YMALLOC(nBlocks * sizeof(yaffs_BlockIndex));
-
-       if(!blockIndex) {
-               blockIndex = YMALLOC_ALT(nBlocks * sizeof(yaffs_BlockIndex));
-               altBlockIndex = 1;
-       }
-
-       if(!blockIndex) {
-               T(YAFFS_TRACE_SCAN,
-                 (TSTR("yaffs_Scan() could not allocate block index!" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       dev->blocksInCheckpoint = 0;
-
-       chunkData = yaffs_GetTempBuffer(dev, __LINE__);
-
-       /* Scan all the blocks to determine their state */
-       for (blk = dev->internalStartBlock; blk <= dev->internalEndBlock; blk++) {
-               bi = yaffs_GetBlockInfo(dev, blk);
-               yaffs_ClearChunkBits(dev, blk);
-               bi->pagesInUse = 0;
-               bi->softDeletions = 0;
-
-               yaffs_QueryInitialBlockState(dev, blk, &state, &sequenceNumber);
-
-               bi->blockState = state;
-               bi->sequenceNumber = sequenceNumber;
-
-               if(bi->sequenceNumber == YAFFS_SEQUENCE_CHECKPOINT_DATA)
-                       bi->blockState = state = YAFFS_BLOCK_STATE_CHECKPOINT;
-
-               T(YAFFS_TRACE_SCAN_DEBUG,
-                 (TSTR("Block scanning block %d state %d seq %d" TENDSTR), blk,
-                  state, sequenceNumber));
-
-
-               if(state == YAFFS_BLOCK_STATE_CHECKPOINT){
-                       dev->blocksInCheckpoint++;
-
-               } else if (state == YAFFS_BLOCK_STATE_DEAD) {
-                       T(YAFFS_TRACE_BAD_BLOCKS,
-                         (TSTR("block %d is bad" TENDSTR), blk));
-               } else if (state == YAFFS_BLOCK_STATE_EMPTY) {
-                       T(YAFFS_TRACE_SCAN_DEBUG,
-                         (TSTR("Block empty " TENDSTR)));
-                       dev->nErasedBlocks++;
-                       dev->nFreeChunks += dev->nChunksPerBlock;
-               } else if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-
-                       /* Determine the highest sequence number */
-                       if (dev->isYaffs2 &&
-                           sequenceNumber >= YAFFS_LOWEST_SEQUENCE_NUMBER &&
-                           sequenceNumber < YAFFS_HIGHEST_SEQUENCE_NUMBER) {
-
-                               blockIndex[nBlocksToScan].seq = sequenceNumber;
-                               blockIndex[nBlocksToScan].block = blk;
-
-                               nBlocksToScan++;
-
-                               if (sequenceNumber >= dev->sequenceNumber) {
-                                       dev->sequenceNumber = sequenceNumber;
-                               }
-                       } else if (dev->isYaffs2) {
-                               /* TODO: Nasty sequence number! */
-                               T(YAFFS_TRACE_SCAN,
-                                 (TSTR
-                                  ("Block scanning block %d has bad sequence number %d"
-                                   TENDSTR), blk, sequenceNumber));
-
-                       }
-               }
-       }
-
-       T(YAFFS_TRACE_SCAN,
-       (TSTR("%d blocks to be sorted..." TENDSTR), nBlocksToScan));
-
-
-
-       YYIELD();
-
-       /* Sort the blocks */
-#ifndef CONFIG_YAFFS_USE_OWN_SORT
-       yaffs_qsort(blockIndex, nBlocksToScan,
-               sizeof(yaffs_BlockIndex), ybicmp);
-#else
-       {
-               /* Dungy old bubble sort... */
-
-               yaffs_BlockIndex temp;
-               int i;
-               int j;
-
-               for (i = 0; i < nBlocksToScan; i++)
-                       for (j = i + 1; j < nBlocksToScan; j++)
-                               if (blockIndex[i].seq > blockIndex[j].seq) {
-                                       temp = blockIndex[j];
-                                       blockIndex[j] = blockIndex[i];
-                                       blockIndex[i] = temp;
-                               }
-       }
-#endif
-
-       YYIELD();
-
-       T(YAFFS_TRACE_SCAN, (TSTR("...done" TENDSTR)));
-
-       /* Now scan the blocks looking at the data. */
-       startIterator = 0;
-       endIterator = nBlocksToScan - 1;
-       T(YAFFS_TRACE_SCAN_DEBUG,
-         (TSTR("%d blocks to be scanned" TENDSTR), nBlocksToScan));
-
-       /* For each block.... backwards */
-       for (blockIterator = endIterator; !alloc_failed && blockIterator >= startIterator;
-            blockIterator--) {
-               /* Cooperative multitasking! This loop can run for so
-                  long that watchdog timers expire. */
-               YYIELD();
-
-               /* get the block to scan in the correct order */
-               blk = blockIndex[blockIterator].block;
-
-               bi = yaffs_GetBlockInfo(dev, blk);
-
-
-               state = bi->blockState;
-
-               deleted = 0;
-
-               /* For each chunk in each block that needs scanning.... */
-               foundChunksInBlock = 0;
-               for (c = dev->nChunksPerBlock - 1;
-                    !alloc_failed && c >= 0 &&
-                    (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
-                     state == YAFFS_BLOCK_STATE_ALLOCATING); c--) {
-                       /* Scan backwards...
-                        * Read the tags and decide what to do
-                        */
-
-                       chunk = blk * dev->nChunksPerBlock + c;
-
-                       result = yaffs_ReadChunkWithTagsFromNAND(dev, chunk, NULL,
-                                                       &tags);
-
-                       /* Let's have a good look at this chunk... */
-
-                       if (!tags.chunkUsed) {
-                               /* An unassigned chunk in the block.
-                                * If there are used chunks after this one, then
-                                * it is a chunk that was skipped due to failing the erased
-                                * check. Just skip it so that it can be deleted.
-                                * But, more typically, We get here when this is an unallocated
-                                * chunk and his means that either the block is empty or
-                                * this is the one being allocated from
-                                */
-
-                               if(foundChunksInBlock)
-                               {
-                                       /* This is a chunk that was skipped due to failing the erased check */
-
-                               } else if (c == 0) {
-                                       /* We're looking at the first chunk in the block so the block is unused */
-                                       state = YAFFS_BLOCK_STATE_EMPTY;
-                                       dev->nErasedBlocks++;
-                               } else {
-                                       if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING ||
-                                           state == YAFFS_BLOCK_STATE_ALLOCATING) {
-                                               if(dev->sequenceNumber == bi->sequenceNumber) {
-                                                       /* this is the block being allocated from */
-
-                                                       T(YAFFS_TRACE_SCAN,
-                                                         (TSTR
-                                                          (" Allocating from %d %d"
-                                                           TENDSTR), blk, c));
-
-                                                       state = YAFFS_BLOCK_STATE_ALLOCATING;
-                                                       dev->allocationBlock = blk;
-                                                       dev->allocationPage = c;
-                                                       dev->allocationBlockFinder = blk;
-                                               }
-                                               else {
-                                                       /* This is a partially written block that is not
-                                                        * the current allocation block. This block must have
-                                                        * had a write failure, so set up for retirement.
-                                                        */
-
-                                                        bi->needsRetiring = 1;
-                                                        bi->gcPrioritise = 1;
-
-                                                        T(YAFFS_TRACE_ALWAYS,
-                                                        (TSTR("Partially written block %d being set for retirement" TENDSTR),
-                                                        blk));
-                                               }
-
-                                       }
-
-                               }
-
-                               dev->nFreeChunks++;
-
-                       } else if (tags.chunkId > 0) {
-                               /* chunkId > 0 so it is a data chunk... */
-                               unsigned int endpos;
-                               __u32 chunkBase =
-                                   (tags.chunkId - 1) * dev->nDataBytesPerChunk;
-
-                               foundChunksInBlock = 1;
-
-
-                               yaffs_SetChunkBit(dev, blk, c);
-                               bi->pagesInUse++;
-
-                               in = yaffs_FindOrCreateObjectByNumber(dev,
-                                                                     tags.
-                                                                     objectId,
-                                                                     YAFFS_OBJECT_TYPE_FILE);
-                               if(!in){
-                                       /* Out of memory */
-                                       alloc_failed = 1;
-                               }
-
-                               if (in &&
-                                   in->variantType == YAFFS_OBJECT_TYPE_FILE
-                                   && chunkBase <
-                                   in->variant.fileVariant.shrinkSize) {
-                                       /* This has not been invalidated by a resize */
-                                       if(!yaffs_PutChunkIntoFile(in, tags.chunkId,
-                                                              chunk, -1)){
-                                               alloc_failed = 1;
-                                       }
-
-                                       /* File size is calculated by looking at the data chunks if we have not
-                                        * seen an object header yet. Stop this practice once we find an object header.
-                                        */
-                                       endpos =
-                                           (tags.chunkId -
-                                            1) * dev->nDataBytesPerChunk +
-                                           tags.byteCount;
-
-                                       if (!in->valid &&       /* have not got an object header yet */
-                                           in->variant.fileVariant.
-                                           scannedFileSize < endpos) {
-                                               in->variant.fileVariant.
-                                                   scannedFileSize = endpos;
-                                               in->variant.fileVariant.
-                                                   fileSize =
-                                                   in->variant.fileVariant.
-                                                   scannedFileSize;
-                                       }
-
-                               } else if(in) {
-                                       /* This chunk has been invalidated by a resize, so delete */
-                                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
-
-                               }
-                       } else {
-                               /* chunkId == 0, so it is an ObjectHeader.
-                                * Thus, we read in the object header and make the object
-                                */
-                               foundChunksInBlock = 1;
-
-                               yaffs_SetChunkBit(dev, blk, c);
-                               bi->pagesInUse++;
-
-                               oh = NULL;
-                               in = NULL;
-
-                               if (tags.extraHeaderInfoAvailable) {
-                                       in = yaffs_FindOrCreateObjectByNumber
-                                           (dev, tags.objectId,
-                                            tags.extraObjectType);
-                               }
-
-                               if (!in ||
-#ifdef CONFIG_YAFFS_DISABLE_LAZY_LOAD
-                                   !in->valid ||
-#endif
-                                   tags.extraShadows ||
-                                   (!in->valid &&
-                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
-                                    tags.objectId == YAFFS_OBJECTID_LOSTNFOUND))
-                                   ) {
-
-                                       /* If we don't have  valid info then we need to read the chunk
-                                        * TODO In future we can probably defer reading the chunk and
-                                        * living with invalid data until needed.
-                                        */
-
-                                       result = yaffs_ReadChunkWithTagsFromNAND(dev,
-                                                                       chunk,
-                                                                       chunkData,
-                                                                       NULL);
-
-                                       oh = (yaffs_ObjectHeader *) chunkData;
-
-                                       if (!in)
-                                               in = yaffs_FindOrCreateObjectByNumber(dev, tags.objectId, oh->type);
-
-                               }
-
-                               if (!in) {
-                                       /* TODO Hoosterman we have a problem! */
-                                       T(YAFFS_TRACE_ERROR,
-                                         (TSTR
-                                          ("yaffs tragedy: Could not make object for object  %d  "
-                                           "at chunk %d during scan"
-                                           TENDSTR), tags.objectId, chunk));
-
-                               }
-
-                               if (in->valid) {
-                                       /* We have already filled this one.
-                                        * We have a duplicate that will be discarded, but
-                                        * we first have to suck out resize info if it is a file.
-                                        */
-
-                                       if ((in->variantType == YAFFS_OBJECT_TYPE_FILE) &&
-                                            ((oh &&
-                                              oh-> type == YAFFS_OBJECT_TYPE_FILE)||
-                                             (tags.extraHeaderInfoAvailable  &&
-                                              tags.extraObjectType == YAFFS_OBJECT_TYPE_FILE))
-                                           ) {
-                                               __u32 thisSize =
-                                                   (oh) ? oh->fileSize : tags.
-                                                   extraFileLength;
-                                               __u32 parentObjectId =
-                                                   (oh) ? oh->
-                                                   parentObjectId : tags.
-                                                   extraParentObjectId;
-                                               unsigned isShrink =
-                                                   (oh) ? oh->isShrink : tags.
-                                                   extraIsShrinkHeader;
-
-                                               /* If it is deleted (unlinked at start also means deleted)
-                                                * we treat the file size as being zeroed at this point.
-                                                */
-                                               if (parentObjectId ==
-                                                   YAFFS_OBJECTID_DELETED
-                                                   || parentObjectId ==
-                                                   YAFFS_OBJECTID_UNLINKED) {
-                                                       thisSize = 0;
-                                                       isShrink = 1;
-                                               }
-
-                                               if (isShrink &&
-                                                   in->variant.fileVariant.
-                                                   shrinkSize > thisSize) {
-                                                       in->variant.fileVariant.
-                                                           shrinkSize =
-                                                           thisSize;
-                                               }
-
-                                               if (isShrink) {
-                                                       bi->hasShrinkHeader = 1;
-                                               }
-
-                                       }
-                                       /* Use existing - destroy this one. */
-                                       yaffs_DeleteChunk(dev, chunk, 1, __LINE__);
-
-                               }
-
-                               if (!in->valid &&
-                                   (tags.objectId == YAFFS_OBJECTID_ROOT ||
-                                    tags.objectId ==
-                                    YAFFS_OBJECTID_LOSTNFOUND)) {
-                                       /* We only load some info, don't fiddle with directory structure */
-                                       in->valid = 1;
-
-                                       if(oh) {
-                                               in->variantType = oh->type;
-
-                                               in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-                                               in->win_atime[0] = oh->win_atime[0];
-                                               in->win_ctime[0] = oh->win_ctime[0];
-                                               in->win_mtime[0] = oh->win_mtime[0];
-                                               in->win_atime[1] = oh->win_atime[1];
-                                               in->win_ctime[1] = oh->win_ctime[1];
-                                               in->win_mtime[1] = oh->win_mtime[1];
-#else
-                                               in->yst_uid = oh->yst_uid;
-                                               in->yst_gid = oh->yst_gid;
-                                               in->yst_atime = oh->yst_atime;
-                                               in->yst_mtime = oh->yst_mtime;
-                                               in->yst_ctime = oh->yst_ctime;
-                                               in->yst_rdev = oh->yst_rdev;
-
-#endif
-                                       } else {
-                                               in->variantType = tags.extraObjectType;
-                                               in->lazyLoaded = 1;
-                                       }
-
-                                       in->chunkId = chunk;
-
-                               } else if (!in->valid) {
-                                       /* we need to load this info */
-
-                                       in->valid = 1;
-                                       in->chunkId = chunk;
-
-                                       if(oh) {
-                                               in->variantType = oh->type;
-
-                                               in->yst_mode = oh->yst_mode;
-#ifdef CONFIG_YAFFS_WINCE
-                                               in->win_atime[0] = oh->win_atime[0];
-                                               in->win_ctime[0] = oh->win_ctime[0];
-                                               in->win_mtime[0] = oh->win_mtime[0];
-                                               in->win_atime[1] = oh->win_atime[1];
-                                               in->win_ctime[1] = oh->win_ctime[1];
-                                               in->win_mtime[1] = oh->win_mtime[1];
-#else
-                                               in->yst_uid = oh->yst_uid;
-                                               in->yst_gid = oh->yst_gid;
-                                               in->yst_atime = oh->yst_atime;
-                                               in->yst_mtime = oh->yst_mtime;
-                                               in->yst_ctime = oh->yst_ctime;
-                                               in->yst_rdev = oh->yst_rdev;
-#endif
-
-                                               if (oh->shadowsObject > 0)
-                                                       yaffs_HandleShadowedObject(dev,
-                                                                          oh->
-                                                                          shadowsObject,
-                                                                          1);
-
-
-                                               yaffs_SetObjectName(in, oh->name);
-                                               parent =
-                                                   yaffs_FindOrCreateObjectByNumber
-                                                       (dev, oh->parentObjectId,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
-
-                                                fileSize = oh->fileSize;
-                                                isShrink = oh->isShrink;
-                                                equivalentObjectId = oh->equivalentObjectId;
-
-                                       }
-                                       else {
-                                               in->variantType = tags.extraObjectType;
-                                               parent =
-                                                   yaffs_FindOrCreateObjectByNumber
-                                                       (dev, tags.extraParentObjectId,
-                                                        YAFFS_OBJECT_TYPE_DIRECTORY);
-                                                fileSize = tags.extraFileLength;
-                                                isShrink = tags.extraIsShrinkHeader;
-                                                equivalentObjectId = tags.extraEquivalentObjectId;
-                                               in->lazyLoaded = 1;
-
-                                       }
-                                       in->dirty = 0;
-
-                                       /* directory stuff...
-                                        * hook up to parent
-                                        */
-
-                                       if (parent->variantType ==
-                                           YAFFS_OBJECT_TYPE_UNKNOWN) {
-                                               /* Set up as a directory */
-                                               parent->variantType =
-                                                   YAFFS_OBJECT_TYPE_DIRECTORY;
-                                               INIT_LIST_HEAD(&parent->variant.
-                                                              directoryVariant.
-                                                              children);
-                                       } else if (parent->variantType !=
-                                                  YAFFS_OBJECT_TYPE_DIRECTORY)
-                                       {
-                                               /* Hoosterman, another problem....
-                                                * We're trying to use a non-directory as a directory
-                                                */
-
-                                               T(YAFFS_TRACE_ERROR,
-                                                 (TSTR
-                                                  ("yaffs tragedy: attempting to use non-directory as"
-                                                   " a directory in scan. Put in lost+found."
-                                                   TENDSTR)));
-                                               parent = dev->lostNFoundDir;
-                                       }
-
-                                       yaffs_AddObjectToDirectory(parent, in);
-
-                                       itsUnlinked = (parent == dev->deletedDir) ||
-                                                     (parent == dev->unlinkedDir);
-
-                                       if (isShrink) {
-                                               /* Mark the block as having a shrinkHeader */
-                                               bi->hasShrinkHeader = 1;
-                                       }
-
-                                       /* Note re hardlinks.
-                                        * Since we might scan a hardlink before its equivalent object is scanned
-                                        * we put them all in a list.
-                                        * After scanning is complete, we should have all the objects, so we run
-                                        * through this list and fix up all the chains.
-                                        */
-
-                                       switch (in->variantType) {
-                                       case YAFFS_OBJECT_TYPE_UNKNOWN:
-                                               /* Todo got a problem */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_FILE:
-
-                                               if (in->variant.fileVariant.
-                                                   scannedFileSize < fileSize) {
-                                                       /* This covers the case where the file size is greater
-                                                        * than where the data is
-                                                        * This will happen if the file is resized to be larger
-                                                        * than its current data extents.
-                                                        */
-                                                       in->variant.fileVariant.fileSize = fileSize;
-                                                       in->variant.fileVariant.scannedFileSize =
-                                                           in->variant.fileVariant.fileSize;
-                                               }
-
-                                               if (isShrink &&
-                                                   in->variant.fileVariant.shrinkSize > fileSize) {
-                                                       in->variant.fileVariant.shrinkSize = fileSize;
-                                               }
-
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_HARDLINK:
-                                               if(!itsUnlinked) {
-                                                 in->variant.hardLinkVariant.equivalentObjectId =
-                                                   equivalentObjectId;
-                                                 in->hardLinks.next =
-                                                   (struct list_head *) hardList;
-                                                 hardList = in;
-                                               }
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_DIRECTORY:
-                                               /* Do nothing */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_SPECIAL:
-                                               /* Do nothing */
-                                               break;
-                                       case YAFFS_OBJECT_TYPE_SYMLINK:
-                                               if(oh){
-                                                  in->variant.symLinkVariant.alias =
-                                                   yaffs_CloneString(oh->
-                                                                     alias);
-                                                  if(!in->variant.symLinkVariant.alias)
-                                                       alloc_failed = 1;
-                                               }
-                                               break;
-                                       }
-
-                               }
-
-                       }
-
-               } /* End of scanning for each chunk */
-
-               if (state == YAFFS_BLOCK_STATE_NEEDS_SCANNING) {
-                       /* If we got this far while scanning, then the block is fully allocated. */
-                       state = YAFFS_BLOCK_STATE_FULL;
-               }
-
-               bi->blockState = state;
-
-               /* Now let's see if it was dirty */
-               if (bi->pagesInUse == 0 &&
-                   !bi->hasShrinkHeader &&
-                   bi->blockState == YAFFS_BLOCK_STATE_FULL) {
-                       yaffs_BlockBecameDirty(dev, blk);
-               }
-
-       }
-
-       if (altBlockIndex)
-               YFREE_ALT(blockIndex);
-       else
-               YFREE(blockIndex);
-
-       /* Ok, we've done all the scanning.
-        * Fix up the hard link chains.
-        * We should now have scanned all the objects, now it's time to add these
-        * hardlinks.
-        */
-       yaffs_HardlinkFixup(dev,hardList);
-
-
-       /*
-       *  Sort out state of unlinked and deleted objects.
-       */
-       {
-               struct list_head *i;
-               struct list_head *n;
-
-               yaffs_Object *l;
-
-               /* Soft delete all the unlinked files */
-               list_for_each_safe(i, n,
-                                  &dev->unlinkedDir->variant.directoryVariant.
-                                  children) {
-                       if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
-                               yaffs_DestroyObject(l);
-                       }
-               }
-
-               /* Soft delete all the deletedDir files */
-               list_for_each_safe(i, n,
-                                  &dev->deletedDir->variant.directoryVariant.
-                                  children) {
-                       if (i) {
-                               l = list_entry(i, yaffs_Object, siblings);
-                               yaffs_DestroyObject(l);
-
-                       }
-               }
-       }
-
-       yaffs_ReleaseTempBuffer(dev, chunkData, __LINE__);
-
-       if(alloc_failed){
-               return YAFFS_FAIL;
-       }
-
-       T(YAFFS_TRACE_SCAN, (TSTR("yaffs_ScanBackwards ends" TENDSTR)));
-
-       return YAFFS_OK;
-}
-
-/*------------------------------  Directory Functions ----------------------------- */
-
-static void yaffs_RemoveObjectFromDirectory(yaffs_Object * obj)
-{
-       yaffs_Device *dev = obj->myDev;
-
-       if(dev && dev->removeObjectCallback)
-               dev->removeObjectCallback(obj);
-
-       list_del_init(&obj->siblings);
-       obj->parent = NULL;
-}
-
-
-static void yaffs_AddObjectToDirectory(yaffs_Object * directory,
-                                      yaffs_Object * obj)
-{
-
-       if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a null pointer directory"
-                   TENDSTR)));
-               YBUG();
-       }
-       if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: Trying to add an object to a non-directory"
-                   TENDSTR)));
-               YBUG();
-       }
-
-       if (obj->siblings.prev == NULL) {
-               /* Not initialised */
-               INIT_LIST_HEAD(&obj->siblings);
-
-       } else if (!list_empty(&obj->siblings)) {
-               /* If it is holed up somewhere else, un hook it */
-               yaffs_RemoveObjectFromDirectory(obj);
-       }
-       /* Now add it */
-       list_add(&obj->siblings, &directory->variant.directoryVariant.children);
-       obj->parent = directory;
-
-       if (directory == obj->myDev->unlinkedDir
-           || directory == obj->myDev->deletedDir) {
-               obj->unlinked = 1;
-               obj->myDev->nUnlinkedFiles++;
-               obj->renameAllowed = 0;
-       }
-}
-
-yaffs_Object *yaffs_FindObjectByName(yaffs_Object * directory,
-                                    const YCHAR * name)
-{
-       int sum;
-
-       struct list_head *i;
-       YCHAR buffer[YAFFS_MAX_NAME_LENGTH + 1];
-
-       yaffs_Object *l;
-
-       if (!name) {
-               return NULL;
-       }
-
-       if (!directory) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_FindObjectByName: null pointer directory"
-                   TENDSTR)));
-               YBUG();
-       }
-       if (directory->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
-               YBUG();
-       }
-
-       sum = yaffs_CalcNameSum(name);
-
-       list_for_each(i, &directory->variant.directoryVariant.children) {
-               if (i) {
-                       l = list_entry(i, yaffs_Object, siblings);
-
-                       yaffs_CheckObjectDetailsLoaded(l);
-
-                       /* Special case for lost-n-found */
-                       if (l->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
-                               if (yaffs_strcmp(name, YAFFS_LOSTNFOUND_NAME) == 0) {
-                                       return l;
-                               }
-                       } else if (yaffs_SumCompare(l->sum, sum) || l->chunkId <= 0)
-                       {
-                               /* LostnFound cunk called Objxxx
-                                * Do a real check
-                                */
-                               yaffs_GetObjectName(l, buffer,
-                                                   YAFFS_MAX_NAME_LENGTH);
-                               if (yaffs_strncmp(name, buffer,YAFFS_MAX_NAME_LENGTH) == 0) {
-                                       return l;
-                               }
-
-                       }
-               }
-       }
-
-       return NULL;
-}
-
-
-#if 0
-int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
-                                  int (*fn) (yaffs_Object *))
-{
-       struct list_head *i;
-       yaffs_Object *l;
-
-       if (!theDir) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_FindObjectByName: null pointer directory"
-                   TENDSTR)));
-               YBUG();
-       }
-       if (theDir->variantType != YAFFS_OBJECT_TYPE_DIRECTORY) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("tragedy: yaffs_FindObjectByName: non-directory" TENDSTR)));
-               YBUG();
-       }
-
-       list_for_each(i, &theDir->variant.directoryVariant.children) {
-               if (i) {
-                       l = list_entry(i, yaffs_Object, siblings);
-                       if (l && !fn(l)) {
-                               return YAFFS_FAIL;
-                       }
-               }
-       }
-
-       return YAFFS_OK;
-
-}
-#endif
-
-/* GetEquivalentObject dereferences any hard links to get to the
- * actual object.
- */
-
-yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj)
-{
-       if (obj && obj->variantType == YAFFS_OBJECT_TYPE_HARDLINK) {
-               /* We want the object id of the equivalent object, not this one */
-               obj = obj->variant.hardLinkVariant.equivalentObject;
-               yaffs_CheckObjectDetailsLoaded(obj);
-       }
-       return obj;
-
-}
-
-int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize)
-{
-       memset(name, 0, buffSize * sizeof(YCHAR));
-
-       yaffs_CheckObjectDetailsLoaded(obj);
-
-       if (obj->objectId == YAFFS_OBJECTID_LOSTNFOUND) {
-               yaffs_strncpy(name, YAFFS_LOSTNFOUND_NAME, buffSize - 1);
-       } else if (obj->chunkId <= 0) {
-               YCHAR locName[20];
-               /* make up a name */
-               yaffs_sprintf(locName, _Y("%s%d"), YAFFS_LOSTNFOUND_PREFIX,
-                             obj->objectId);
-               yaffs_strncpy(name, locName, buffSize - 1);
-
-       }
-#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
-       else if (obj->shortName[0]) {
-               yaffs_strcpy(name, obj->shortName);
-       }
-#endif
-       else {
-               int result;
-               __u8 *buffer = yaffs_GetTempBuffer(obj->myDev, __LINE__);
-
-               yaffs_ObjectHeader *oh = (yaffs_ObjectHeader *) buffer;
-
-               memset(buffer, 0, obj->myDev->nDataBytesPerChunk);
-
-               if (obj->chunkId >= 0) {
-                       result = yaffs_ReadChunkWithTagsFromNAND(obj->myDev,
-                                                       obj->chunkId, buffer,
-                                                       NULL);
-               }
-               yaffs_strncpy(name, oh->name, buffSize - 1);
-
-               yaffs_ReleaseTempBuffer(obj->myDev, buffer, __LINE__);
-       }
-
-       return yaffs_strlen(name);
-}
-
-int yaffs_GetObjectFileLength(yaffs_Object * obj)
-{
-
-       /* Dereference any hard linking */
-       obj = yaffs_GetEquivalentObject(obj);
-
-       if (obj->variantType == YAFFS_OBJECT_TYPE_FILE) {
-               return obj->variant.fileVariant.fileSize;
-       }
-       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
-               return yaffs_strlen(obj->variant.symLinkVariant.alias);
-       } else {
-               /* Only a directory should drop through to here */
-               return obj->myDev->nDataBytesPerChunk;
-       }
-}
-
-int yaffs_GetObjectLinkCount(yaffs_Object * obj)
-{
-       int count = 0;
-       struct list_head *i;
-
-       if (!obj->unlinked) {
-               count++;        /* the object itself */
-       }
-       list_for_each(i, &obj->hardLinks) {
-               count++;        /* add the hard links; */
-       }
-       return count;
-
-}
-
-int yaffs_GetObjectInode(yaffs_Object * obj)
-{
-       obj = yaffs_GetEquivalentObject(obj);
-
-       return obj->objectId;
-}
-
-unsigned yaffs_GetObjectType(yaffs_Object * obj)
-{
-       obj = yaffs_GetEquivalentObject(obj);
-
-       switch (obj->variantType) {
-       case YAFFS_OBJECT_TYPE_FILE:
-               return DT_REG;
-               break;
-       case YAFFS_OBJECT_TYPE_DIRECTORY:
-               return DT_DIR;
-               break;
-       case YAFFS_OBJECT_TYPE_SYMLINK:
-               return DT_LNK;
-               break;
-       case YAFFS_OBJECT_TYPE_HARDLINK:
-               return DT_REG;
-               break;
-       case YAFFS_OBJECT_TYPE_SPECIAL:
-               if (S_ISFIFO(obj->yst_mode))
-                       return DT_FIFO;
-               if (S_ISCHR(obj->yst_mode))
-                       return DT_CHR;
-               if (S_ISBLK(obj->yst_mode))
-                       return DT_BLK;
-               if (S_ISSOCK(obj->yst_mode))
-                       return DT_SOCK;
-       default:
-               return DT_REG;
-               break;
-       }
-}
-
-YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj)
-{
-       obj = yaffs_GetEquivalentObject(obj);
-       if (obj->variantType == YAFFS_OBJECT_TYPE_SYMLINK) {
-               return yaffs_CloneString(obj->variant.symLinkVariant.alias);
-       } else {
-               return yaffs_CloneString(_Y(""));
-       }
-}
-
-#ifndef CONFIG_YAFFS_WINCE
-
-int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr)
-{
-       unsigned int valid = attr->ia_valid;
-
-       if (valid & ATTR_MODE)
-               obj->yst_mode = attr->ia_mode;
-       if (valid & ATTR_UID)
-               obj->yst_uid = attr->ia_uid;
-       if (valid & ATTR_GID)
-               obj->yst_gid = attr->ia_gid;
-
-       if (valid & ATTR_ATIME)
-               obj->yst_atime = Y_TIME_CONVERT(attr->ia_atime);
-       if (valid & ATTR_CTIME)
-               obj->yst_ctime = Y_TIME_CONVERT(attr->ia_ctime);
-       if (valid & ATTR_MTIME)
-               obj->yst_mtime = Y_TIME_CONVERT(attr->ia_mtime);
-
-       if (valid & ATTR_SIZE)
-               yaffs_ResizeFile(obj, attr->ia_size);
-
-       yaffs_UpdateObjectHeader(obj, NULL, 1, 0, 0);
-
-       return YAFFS_OK;
-
-}
-int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr)
-{
-       unsigned int valid = 0;
-
-       attr->ia_mode = obj->yst_mode;
-       valid |= ATTR_MODE;
-       attr->ia_uid = obj->yst_uid;
-       valid |= ATTR_UID;
-       attr->ia_gid = obj->yst_gid;
-       valid |= ATTR_GID;
-
-       Y_TIME_CONVERT(attr->ia_atime) = obj->yst_atime;
-       valid |= ATTR_ATIME;
-       Y_TIME_CONVERT(attr->ia_ctime) = obj->yst_ctime;
-       valid |= ATTR_CTIME;
-       Y_TIME_CONVERT(attr->ia_mtime) = obj->yst_mtime;
-       valid |= ATTR_MTIME;
-
-       attr->ia_size = yaffs_GetFileSize(obj);
-       valid |= ATTR_SIZE;
-
-       attr->ia_valid = valid;
-
-       return YAFFS_OK;
-
-}
-
-#endif
-
-#if 0
-int yaffs_DumpObject(yaffs_Object * obj)
-{
-       YCHAR name[257];
-
-       yaffs_GetObjectName(obj, name, 256);
-
-       T(YAFFS_TRACE_ALWAYS,
-         (TSTR
-          ("Object %d, inode %d \"%s\"\n dirty %d valid %d serial %d sum %d"
-           " chunk %d type %d size %d\n"
-           TENDSTR), obj->objectId, yaffs_GetObjectInode(obj), name,
-          obj->dirty, obj->valid, obj->serial, obj->sum, obj->chunkId,
-          yaffs_GetObjectType(obj), yaffs_GetObjectFileLength(obj)));
-
-       return YAFFS_OK;
-}
-#endif
-
-/*---------------------------- Initialisation code -------------------------------------- */
-
-static int yaffs_CheckDevFunctions(const yaffs_Device * dev)
-{
-
-       /* Common functions, gotta have */
-       if (!dev->eraseBlockInNAND || !dev->initialiseNAND)
-               return 0;
-
-#ifdef CONFIG_YAFFS_YAFFS2
-
-       /* Can use the "with tags" style interface for yaffs1 or yaffs2 */
-       if (dev->writeChunkWithTagsToNAND &&
-           dev->readChunkWithTagsFromNAND &&
-           !dev->writeChunkToNAND &&
-           !dev->readChunkFromNAND &&
-           dev->markNANDBlockBad && dev->queryNANDBlock)
-               return 1;
-#endif
-
-       /* Can use the "spare" style interface for yaffs1 */
-       if (!dev->isYaffs2 &&
-           !dev->writeChunkWithTagsToNAND &&
-           !dev->readChunkWithTagsFromNAND &&
-           dev->writeChunkToNAND &&
-           dev->readChunkFromNAND &&
-           !dev->markNANDBlockBad && !dev->queryNANDBlock)
-               return 1;
-
-       return 0;               /* bad */
-}
-
-
-static int yaffs_CreateInitialDirectories(yaffs_Device *dev)
-{
-       /* Initialise the unlinked, deleted, root and lost and found directories */
-
-       dev->lostNFoundDir = dev->rootDir =  NULL;
-       dev->unlinkedDir = dev->deletedDir = NULL;
-
-       dev->unlinkedDir =
-           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_UNLINKED, S_IFDIR);
-
-       dev->deletedDir =
-           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_DELETED, S_IFDIR);
-
-       dev->rootDir =
-           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_ROOT,
-                                     YAFFS_ROOT_MODE | S_IFDIR);
-       dev->lostNFoundDir =
-           yaffs_CreateFakeDirectory(dev, YAFFS_OBJECTID_LOSTNFOUND,
-                                     YAFFS_LOSTNFOUND_MODE | S_IFDIR);
-
-       if(dev->lostNFoundDir && dev->rootDir && dev->unlinkedDir && dev->deletedDir){
-               yaffs_AddObjectToDirectory(dev->rootDir, dev->lostNFoundDir);
-               return YAFFS_OK;
-       }
-
-       return YAFFS_FAIL;
-}
-
-int yaffs_GutsInitialise(yaffs_Device * dev)
-{
-       int init_failed = 0;
-       unsigned x;
-       int bits;
-
-       T(YAFFS_TRACE_TRACING, (TSTR("yaffs: yaffs_GutsInitialise()" TENDSTR)));
-
-       /* Check stuff that must be set */
-
-       if (!dev) {
-               T(YAFFS_TRACE_ALWAYS, (TSTR("yaffs: Need a device" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       dev->internalStartBlock = dev->startBlock;
-       dev->internalEndBlock = dev->endBlock;
-       dev->blockOffset = 0;
-       dev->chunkOffset = 0;
-       dev->nFreeChunks = 0;
-
-       if (dev->startBlock == 0) {
-               dev->internalStartBlock = dev->startBlock + 1;
-               dev->internalEndBlock = dev->endBlock + 1;
-               dev->blockOffset = 1;
-               dev->chunkOffset = dev->nChunksPerBlock;
-       }
-
-       /* Check geometry parameters. */
-
-       if ((dev->isYaffs2 && dev->nDataBytesPerChunk < 1024) ||
-           (!dev->isYaffs2 && dev->nDataBytesPerChunk != 512) ||
-            dev->nChunksPerBlock < 2 ||
-            dev->nReservedBlocks < 2 ||
-            dev->internalStartBlock <= 0 ||
-            dev->internalEndBlock <= 0 ||
-            dev->internalEndBlock <= (dev->internalStartBlock + dev->nReservedBlocks + 2)      // otherwise it is too small
-           ) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("yaffs: NAND geometry problems: chunk size %d, type is yaffs%s "
-                   TENDSTR), dev->nDataBytesPerChunk, dev->isYaffs2 ? "2" : ""));
-               return YAFFS_FAIL;
-       }
-
-       if (yaffs_InitialiseNAND(dev) != YAFFS_OK) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: InitialiseNAND failed" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       /* Got the right mix of functions? */
-       if (!yaffs_CheckDevFunctions(dev)) {
-               /* Function missing */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR
-                  ("yaffs: device function(s) missing or wrong\n" TENDSTR)));
-
-               return YAFFS_FAIL;
-       }
-
-       /* This is really a compilation check. */
-       if (!yaffs_CheckStructures()) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs_CheckStructures failed\n" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       if (dev->isMounted) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: device already mounted\n" TENDSTR)));
-               return YAFFS_FAIL;
-       }
-
-       /* Finished with most checks. One or two more checks happen later on too. */
-
-       dev->isMounted = 1;
-
-
-
-       /* OK now calculate a few things for the device */
-
-       /*
-        *  Calculate all the chunk size manipulation numbers:
-        */
-        /* Start off assuming it is a power of 2 */
-        dev->chunkShift = ShiftDiv(dev->nDataBytesPerChunk);
-        dev->chunkMask = (1<<dev->chunkShift) - 1;
-
-        if(dev->nDataBytesPerChunk == (dev->chunkMask + 1)){
-               /* Yes it is a power of 2, disable crumbs */
-               dev->crumbMask = 0;
-               dev->crumbShift = 0;
-               dev->crumbsPerChunk = 0;
-        } else {
-               /* Not a power of 2, use crumbs instead */
-               dev->crumbShift = ShiftDiv(sizeof(yaffs_PackedTags2TagsPart));
-               dev->crumbMask = (1<<dev->crumbShift)-1;
-               dev->crumbsPerChunk = dev->nDataBytesPerChunk/(1 << dev->crumbShift);
-               dev->chunkShift = 0;
-               dev->chunkMask = 0;
-       }
-
-
-       /*
-        * Calculate chunkGroupBits.
-        * We need to find the next power of 2 > than internalEndBlock
-        */
-
-       x = dev->nChunksPerBlock * (dev->internalEndBlock + 1);
-
-       bits = ShiftsGE(x);
-
-       /* Set up tnode width if wide tnodes are enabled. */
-       if(!dev->wideTnodesDisabled){
-               /* bits must be even so that we end up with 32-bit words */
-               if(bits & 1)
-                       bits++;
-               if(bits < 16)
-                       dev->tnodeWidth = 16;
-               else
-                       dev->tnodeWidth = bits;
-       }
-       else
-               dev->tnodeWidth = 16;
-
-       dev->tnodeMask = (1<<dev->tnodeWidth)-1;
-
-       /* Level0 Tnodes are 16 bits or wider (if wide tnodes are enabled),
-        * so if the bitwidth of the
-        * chunk range we're using is greater than 16 we need
-        * to figure out chunk shift and chunkGroupSize
-        */
-
-       if (bits <= dev->tnodeWidth)
-               dev->chunkGroupBits = 0;
-       else
-               dev->chunkGroupBits = bits - dev->tnodeWidth;
-
-
-       dev->chunkGroupSize = 1 << dev->chunkGroupBits;
-
-       if (dev->nChunksPerBlock < dev->chunkGroupSize) {
-               /* We have a problem because the soft delete won't work if
-                * the chunk group size > chunks per block.
-                * This can be remedied by using larger "virtual blocks".
-                */
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("yaffs: chunk group too large\n" TENDSTR)));
-
-               return YAFFS_FAIL;
-       }
-
-       /* OK, we've finished verifying the device, lets continue with initialisation */
-
-       /* More device initialisation */
-       dev->garbageCollections = 0;
-       dev->passiveGarbageCollections = 0;
-       dev->currentDirtyChecker = 0;
-       dev->bufferedBlock = -1;
-       dev->doingBufferedBlockRewrite = 0;
-       dev->nDeletedFiles = 0;
-       dev->nBackgroundDeletions = 0;
-       dev->nUnlinkedFiles = 0;
-       dev->eccFixed = 0;
-       dev->eccUnfixed = 0;
-       dev->tagsEccFixed = 0;
-       dev->tagsEccUnfixed = 0;
-       dev->nErasureFailures = 0;
-       dev->nErasedBlocks = 0;
-       dev->isDoingGC = 0;
-       dev->hasPendingPrioritisedGCs = 1; /* Assume the worst for now, will get fixed on first GC */
-
-       /* Initialise temporary buffers and caches. */
-       if(!yaffs_InitialiseTempBuffers(dev))
-               init_failed = 1;
-
-       dev->srCache = NULL;
-       dev->gcCleanupList = NULL;
-
-
-       if (!init_failed &&
-           dev->nShortOpCaches > 0) {
-               int i;
-               __u8 *buf;
-               int srCacheBytes = dev->nShortOpCaches * sizeof(yaffs_ChunkCache);
-
-               if (dev->nShortOpCaches > YAFFS_MAX_SHORT_OP_CACHES) {
-                       dev->nShortOpCaches = YAFFS_MAX_SHORT_OP_CACHES;
-               }
-
-               buf = dev->srCache =  YMALLOC(srCacheBytes);
-
-               if(dev->srCache)
-                       memset(dev->srCache,0,srCacheBytes);
-
-               for (i = 0; i < dev->nShortOpCaches && buf; i++) {
-                       dev->srCache[i].object = NULL;
-                       dev->srCache[i].lastUse = 0;
-                       dev->srCache[i].dirty = 0;
-                       dev->srCache[i].data = buf = YMALLOC_DMA(dev->nDataBytesPerChunk);
-               }
-               if(!buf)
-                       init_failed = 1;
-
-               dev->srLastUse = 0;
-       }
-
-       dev->cacheHits = 0;
-
-       if(!init_failed){
-               dev->gcCleanupList = YMALLOC(dev->nChunksPerBlock * sizeof(__u32));
-               if(!dev->gcCleanupList)
-                       init_failed = 1;
-       }
-
-       if (dev->isYaffs2) {
-               dev->useHeaderFileSize = 1;
-       }
-       if(!init_failed && !yaffs_InitialiseBlocks(dev))
-               init_failed = 1;
-
-       yaffs_InitialiseTnodes(dev);
-       yaffs_InitialiseObjects(dev);
-
-       if(!init_failed && !yaffs_CreateInitialDirectories(dev))
-               init_failed = 1;
-
-
-       if(!init_failed){
-               /* Now scan the flash. */
-               if (dev->isYaffs2) {
-                       if(yaffs_CheckpointRestore(dev)) {
-                               T(YAFFS_TRACE_ALWAYS,
-                                 (TSTR("yaffs: restored from checkpoint" TENDSTR)));
-                       } else {
-
-                               /* Clean up the mess caused by an aborted checkpoint load
-                                * and scan backwards.
-                                */
-                               yaffs_DeinitialiseBlocks(dev);
-                               yaffs_DeinitialiseTnodes(dev);
-                               yaffs_DeinitialiseObjects(dev);
-
-
-                               dev->nErasedBlocks = 0;
-                               dev->nFreeChunks = 0;
-                               dev->allocationBlock = -1;
-                               dev->allocationPage = -1;
-                               dev->nDeletedFiles = 0;
-                               dev->nUnlinkedFiles = 0;
-                               dev->nBackgroundDeletions = 0;
-                               dev->oldestDirtySequence = 0;
-
-                               if(!init_failed && !yaffs_InitialiseBlocks(dev))
-                                       init_failed = 1;
-
-                               yaffs_InitialiseTnodes(dev);
-                               yaffs_InitialiseObjects(dev);
-
-                               if(!init_failed && !yaffs_CreateInitialDirectories(dev))
-                                       init_failed = 1;
-
-                               if(!init_failed && !yaffs_ScanBackwards(dev))
-                                       init_failed = 1;
-                       }
-               }else
-                       if(!yaffs_Scan(dev))
-                               init_failed = 1;
-       }
-
-       if(init_failed){
-               /* Clean up the mess */
-               T(YAFFS_TRACE_TRACING,
-                 (TSTR("yaffs: yaffs_GutsInitialise() aborted.\n" TENDSTR)));
-
-               yaffs_Deinitialise(dev);
-               return YAFFS_FAIL;
-       }
-
-       /* Zero out stats */
-       dev->nPageReads = 0;
-       dev->nPageWrites = 0;
-       dev->nBlockErasures = 0;
-       dev->nGCCopies = 0;
-       dev->nRetriedWrites = 0;
-
-       dev->nRetiredBlocks = 0;
-
-       yaffs_VerifyFreeChunks(dev);
-       yaffs_VerifyBlocks(dev);
-
-
-       T(YAFFS_TRACE_TRACING,
-         (TSTR("yaffs: yaffs_GutsInitialise() done.\n" TENDSTR)));
-       return YAFFS_OK;
-
-}
-
-void yaffs_Deinitialise(yaffs_Device * dev)
-{
-       if (dev->isMounted) {
-               int i;
-
-               yaffs_DeinitialiseBlocks(dev);
-               yaffs_DeinitialiseTnodes(dev);
-               yaffs_DeinitialiseObjects(dev);
-               if (dev->nShortOpCaches > 0 &&
-                   dev->srCache) {
-
-                       for (i = 0; i < dev->nShortOpCaches; i++) {
-                               if(dev->srCache[i].data)
-                                       YFREE(dev->srCache[i].data);
-                               dev->srCache[i].data = NULL;
-                       }
-
-                       YFREE(dev->srCache);
-                       dev->srCache = NULL;
-               }
-
-               YFREE(dev->gcCleanupList);
-
-               for (i = 0; i < YAFFS_N_TEMP_BUFFERS; i++) {
-                       YFREE(dev->tempBuffer[i].buffer);
-               }
-
-               dev->isMounted = 0;
-       }
-
-}
-
-static int yaffs_CountFreeChunks(yaffs_Device * dev)
-{
-       int nFree;
-       int b;
-
-       yaffs_BlockInfo *blk;
-
-       for (nFree = 0, b = dev->internalStartBlock; b <= dev->internalEndBlock;
-            b++) {
-               blk = yaffs_GetBlockInfo(dev, b);
-
-               switch (blk->blockState) {
-               case YAFFS_BLOCK_STATE_EMPTY:
-               case YAFFS_BLOCK_STATE_ALLOCATING:
-               case YAFFS_BLOCK_STATE_COLLECTING:
-               case YAFFS_BLOCK_STATE_FULL:
-                       nFree +=
-                           (dev->nChunksPerBlock - blk->pagesInUse +
-                            blk->softDeletions);
-                       break;
-               default:
-                       break;
-               }
-
-       }
-
-       return nFree;
-}
-
-int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev)
-{
-       /* This is what we report to the outside world */
-
-       int nFree;
-       int nDirtyCacheChunks;
-       int blocksForCheckpoint;
-
-#if 1
-       nFree = dev->nFreeChunks;
-#else
-       nFree = yaffs_CountFreeChunks(dev);
-#endif
-
-       nFree += dev->nDeletedFiles;
-
-       /* Now count the number of dirty chunks in the cache and subtract those */
-
-       {
-               int i;
-               for (nDirtyCacheChunks = 0, i = 0; i < dev->nShortOpCaches; i++) {
-                       if (dev->srCache[i].dirty)
-                               nDirtyCacheChunks++;
-               }
-       }
-
-       nFree -= nDirtyCacheChunks;
-
-       nFree -= ((dev->nReservedBlocks + 1) * dev->nChunksPerBlock);
-
-       /* Now we figure out how much to reserve for the checkpoint and report that... */
-       blocksForCheckpoint = dev->nCheckpointReservedBlocks - dev->blocksInCheckpoint;
-       if(blocksForCheckpoint < 0)
-               blocksForCheckpoint = 0;
-
-       nFree -= (blocksForCheckpoint * dev->nChunksPerBlock);
-
-       if (nFree < 0)
-               nFree = 0;
-
-       return nFree;
-
-}
-
-static int yaffs_freeVerificationFailures;
-
-static void yaffs_VerifyFreeChunks(yaffs_Device * dev)
-{
-       int counted;
-       int difference;
-
-       if(yaffs_SkipVerification(dev))
-               return;
-
-       counted = yaffs_CountFreeChunks(dev);
-
-       difference = dev->nFreeChunks - counted;
-
-       if (difference) {
-               T(YAFFS_TRACE_ALWAYS,
-                 (TSTR("Freechunks verification failure %d %d %d" TENDSTR),
-                  dev->nFreeChunks, counted, difference));
-               yaffs_freeVerificationFailures++;
-       }
-}
-
-/*---------------------------------------- YAFFS test code ----------------------*/
-
-#define yaffs_CheckStruct(structure,syze, name) \
-           if(sizeof(structure) != syze) \
-              { \
-                T(YAFFS_TRACE_ALWAYS,(TSTR("%s should be %d but is %d\n" TENDSTR),\
-                name,syze,sizeof(structure))); \
-                return YAFFS_FAIL; \
-               }
-
-static int yaffs_CheckStructures(void)
-{
-/*      yaffs_CheckStruct(yaffs_Tags,8,"yaffs_Tags") */
-/*      yaffs_CheckStruct(yaffs_TagsUnion,8,"yaffs_TagsUnion") */
-/*      yaffs_CheckStruct(yaffs_Spare,16,"yaffs_Spare") */
-#ifndef CONFIG_YAFFS_TNODE_LIST_DEBUG
-       yaffs_CheckStruct(yaffs_Tnode, 2 * YAFFS_NTNODES_LEVEL0, "yaffs_Tnode")
-#endif
-           yaffs_CheckStruct(yaffs_ObjectHeader, 512, "yaffs_ObjectHeader")
-
-           return YAFFS_OK;
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_guts.h
deleted file mode 100644 (file)
index ea06c1a..0000000
+++ /dev/null
@@ -1,902 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_GUTS_H__
-#define __YAFFS_GUTS_H__
-
-#include "devextras.h"
-#include "yportenv.h"
-
-#define YAFFS_OK       1
-#define YAFFS_FAIL  0
-
-/* Give us a  Y=0x59,
- * Give us an A=0x41,
- * Give us an FF=0xFF
- * Give us an S=0x53
- * And what have we got...
- */
-#define YAFFS_MAGIC                    0x5941FF53
-
-#define YAFFS_NTNODES_LEVEL0           16
-#define YAFFS_TNODES_LEVEL0_BITS       4
-#define YAFFS_TNODES_LEVEL0_MASK       0xf
-
-#define YAFFS_NTNODES_INTERNAL                 (YAFFS_NTNODES_LEVEL0 / 2)
-#define YAFFS_TNODES_INTERNAL_BITS     (YAFFS_TNODES_LEVEL0_BITS - 1)
-#define YAFFS_TNODES_INTERNAL_MASK     0x7
-#define YAFFS_TNODES_MAX_LEVEL         6
-
-#ifndef CONFIG_YAFFS_NO_YAFFS1
-#define YAFFS_BYTES_PER_SPARE          16
-#define YAFFS_BYTES_PER_CHUNK          512
-#define YAFFS_CHUNK_SIZE_SHIFT         9
-#define YAFFS_CHUNKS_PER_BLOCK         32
-#define YAFFS_BYTES_PER_BLOCK          (YAFFS_CHUNKS_PER_BLOCK*YAFFS_BYTES_PER_CHUNK)
-#endif
-
-#define YAFFS_MIN_YAFFS2_CHUNK_SIZE    1024
-#define YAFFS_MIN_YAFFS2_SPARE_SIZE    32
-
-#define YAFFS_MAX_CHUNK_ID             0x000FFFFF
-
-#define YAFFS_UNUSED_OBJECT_ID         0x0003FFFF
-
-#define YAFFS_ALLOCATION_NOBJECTS      100
-#define YAFFS_ALLOCATION_NTNODES       100
-#define YAFFS_ALLOCATION_NLINKS                100
-
-#define YAFFS_NOBJECT_BUCKETS          256
-
-
-#define YAFFS_OBJECT_SPACE             0x40000
-
-#define YAFFS_CHECKPOINT_VERSION       3
-
-#ifdef CONFIG_YAFFS_UNICODE
-#define YAFFS_MAX_NAME_LENGTH          127
-#define YAFFS_MAX_ALIAS_LENGTH         79
-#else
-#define YAFFS_MAX_NAME_LENGTH          255
-#define YAFFS_MAX_ALIAS_LENGTH         159
-#endif
-
-#define YAFFS_SHORT_NAME_LENGTH                15
-
-/* Some special object ids for pseudo objects */
-#define YAFFS_OBJECTID_ROOT            1
-#define YAFFS_OBJECTID_LOSTNFOUND      2
-#define YAFFS_OBJECTID_UNLINKED                3
-#define YAFFS_OBJECTID_DELETED         4
-
-/* Sseudo object ids for checkpointing */
-#define YAFFS_OBJECTID_SB_HEADER       0x10
-#define YAFFS_OBJECTID_CHECKPOINT_DATA 0x20
-#define YAFFS_SEQUENCE_CHECKPOINT_DATA  0x21
-
-/* */
-
-#define YAFFS_MAX_SHORT_OP_CACHES      20
-
-#define YAFFS_N_TEMP_BUFFERS           4
-
-/* We limit the number attempts at sucessfully saving a chunk of data.
- * Small-page devices have 32 pages per block; large-page devices have 64.
- * Default to something in the order of 5 to 10 blocks worth of chunks.
- */
-#define YAFFS_WR_ATTEMPTS              (5*64)
-
-/* Sequence numbers are used in YAFFS2 to determine block allocation order.
- * The range is limited slightly to help distinguish bad numbers from good.
- * This also allows us to perhaps in the future use special numbers for
- * special purposes.
- * EFFFFF00 allows the allocation of 8 blocks per second (~1Mbytes) for 15 years,
- * and is a larger number than the lifetime of a 2GB device.
- */
-#define YAFFS_LOWEST_SEQUENCE_NUMBER   0x00001000
-#define YAFFS_HIGHEST_SEQUENCE_NUMBER  0xEFFFFF00
-
-/* ChunkCache is used for short read/write operations.*/
-typedef struct {
-       struct yaffs_ObjectStruct *object;
-       int chunkId;
-       int lastUse;
-       int dirty;
-       int nBytes;             /* Only valid if the cache is dirty */
-       int locked;             /* Can't push out or flush while locked. */
-#ifdef CONFIG_YAFFS_YAFFS2
-       __u8 *data;
-#else
-       __u8 data[YAFFS_BYTES_PER_CHUNK];
-#endif
-} yaffs_ChunkCache;
-
-
-
-/* Tags structures in RAM
- * NB This uses bitfield. Bitfields should not straddle a u32 boundary otherwise
- * the structure size will get blown out.
- */
-
-#ifndef CONFIG_YAFFS_NO_YAFFS1
-typedef struct {
-       unsigned chunkId:20;
-       unsigned serialNumber:2;
-       unsigned byteCount:10;
-       unsigned objectId:18;
-       unsigned ecc:12;
-       unsigned unusedStuff:2;
-
-} yaffs_Tags;
-
-typedef union {
-       yaffs_Tags asTags;
-       __u8 asBytes[8];
-} yaffs_TagsUnion;
-
-#endif
-
-/* Stuff used for extended tags in YAFFS2 */
-
-typedef enum {
-       YAFFS_ECC_RESULT_UNKNOWN,
-       YAFFS_ECC_RESULT_NO_ERROR,
-       YAFFS_ECC_RESULT_FIXED,
-       YAFFS_ECC_RESULT_UNFIXED
-} yaffs_ECCResult;
-
-typedef enum {
-       YAFFS_OBJECT_TYPE_UNKNOWN,
-       YAFFS_OBJECT_TYPE_FILE,
-       YAFFS_OBJECT_TYPE_SYMLINK,
-       YAFFS_OBJECT_TYPE_DIRECTORY,
-       YAFFS_OBJECT_TYPE_HARDLINK,
-       YAFFS_OBJECT_TYPE_SPECIAL
-} yaffs_ObjectType;
-
-#define YAFFS_OBJECT_TYPE_MAX YAFFS_OBJECT_TYPE_SPECIAL
-
-typedef struct {
-
-       unsigned validMarker0;
-       unsigned chunkUsed;     /*  Status of the chunk: used or unused */
-       unsigned objectId;      /* If 0 then this is not part of an object (unused) */
-       unsigned chunkId;       /* If 0 then this is a header, else a data chunk */
-       unsigned byteCount;     /* Only valid for data chunks */
-
-       /* The following stuff only has meaning when we read */
-       yaffs_ECCResult eccResult;
-       unsigned blockBad;
-
-       /* YAFFS 1 stuff */
-       unsigned chunkDeleted;  /* The chunk is marked deleted */
-       unsigned serialNumber;  /* Yaffs1 2-bit serial number */
-
-       /* YAFFS2 stuff */
-       unsigned sequenceNumber;        /* The sequence number of this block */
-
-       /* Extra info if this is an object header (YAFFS2 only) */
-
-       unsigned extraHeaderInfoAvailable;      /* There is extra info available if this is not zero */
-       unsigned extraParentObjectId;   /* The parent object */
-       unsigned extraIsShrinkHeader;   /* Is it a shrink header? */
-       unsigned extraShadows;          /* Does this shadow another object? */
-
-       yaffs_ObjectType extraObjectType;       /* What object type? */
-
-       unsigned extraFileLength;               /* Length if it is a file */
-       unsigned extraEquivalentObjectId;       /* Equivalent object Id if it is a hard link */
-
-       unsigned validMarker1;
-
-} yaffs_ExtendedTags;
-
-/* Spare structure for YAFFS1 */
-typedef struct {
-       __u8 tagByte0;
-       __u8 tagByte1;
-       __u8 tagByte2;
-       __u8 tagByte3;
-       __u8 pageStatus;        /* set to 0 to delete the chunk */
-       __u8 blockStatus;
-       __u8 tagByte4;
-       __u8 tagByte5;
-       __u8 ecc1[3];
-       __u8 tagByte6;
-       __u8 tagByte7;
-       __u8 ecc2[3];
-} yaffs_Spare;
-
-/*Special structure for passing through to mtd */
-struct yaffs_NANDSpare {
-       yaffs_Spare spare;
-       int eccres1;
-       int eccres2;
-};
-
-/* Block data in RAM */
-
-typedef enum {
-       YAFFS_BLOCK_STATE_UNKNOWN = 0,
-
-       YAFFS_BLOCK_STATE_SCANNING,
-       YAFFS_BLOCK_STATE_NEEDS_SCANNING,
-       /* The block might have something on it (ie it is allocating or full, perhaps empty)
-        * but it needs to be scanned to determine its true state.
-        * This state is only valid during yaffs_Scan.
-        * NB We tolerate empty because the pre-scanner might be incapable of deciding
-        * However, if this state is returned on a YAFFS2 device, then we expect a sequence number
-        */
-
-       YAFFS_BLOCK_STATE_EMPTY,
-       /* This block is empty */
-
-       YAFFS_BLOCK_STATE_ALLOCATING,
-       /* This block is partially allocated.
-        * At least one page holds valid data.
-        * This is the one currently being used for page
-        * allocation. Should never be more than one of these
-        */
-
-       YAFFS_BLOCK_STATE_FULL,
-       /* All the pages in this block have been allocated.
-        */
-
-       YAFFS_BLOCK_STATE_DIRTY,
-       /* All pages have been allocated and deleted.
-        * Erase me, reuse me.
-        */
-
-       YAFFS_BLOCK_STATE_CHECKPOINT,
-       /* This block is assigned to holding checkpoint data.
-        */
-
-       YAFFS_BLOCK_STATE_COLLECTING,
-       /* This block is being garbage collected */
-
-       YAFFS_BLOCK_STATE_DEAD
-       /* This block has failed and is not in use */
-} yaffs_BlockState;
-
-#define        YAFFS_NUMBER_OF_BLOCK_STATES (YAFFS_BLOCK_STATE_DEAD + 1)
-
-
-typedef struct {
-
-       int softDeletions:10;   /* number of soft deleted pages */
-       int pagesInUse:10;      /* number of pages in use */
-       yaffs_BlockState blockState:4;  /* One of the above block states */
-       __u32 needsRetiring:1;  /* Data has failed on this block, need to get valid data off */
-                               /* and retire the block. */
-       __u32 skipErasedCheck: 1; /* If this is set we can skip the erased check on this block */
-       __u32 gcPrioritise: 1;  /* An ECC check or blank check has failed on this block.
-                                  It should be prioritised for GC */
-        __u32 chunkErrorStrikes:3; /* How many times we've had ecc etc failures on this block and tried to reuse it */
-
-#ifdef CONFIG_YAFFS_YAFFS2
-       __u32 hasShrinkHeader:1; /* This block has at least one shrink object header */
-       __u32 sequenceNumber;    /* block sequence number for yaffs2 */
-#endif
-
-} yaffs_BlockInfo;
-
-/* -------------------------- Object structure -------------------------------*/
-/* This is the object structure as stored on NAND */
-
-typedef struct {
-       yaffs_ObjectType type;
-
-       /* Apply to everything  */
-       int parentObjectId;
-       __u16 sum__NoLongerUsed;        /* checksum of name. No longer used */
-       YCHAR name[YAFFS_MAX_NAME_LENGTH + 1];
-
-       /* Thes following apply to directories, files, symlinks - not hard links */
-       __u32 yst_mode;         /* protection */
-
-#ifdef CONFIG_YAFFS_WINCE
-       __u32 notForWinCE[5];
-#else
-       __u32 yst_uid;
-       __u32 yst_gid;
-       __u32 yst_atime;
-       __u32 yst_mtime;
-       __u32 yst_ctime;
-#endif
-
-       /* File size  applies to files only */
-       int fileSize;
-
-       /* Equivalent object id applies to hard links only. */
-       int equivalentObjectId;
-
-       /* Alias is for symlinks only. */
-       YCHAR alias[YAFFS_MAX_ALIAS_LENGTH + 1];
-
-       __u32 yst_rdev;         /* device stuff for block and char devices (major/min) */
-
-#ifdef CONFIG_YAFFS_WINCE
-       __u32 win_ctime[2];
-       __u32 win_atime[2];
-       __u32 win_mtime[2];
-       __u32 roomToGrow[4];
-#else
-       __u32 roomToGrow[10];
-#endif
-
-       int shadowsObject;      /* This object header shadows the specified object if > 0 */
-
-       /* isShrink applies to object headers written when we shrink the file (ie resize) */
-       __u32 isShrink;
-
-} yaffs_ObjectHeader;
-
-/*--------------------------- Tnode -------------------------- */
-
-union yaffs_Tnode_union {
-#ifdef CONFIG_YAFFS_TNODE_LIST_DEBUG
-       union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL + 1];
-#else
-       union yaffs_Tnode_union *internal[YAFFS_NTNODES_INTERNAL];
-#endif
-/*     __u16 level0[YAFFS_NTNODES_LEVEL0]; */
-
-};
-
-typedef union yaffs_Tnode_union yaffs_Tnode;
-
-struct yaffs_TnodeList_struct {
-       struct yaffs_TnodeList_struct *next;
-       yaffs_Tnode *tnodes;
-};
-
-typedef struct yaffs_TnodeList_struct yaffs_TnodeList;
-
-/*------------------------  Object -----------------------------*/
-/* An object can be one of:
- * - a directory (no data, has children links
- * - a regular file (data.... not prunes :->).
- * - a symlink [symbolic link] (the alias).
- * - a hard link
- */
-
-typedef struct {
-       __u32 fileSize;
-       __u32 scannedFileSize;
-       __u32 shrinkSize;
-       int topLevel;
-       yaffs_Tnode *top;
-} yaffs_FileStructure;
-
-typedef struct {
-       struct list_head children;      /* list of child links */
-} yaffs_DirectoryStructure;
-
-typedef struct {
-       YCHAR *alias;
-} yaffs_SymLinkStructure;
-
-typedef struct {
-       struct yaffs_ObjectStruct *equivalentObject;
-       __u32 equivalentObjectId;
-} yaffs_HardLinkStructure;
-
-typedef union {
-       yaffs_FileStructure fileVariant;
-       yaffs_DirectoryStructure directoryVariant;
-       yaffs_SymLinkStructure symLinkVariant;
-       yaffs_HardLinkStructure hardLinkVariant;
-} yaffs_ObjectVariant;
-
-struct yaffs_ObjectStruct {
-       __u8 deleted:1;         /* This should only apply to unlinked files. */
-       __u8 softDeleted:1;     /* it has also been soft deleted */
-       __u8 unlinked:1;        /* An unlinked file. The file should be in the unlinked directory.*/
-       __u8 fake:1;            /* A fake object has no presence on NAND. */
-       __u8 renameAllowed:1;   /* Some objects are not allowed to be renamed. */
-       __u8 unlinkAllowed:1;
-       __u8 dirty:1;           /* the object needs to be written to flash */
-       __u8 valid:1;           /* When the file system is being loaded up, this
-                                * object might be created before the data
-                                * is available (ie. file data records appear before the header).
-                                */
-       __u8 lazyLoaded:1;      /* This object has been lazy loaded and is missing some detail */
-
-       __u8 deferedFree:1;     /* For Linux kernel. Object is removed from NAND, but is
-                                * still in the inode cache. Free of object is defered.
-                                * until the inode is released.
-                                */
-
-       __u8 serial;            /* serial number of chunk in NAND. Cached here */
-       __u16 sum;              /* sum of the name to speed searching */
-
-       struct yaffs_DeviceStruct *myDev;       /* The device I'm on */
-
-       struct list_head hashLink;      /* list of objects in this hash bucket */
-
-       struct list_head hardLinks;     /* all the equivalent hard linked objects */
-
-       /* directory structure stuff */
-       /* also used for linking up the free list */
-       struct yaffs_ObjectStruct *parent;
-       struct list_head siblings;
-
-       /* Where's my object header in NAND? */
-       int chunkId;
-
-       int nDataChunks;        /* Number of data chunks attached to the file. */
-
-       __u32 objectId;         /* the object id value */
-
-       __u32 yst_mode;
-
-#ifdef CONFIG_YAFFS_SHORT_NAMES_IN_RAM
-       YCHAR shortName[YAFFS_SHORT_NAME_LENGTH + 1];
-#endif
-
-#ifndef __KERNEL__
-       __u32 inUse;
-#endif
-
-#ifdef CONFIG_YAFFS_WINCE
-       __u32 win_ctime[2];
-       __u32 win_mtime[2];
-       __u32 win_atime[2];
-#else
-       __u32 yst_uid;
-       __u32 yst_gid;
-       __u32 yst_atime;
-       __u32 yst_mtime;
-       __u32 yst_ctime;
-#endif
-
-       __u32 yst_rdev;
-
-#ifdef __KERNEL__
-       struct inode *myInode;
-
-#endif
-
-       yaffs_ObjectType variantType;
-
-       yaffs_ObjectVariant variant;
-
-};
-
-typedef struct yaffs_ObjectStruct yaffs_Object;
-
-struct yaffs_ObjectList_struct {
-       yaffs_Object *objects;
-       struct yaffs_ObjectList_struct *next;
-};
-
-typedef struct yaffs_ObjectList_struct yaffs_ObjectList;
-
-typedef struct {
-       struct list_head list;
-       int count;
-} yaffs_ObjectBucket;
-
-
-/* yaffs_CheckpointObject holds the definition of an object as dumped
- * by checkpointing.
- */
-
-typedef struct {
-        int structType;
-       __u32 objectId;
-       __u32 parentId;
-       int chunkId;
-
-       yaffs_ObjectType variantType:3;
-       __u8 deleted:1;
-       __u8 softDeleted:1;
-       __u8 unlinked:1;
-       __u8 fake:1;
-       __u8 renameAllowed:1;
-       __u8 unlinkAllowed:1;
-       __u8 serial;
-
-       int nDataChunks;
-       __u32 fileSizeOrEquivalentObjectId;
-
-}yaffs_CheckpointObject;
-
-/*--------------------- Temporary buffers ----------------
- *
- * These are chunk-sized working buffers. Each device has a few
- */
-
-typedef struct {
-       __u8 *buffer;
-       int line;       /* track from whence this buffer was allocated */
-       int maxLine;
-} yaffs_TempBuffer;
-
-/*----------------- Device ---------------------------------*/
-
-struct yaffs_DeviceStruct {
-       struct list_head devList;
-       const char *name;
-
-       /* Entry parameters set up way early. Yaffs sets up the rest.*/
-       int nDataBytesPerChunk; /* Should be a power of 2 >= 512 */
-       int nChunksPerBlock;    /* does not need to be a power of 2 */
-       int nBytesPerSpare;     /* spare area size */
-       int startBlock;         /* Start block we're allowed to use */
-       int endBlock;           /* End block we're allowed to use */
-       int nReservedBlocks;    /* We want this tuneable so that we can reduce */
-                               /* reserved blocks on NOR and RAM. */
-
-
-       /* Stuff used by the shared space checkpointing mechanism */
-       /* If this value is zero, then this mechanism is disabled */
-
-       int nCheckpointReservedBlocks; /* Blocks to reserve for checkpoint data */
-
-
-
-
-       int nShortOpCaches;     /* If <= 0, then short op caching is disabled, else
-                                * the number of short op caches (don't use too many)
-                                */
-
-       int useHeaderFileSize;  /* Flag to determine if we should use file sizes from the header */
-
-       int useNANDECC;         /* Flag to decide whether or not to use NANDECC */
-
-       void *genericDevice;    /* Pointer to device context
-                                * On an mtd this holds the mtd pointer.
-                                */
-        void *superBlock;
-
-       /* NAND access functions (Must be set before calling YAFFS)*/
-
-       int (*writeChunkToNAND) (struct yaffs_DeviceStruct * dev,
-                                int chunkInNAND, const __u8 * data,
-                                const yaffs_Spare * spare);
-       int (*readChunkFromNAND) (struct yaffs_DeviceStruct * dev,
-                                 int chunkInNAND, __u8 * data,
-                                 yaffs_Spare * spare);
-       int (*eraseBlockInNAND) (struct yaffs_DeviceStruct * dev,
-                                int blockInNAND);
-       int (*initialiseNAND) (struct yaffs_DeviceStruct * dev);
-
-#ifdef CONFIG_YAFFS_YAFFS2
-       int (*writeChunkWithTagsToNAND) (struct yaffs_DeviceStruct * dev,
-                                        int chunkInNAND, const __u8 * data,
-                                        const yaffs_ExtendedTags * tags);
-       int (*readChunkWithTagsFromNAND) (struct yaffs_DeviceStruct * dev,
-                                         int chunkInNAND, __u8 * data,
-                                         yaffs_ExtendedTags * tags);
-       int (*markNANDBlockBad) (struct yaffs_DeviceStruct * dev, int blockNo);
-       int (*queryNANDBlock) (struct yaffs_DeviceStruct * dev, int blockNo,
-                              yaffs_BlockState * state, int *sequenceNumber);
-#endif
-
-       int isYaffs2;
-
-       /* The removeObjectCallback function must be supplied by OS flavours that
-        * need it. The Linux kernel does not use this, but yaffs direct does use
-        * it to implement the faster readdir
-        */
-       void (*removeObjectCallback)(struct yaffs_ObjectStruct *obj);
-
-       /* Callback to mark the superblock dirsty */
-       void (*markSuperBlockDirty)(void * superblock);
-
-       int wideTnodesDisabled; /* Set to disable wide tnodes */
-
-
-       /* End of stuff that must be set before initialisation. */
-
-       /* Checkpoint control. Can be set before or after initialisation */
-       __u8 skipCheckpointRead;
-       __u8 skipCheckpointWrite;
-
-       /* Runtime parameters. Set up by YAFFS. */
-
-       __u16 chunkGroupBits;   /* 0 for devices <= 32MB. else log2(nchunks) - 16 */
-       __u16 chunkGroupSize;   /* == 2^^chunkGroupBits */
-
-       /* Stuff to support wide tnodes */
-       __u32 tnodeWidth;
-       __u32 tnodeMask;
-
-       /* Stuff to support various file offses to chunk/offset translations */
-       /* "Crumbs" for nDataBytesPerChunk not being a power of 2 */
-       __u32 crumbMask;
-       __u32 crumbShift;
-       __u32 crumbsPerChunk;
-
-       /* Straight shifting for nDataBytesPerChunk being a power of 2 */
-       __u32 chunkShift;
-       __u32 chunkMask;
-
-
-#ifdef __KERNEL__
-
-       struct semaphore sem;   /* Semaphore for waiting on erasure.*/
-       struct semaphore grossLock;     /* Gross locking semaphore */
-       __u8 *spareBuffer;      /* For mtdif2 use. Don't know the size of the buffer
-                                * at compile time so we have to allocate it.
-                                */
-       void (*putSuperFunc) (struct super_block * sb);
-#endif
-
-       int isMounted;
-
-       int isCheckpointed;
-
-
-       /* Stuff to support block offsetting to support start block zero */
-       int internalStartBlock;
-       int internalEndBlock;
-       int blockOffset;
-       int chunkOffset;
-
-
-       /* Runtime checkpointing stuff */
-       int checkpointPageSequence;   /* running sequence number of checkpoint pages */
-       int checkpointByteCount;
-       int checkpointByteOffset;
-       __u8 *checkpointBuffer;
-       int checkpointOpenForWrite;
-       int blocksInCheckpoint;
-       int checkpointCurrentChunk;
-       int checkpointCurrentBlock;
-       int checkpointNextBlock;
-       int *checkpointBlockList;
-       int checkpointMaxBlocks;
-       __u32 checkpointSum;
-       __u32 checkpointXor;
-
-       /* Block Info */
-       yaffs_BlockInfo *blockInfo;
-       __u8 *chunkBits;        /* bitmap of chunks in use */
-       unsigned blockInfoAlt:1;        /* was allocated using alternative strategy */
-       unsigned chunkBitsAlt:1;        /* was allocated using alternative strategy */
-       int chunkBitmapStride;  /* Number of bytes of chunkBits per block.
-                                * Must be consistent with nChunksPerBlock.
-                                */
-
-       int nErasedBlocks;
-       int allocationBlock;    /* Current block being allocated off */
-       __u32 allocationPage;
-       int allocationBlockFinder;      /* Used to search for next allocation block */
-
-       /* Runtime state */
-       int nTnodesCreated;
-       yaffs_Tnode *freeTnodes;
-       int nFreeTnodes;
-       yaffs_TnodeList *allocatedTnodeList;
-
-       int isDoingGC;
-
-       int nObjectsCreated;
-       yaffs_Object *freeObjects;
-       int nFreeObjects;
-
-       yaffs_ObjectList *allocatedObjectList;
-
-       yaffs_ObjectBucket objectBucket[YAFFS_NOBJECT_BUCKETS];
-
-       int nFreeChunks;
-
-       int currentDirtyChecker;        /* Used to find current dirtiest block */
-
-       __u32 *gcCleanupList;   /* objects to delete at the end of a GC. */
-       int nonAggressiveSkip;  /* GC state/mode */
-
-       /* Statistcs */
-       int nPageWrites;
-       int nPageReads;
-       int nBlockErasures;
-       int nErasureFailures;
-       int nGCCopies;
-       int garbageCollections;
-       int passiveGarbageCollections;
-       int nRetriedWrites;
-       int nRetiredBlocks;
-       int eccFixed;
-       int eccUnfixed;
-       int tagsEccFixed;
-       int tagsEccUnfixed;
-       int nDeletions;
-       int nUnmarkedDeletions;
-
-       int hasPendingPrioritisedGCs; /* We think this device might have pending prioritised gcs */
-
-       /* Special directories */
-       yaffs_Object *rootDir;
-       yaffs_Object *lostNFoundDir;
-
-       /* Buffer areas for storing data to recover from write failures TODO
-        *      __u8            bufferedData[YAFFS_CHUNKS_PER_BLOCK][YAFFS_BYTES_PER_CHUNK];
-        *      yaffs_Spare bufferedSpare[YAFFS_CHUNKS_PER_BLOCK];
-        */
-
-       int bufferedBlock;      /* Which block is buffered here? */
-       int doingBufferedBlockRewrite;
-
-       yaffs_ChunkCache *srCache;
-       int srLastUse;
-
-       int cacheHits;
-
-       /* Stuff for background deletion and unlinked files.*/
-       yaffs_Object *unlinkedDir;      /* Directory where unlinked and deleted files live. */
-       yaffs_Object *deletedDir;       /* Directory where deleted objects are sent to disappear. */
-       yaffs_Object *unlinkedDeletion; /* Current file being background deleted.*/
-       int nDeletedFiles;              /* Count of files awaiting deletion;*/
-       int nUnlinkedFiles;             /* Count of unlinked files. */
-       int nBackgroundDeletions;       /* Count of background deletions. */
-
-
-       yaffs_TempBuffer tempBuffer[YAFFS_N_TEMP_BUFFERS];
-       int maxTemp;
-       int unmanagedTempAllocations;
-       int unmanagedTempDeallocations;
-
-       /* yaffs2 runtime stuff */
-       unsigned sequenceNumber;        /* Sequence number of currently allocating block */
-       unsigned oldestDirtySequence;
-
-};
-
-typedef struct yaffs_DeviceStruct yaffs_Device;
-
-/* The static layout of bllock usage etc is stored in the super block header */
-typedef struct {
-        int StructType;
-       int version;
-       int checkpointStartBlock;
-       int checkpointEndBlock;
-       int startBlock;
-       int endBlock;
-       int rfu[100];
-} yaffs_SuperBlockHeader;
-
-/* The CheckpointDevice structure holds the device information that changes at runtime and
- * must be preserved over unmount/mount cycles.
- */
-typedef struct {
-        int structType;
-       int nErasedBlocks;
-       int allocationBlock;    /* Current block being allocated off */
-       __u32 allocationPage;
-       int nFreeChunks;
-
-       int nDeletedFiles;              /* Count of files awaiting deletion;*/
-       int nUnlinkedFiles;             /* Count of unlinked files. */
-       int nBackgroundDeletions;       /* Count of background deletions. */
-
-       /* yaffs2 runtime stuff */
-       unsigned sequenceNumber;        /* Sequence number of currently allocating block */
-       unsigned oldestDirtySequence;
-
-} yaffs_CheckpointDevice;
-
-
-typedef struct {
-    int structType;
-    __u32 magic;
-    __u32 version;
-    __u32 head;
-} yaffs_CheckpointValidity;
-
-/* Function to manipulate block info */
-static Y_INLINE yaffs_BlockInfo *yaffs_GetBlockInfo(yaffs_Device * dev, int blk)
-{
-       if (blk < dev->internalStartBlock || blk > dev->internalEndBlock) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR
-                  ("**>> yaffs: getBlockInfo block %d is not valid" TENDSTR),
-                  blk));
-               YBUG();
-       }
-       return &dev->blockInfo[blk - dev->internalStartBlock];
-}
-
-/*----------------------- YAFFS Functions -----------------------*/
-
-int yaffs_GutsInitialise(yaffs_Device * dev);
-void yaffs_Deinitialise(yaffs_Device * dev);
-
-int yaffs_GetNumberOfFreeChunks(yaffs_Device * dev);
-
-int yaffs_RenameObject(yaffs_Object * oldDir, const YCHAR * oldName,
-                      yaffs_Object * newDir, const YCHAR * newName);
-
-int yaffs_Unlink(yaffs_Object * dir, const YCHAR * name);
-int yaffs_DeleteFile(yaffs_Object * obj);
-
-int yaffs_GetObjectName(yaffs_Object * obj, YCHAR * name, int buffSize);
-int yaffs_GetObjectFileLength(yaffs_Object * obj);
-int yaffs_GetObjectInode(yaffs_Object * obj);
-unsigned yaffs_GetObjectType(yaffs_Object * obj);
-int yaffs_GetObjectLinkCount(yaffs_Object * obj);
-
-int yaffs_SetAttributes(yaffs_Object * obj, struct iattr *attr);
-int yaffs_GetAttributes(yaffs_Object * obj, struct iattr *attr);
-
-/* File operations */
-int yaffs_ReadDataFromFile(yaffs_Object * obj, __u8 * buffer, loff_t offset,
-                          int nBytes);
-int yaffs_WriteDataToFile(yaffs_Object * obj, const __u8 * buffer, loff_t offset,
-                         int nBytes, int writeThrough);
-int yaffs_ResizeFile(yaffs_Object * obj, loff_t newSize);
-
-yaffs_Object *yaffs_MknodFile(yaffs_Object * parent, const YCHAR * name,
-                             __u32 mode, __u32 uid, __u32 gid);
-int yaffs_FlushFile(yaffs_Object * obj, int updateTime);
-
-/* Flushing and checkpointing */
-void yaffs_FlushEntireDeviceCache(yaffs_Device *dev);
-
-int yaffs_CheckpointSave(yaffs_Device *dev);
-int yaffs_CheckpointRestore(yaffs_Device *dev);
-
-/* Directory operations */
-yaffs_Object *yaffs_MknodDirectory(yaffs_Object * parent, const YCHAR * name,
-                                  __u32 mode, __u32 uid, __u32 gid);
-yaffs_Object *yaffs_FindObjectByName(yaffs_Object * theDir, const YCHAR * name);
-int yaffs_ApplyToDirectoryChildren(yaffs_Object * theDir,
-                                  int (*fn) (yaffs_Object *));
-
-yaffs_Object *yaffs_FindObjectByNumber(yaffs_Device * dev, __u32 number);
-
-/* Link operations */
-yaffs_Object *yaffs_Link(yaffs_Object * parent, const YCHAR * name,
-                        yaffs_Object * equivalentObject);
-
-yaffs_Object *yaffs_GetEquivalentObject(yaffs_Object * obj);
-
-/* Symlink operations */
-yaffs_Object *yaffs_MknodSymLink(yaffs_Object * parent, const YCHAR * name,
-                                __u32 mode, __u32 uid, __u32 gid,
-                                const YCHAR * alias);
-YCHAR *yaffs_GetSymlinkAlias(yaffs_Object * obj);
-
-/* Special inodes (fifos, sockets and devices) */
-yaffs_Object *yaffs_MknodSpecial(yaffs_Object * parent, const YCHAR * name,
-                                __u32 mode, __u32 uid, __u32 gid, __u32 rdev);
-
-/* Special directories */
-yaffs_Object *yaffs_Root(yaffs_Device * dev);
-yaffs_Object *yaffs_LostNFound(yaffs_Device * dev);
-
-#ifdef CONFIG_YAFFS_WINCE
-/* CONFIG_YAFFS_WINCE special stuff */
-void yfsd_WinFileTimeNow(__u32 target[2]);
-#endif
-
-#ifdef __KERNEL__
-
-void yaffs_HandleDeferedFree(yaffs_Object * obj);
-#endif
-
-/* Debug dump  */
-int yaffs_DumpObject(yaffs_Object * obj);
-
-void yaffs_GutsTest(yaffs_Device * dev);
-
-/* A few useful functions */
-void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
-void yaffs_DeleteChunk(yaffs_Device * dev, int chunkId, int markNAND, int lyn);
-int yaffs_CheckFF(__u8 * buffer, int nBytes);
-void yaffs_HandleChunkError(yaffs_Device *dev, yaffs_BlockInfo *bi);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.c
deleted file mode 100644 (file)
index 466e5a4..0000000
+++ /dev/null
@@ -1,241 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-const char *yaffs_mtdif_c_version =
-    "$Id: yaffs_mtdif.c,v 1.19 2007-02-14 01:09:06 wookey Exp $";
-
-#include "yportenv.h"
-
-
-#include "yaffs_mtdif.h"
-
-#include "linux/mtd/mtd.h"
-#include "linux/types.h"
-#include "linux/time.h"
-#include "linux/mtd/nand.h"
-
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
-static struct nand_oobinfo yaffs_oobinfo = {
-       .useecc = 1,
-       .eccbytes = 6,
-       .eccpos = {8, 9, 10, 13, 14, 15}
-};
-
-static struct nand_oobinfo yaffs_noeccinfo = {
-       .useecc = 0,
-};
-#endif
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-static inline void translate_spare2oob(const yaffs_Spare *spare, __u8 *oob)
-{
-       oob[0] = spare->tagByte0;
-       oob[1] = spare->tagByte1;
-       oob[2] = spare->tagByte2;
-       oob[3] = spare->tagByte3;
-       oob[4] = spare->tagByte4;
-       oob[5] = spare->tagByte5 & 0x3f;
-       oob[5] |= spare->blockStatus == 'Y' ? 0: 0x80;
-       oob[5] |= spare->pageStatus == 0 ? 0: 0x40;
-       oob[6] = spare->tagByte6;
-       oob[7] = spare->tagByte7;
-}
-
-static inline void translate_oob2spare(yaffs_Spare *spare, __u8 *oob)
-{
-       struct yaffs_NANDSpare *nspare = (struct yaffs_NANDSpare *)spare;
-       spare->tagByte0 = oob[0];
-       spare->tagByte1 = oob[1];
-       spare->tagByte2 = oob[2];
-       spare->tagByte3 = oob[3];
-       spare->tagByte4 = oob[4];
-       spare->tagByte5 = oob[5] == 0xff ? 0xff : oob[5] & 0x3f;
-       spare->blockStatus = oob[5] & 0x80 ? 0xff : 'Y';
-       spare->pageStatus = oob[5] & 0x40 ? 0xff : 0;
-       spare->ecc1[0] = spare->ecc1[1] = spare->ecc1[2] = 0xff;
-       spare->tagByte6 = oob[6];
-       spare->tagByte7 = oob[7];
-       spare->ecc2[0] = spare->ecc2[1] = spare->ecc2[2] = 0xff;
-
-       nspare->eccres1 = nspare->eccres2 = 0; /* FIXME */
-}
-#endif
-
-int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
-                            const __u8 * data, const yaffs_Spare * spare)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       struct mtd_oob_ops ops;
-#endif
-       size_t dummy;
-       int retval = 0;
-
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       __u8 spareAsBytes[8]; /* OOB */
-
-       if (data && !spare)
-               retval = mtd->write(mtd, addr, dev->nDataBytesPerChunk,
-                               &dummy, data);
-       else if (spare) {
-               if (dev->useNANDECC) {
-                       translate_spare2oob(spare, spareAsBytes);
-                       ops.mode = MTD_OOB_AUTO;
-                       ops.ooblen = 8; /* temp hack */
-               } else {
-                       ops.mode = MTD_OOB_RAW;
-                       ops.ooblen = YAFFS_BYTES_PER_SPARE;
-               }
-               ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
-               ops.datbuf = (u8 *)data;
-               ops.ooboffs = 0;
-               ops.oobbuf = spareAsBytes;
-               retval = mtd->write_oob(mtd, addr, &ops);
-       }
-#else
-       __u8 *spareAsBytes = (__u8 *) spare;
-
-       if (data && spare) {
-               if (dev->useNANDECC)
-                       retval =
-                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                          &dummy, data, spareAsBytes,
-                                          &yaffs_oobinfo);
-               else
-                       retval =
-                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                          &dummy, data, spareAsBytes,
-                                          &yaffs_noeccinfo);
-       } else {
-               if (data)
-                       retval =
-                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
-                                      data);
-               if (spare)
-                       retval =
-                           mtd->write_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
-                                          &dummy, spareAsBytes);
-       }
-#endif
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
-int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
-                             yaffs_Spare * spare)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       struct mtd_oob_ops ops;
-#endif
-       size_t dummy;
-       int retval = 0;
-
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       __u8 spareAsBytes[8]; /* OOB */
-
-       if (data && !spare)
-               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
-                               &dummy, data);
-       else if (spare) {
-               if (dev->useNANDECC) {
-                       ops.mode = MTD_OOB_AUTO;
-                       ops.ooblen = 8; /* temp hack */
-               } else {
-                       ops.mode = MTD_OOB_RAW;
-                       ops.ooblen = YAFFS_BYTES_PER_SPARE;
-               }
-               ops.len = data ? dev->nDataBytesPerChunk : ops.ooblen;
-               ops.datbuf = data;
-               ops.ooboffs = 0;
-               ops.oobbuf = spareAsBytes;
-               retval = mtd->read_oob(mtd, addr, &ops);
-               if (dev->useNANDECC)
-                       translate_oob2spare(spare, spareAsBytes);
-       }
-#else
-       __u8 *spareAsBytes = (__u8 *) spare;
-
-       if (data && spare) {
-               if (dev->useNANDECC) {
-                       /* Careful, this call adds 2 ints */
-                       /* to the end of the spare data.  Calling function */
-                       /* should allocate enough memory for spare, */
-                       /* i.e. [YAFFS_BYTES_PER_SPARE+2*sizeof(int)]. */
-                       retval =
-                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                         &dummy, data, spareAsBytes,
-                                         &yaffs_oobinfo);
-               } else {
-                       retval =
-                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                         &dummy, data, spareAsBytes,
-                                         &yaffs_noeccinfo);
-               }
-       } else {
-               if (data)
-                       retval =
-                           mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
-                                     data);
-               if (spare)
-                       retval =
-                           mtd->read_oob(mtd, addr, YAFFS_BYTES_PER_SPARE,
-                                         &dummy, spareAsBytes);
-       }
-#endif
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
-int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-       __u32 addr =
-           ((loff_t) blockNumber) * dev->nDataBytesPerChunk
-               * dev->nChunksPerBlock;
-       struct erase_info ei;
-       int retval = 0;
-
-       ei.mtd = mtd;
-       ei.addr = addr;
-       ei.len = dev->nDataBytesPerChunk * dev->nChunksPerBlock;
-       ei.time = 1000;
-       ei.retries = 2;
-       ei.callback = NULL;
-       ei.priv = (u_long) dev;
-
-       /* Todo finish off the ei if required */
-
-       sema_init(&dev->sem, 0);
-
-       retval = mtd->erase(mtd, &ei);
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
-int nandmtd_InitialiseNAND(yaffs_Device * dev)
-{
-       return YAFFS_OK;
-}
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif.h
deleted file mode 100644 (file)
index 317600c..0000000
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_MTDIF_H__
-#define __YAFFS_MTDIF_H__
-
-#include "yaffs_guts.h"
-
-int nandmtd_WriteChunkToNAND(yaffs_Device * dev, int chunkInNAND,
-                            const __u8 * data, const yaffs_Spare * spare);
-int nandmtd_ReadChunkFromNAND(yaffs_Device * dev, int chunkInNAND, __u8 * data,
-                             yaffs_Spare * spare);
-int nandmtd_EraseBlockInNAND(yaffs_Device * dev, int blockNumber);
-int nandmtd_InitialiseNAND(yaffs_Device * dev);
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1-compat.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1-compat.c
deleted file mode 100644 (file)
index 6a376f1..0000000
+++ /dev/null
@@ -1,434 +0,0 @@
-From ian@brightstareng.com Fri May 18 15:06:49 2007
-From ian@brightstareng.com Fri May 18 15:08:21 2007
-Received: from 206.173.66.57.ptr.us.xo.net ([206.173.66.57] helo=zebra.brightstareng.com)
-       by apollo.linkchoose.co.uk with esmtp (Exim 4.60)
-       (envelope-from <ian@brightstareng.com>)
-       id 1Hp380-00011e-T6
-       for david.goodenough@linkchoose.co.uk; Fri, 18 May 2007 15:08:21 +0100
-Received: from localhost (localhost.localdomain [127.0.0.1])
-       by zebra.brightstareng.com (Postfix) with ESMTP
-       id 4819F28C004; Fri, 18 May 2007 10:07:49 -0400 (EDT)
-Received: from zebra.brightstareng.com ([127.0.0.1])
- by localhost (zebra [127.0.0.1]) (amavisd-new, port 10024) with ESMTP
- id 05328-06; Fri, 18 May 2007 10:07:16 -0400 (EDT)
-Received: from pippin (unknown [192.168.1.25])
-       by zebra.brightstareng.com (Postfix) with ESMTP
-       id 8BEF528C1BC; Fri, 18 May 2007 10:06:53 -0400 (EDT)
-From: Ian McDonnell <ian@brightstareng.com>
-To: David Goodenough <david.goodenough@linkchoose.co.uk>
-Subject: Re: something tested this time -- yaffs_mtdif1-compat.c
-Date: Fri, 18 May 2007 10:06:49 -0400
-User-Agent: KMail/1.9.1
-References: <200705142207.06909.ian@brightstareng.com> <200705171131.53536.ian@brightstareng.com> <200705181334.32166.david.goodenough@linkchoose.co.uk>
-In-Reply-To: <200705181334.32166.david.goodenough@linkchoose.co.uk>
-Cc: Andrea Conti <alyf@alyf.net>,
- Charles Manning <manningc2@actrix.gen.nz>
-MIME-Version: 1.0
-Content-Type: Multipart/Mixed;
-  boundary="Boundary-00=_5LbTGmt62YoutxM"
-Message-Id: <200705181006.49860.ian@brightstareng.com>
-X-Virus-Scanned: by amavisd-new at brightstareng.com
-Status: R
-X-Status: NT
-X-KMail-EncryptionState:
-X-KMail-SignatureState:
-X-KMail-MDN-Sent:
-
---Boundary-00=_5LbTGmt62YoutxM
-Content-Type: text/plain;
-  charset="iso-8859-15"
-Content-Transfer-Encoding: 7bit
-Content-Disposition: inline
-
-David, Andrea,
-
-On Friday 18 May 2007 08:34, you wrote:
-> Yea team.  With this fix in place (I put it in the wrong place
-> at first) I can now mount and ls the Yaffs partition without
-> an error messages!
-
-Good news!
-
-Attached is a newer yaffs_mtdif1.c with a bandaid to help the
-2.6.18 and 2.6.19 versions of MTD not trip on the oob read.
-See the LINUX_VERSION_CODE conditional in
-nandmtd1_ReadChunkWithTagsFromNAND.
-
--imcd
-
---Boundary-00=_5LbTGmt62YoutxM
-Content-Type: text/x-csrc;
-  charset="iso-8859-15";
-  name="yaffs_mtdif1.c"
-Content-Transfer-Encoding: 7bit
-Content-Disposition: attachment;
-       filename="yaffs_mtdif1.c"
-
-/*
- * YAFFS: Yet another FFS. A NAND-flash specific file system.
- * yaffs_mtdif1.c  NAND mtd interface functions for small-page NAND.
- *
- * Copyright (C) 2002 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/*
- * This module provides the interface between yaffs_nand.c and the
- * MTD API.  This version is used when the MTD interface supports the
- * 'mtd_oob_ops' style calls to read_oob and write_oob, circa 2.6.17,
- * and we have small-page NAND device.
- *
- * These functions are invoked via function pointers in yaffs_nand.c.
- * This replaces functionality provided by functions in yaffs_mtdif.c
- * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are
- * called in yaffs_mtdif.c when the function pointers are NULL.
- * We assume the MTD layer is performing ECC (useNANDECC is true).
- */
-
-#include "yportenv.h"
-#include "yaffs_guts.h"
-#include "yaffs_packedtags1.h"
-#include "yaffs_tagscompat.h"  // for yaffs_CalcTagsECC
-
-#include "linux/kernel.h"
-#include "linux/version.h"
-#include "linux/types.h"
-#include "linux/mtd/mtd.h"
-
-/* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-
-const char *yaffs_mtdif1_c_version = "$Id$";
-
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-# define YTAG1_SIZE 8
-#else
-# define YTAG1_SIZE 9
-#endif
-
-#if 0
-/* Use the following nand_ecclayout with MTD when using
- * CONFIG_YAFFS_9BYTE_TAGS and the older on-NAND tags layout.
- * If you have existing Yaffs images and the byte order differs from this,
- * adjust 'oobfree' to match your existing Yaffs data.
- *
- * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the
- * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to
- * the 9th byte.
- *
- * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5
- * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P
- * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus
- * byte and B is the small-page bad-block indicator byte.
- */
-static struct nand_ecclayout nand_oob_16 = {
-       .eccbytes = 6,
-       .eccpos = { 8, 9, 10, 13, 14, 15 },
-       .oobavail = 9,
-       .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } }
-};
-#endif
-
-/* Write a chunk (page) of data to NAND.
- *
- * Caller always provides ExtendedTags data which are converted to a more
- * compact (packed) form for storage in NAND.  A mini-ECC runs over the
- * contents of the tags meta-data; used to valid the tags when read.
- *
- *  - Pack ExtendedTags to PackedTags1 form
- *  - Compute mini-ECC for PackedTags1
- *  - Write data and packed tags to NAND.
- *
- * Note: Due to the use of the PackedTags1 meta-data which does not include
- * a full sequence number (as found in the larger PackedTags2 form) it is
- * necessary for Yaffs to re-write a chunk/page (just once) to mark it as
- * discarded and dirty.  This is not ideal: newer NAND parts are supposed
- * to be written just once.  When Yaffs performs this operation, this
- * function is called with a NULL data pointer -- calling MTD write_oob
- * without data is valid usage (2.6.17).
- *
- * Any underlying MTD error results in YAFFS_FAIL.
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
-       int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkBytes = dev->nDataBytesPerChunk;
-       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
-       struct mtd_oob_ops ops;
-       yaffs_PackedTags1 pt1;
-       int retval;
-
-       /* we assume that PackedTags1 and yaffs_Tags are compatible */
-       compile_time_assertion(sizeof(yaffs_PackedTags1) == 12);
-       compile_time_assertion(sizeof(yaffs_Tags) == 8);
-
-       yaffs_PackTags1(&pt1, etags);
-       yaffs_CalcTagsECC((yaffs_Tags *)&pt1);
-
-       /* When deleting a chunk, the upper layer provides only skeletal
-        * etags, one with chunkDeleted set.  However, we need to update the
-        * tags, not erase them completely.  So we use the NAND write property
-        * that only zeroed-bits stick and set tag bytes to all-ones and
-        * zero just the (not) deleted bit.
-        */
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-       if (etags->chunkDeleted) {
-               memset(&pt1, 0xff, 8);
-               /* clear delete status bit to indicate deleted */
-               pt1.deleted = 0;
-       }
-#else
-       ((__u8 *)&pt1)[8] = 0xff;
-       if (etags->chunkDeleted) {
-               memset(&pt1, 0xff, 8);
-               /* zero pageStatus byte to indicate deleted */
-               ((__u8 *)&pt1)[8] = 0;
-       }
-#endif
-
-       memset(&ops, 0, sizeof(ops));
-       ops.mode = MTD_OOB_AUTO;
-       ops.len = (data) ? chunkBytes : 0;
-       ops.ooblen = YTAG1_SIZE;
-       ops.datbuf = (__u8 *)data;
-       ops.oobbuf = (__u8 *)&pt1;
-
-       retval = mtd->write_oob(mtd, addr, &ops);
-       if (retval) {
-               yaffs_trace(YAFFS_TRACE_MTD,
-                       "write_oob failed, chunk %d, mtd error %d\n",
-                       chunkInNAND, retval);
-       }
-       return retval ? YAFFS_FAIL : YAFFS_OK;
-}
-
-/* Return with empty ExtendedTags but add eccResult.
- */
-static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
-{
-       if (etags) {
-               memset(etags, 0, sizeof(*etags));
-               etags->eccResult = eccResult;
-       }
-       return retval;
-}
-
-/* Read a chunk (page) from NAND.
- *
- * Caller expects ExtendedTags data to be usable even on error; that is,
- * all members except eccResult and blockBad are zeroed.
- *
- *  - Check ECC results for data (if applicable)
- *  - Check for blank/erased block (return empty ExtendedTags if blank)
- *  - Check the PackedTags1 mini-ECC (correct if necessary/possible)
- *  - Convert PackedTags1 to ExtendedTags
- *  - Update eccResult and blockBad members to refect state.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
-       int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkBytes = dev->nDataBytesPerChunk;
-       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
-       int eccres = YAFFS_ECC_RESULT_NO_ERROR;
-       struct mtd_oob_ops ops;
-       yaffs_PackedTags1 pt1;
-       int retval;
-       int deleted;
-
-       memset(&ops, 0, sizeof(ops));
-       ops.mode = MTD_OOB_AUTO;
-       ops.len = (data) ? chunkBytes : 0;
-       ops.ooblen = YTAG1_SIZE;
-       ops.datbuf = data;
-       ops.oobbuf = (__u8 *)&pt1;
-
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
-       /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
-        * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
-        */
-       ops.len = (ops.datbuf) ? ops.len : ops.ooblen;
-#endif
-       /* Read page and oob using MTD.
-        * Check status and determine ECC result.
-        */
-       retval = mtd->read_oob(mtd, addr, &ops);
-       if (retval) {
-               yaffs_trace(YAFFS_TRACE_MTD,
-                       "read_oob failed, chunk %d, mtd error %d\n",
-                       chunkInNAND, retval);
-       }
-
-       switch (retval) {
-       case 0:
-               /* no error */
-               break;
-
-       case -EUCLEAN:
-               /* MTD's ECC fixed the data */
-               eccres = YAFFS_ECC_RESULT_FIXED;
-               dev->eccFixed++;
-               break;
-
-       case -EBADMSG:
-               /* MTD's ECC could not fix the data */
-               dev->eccUnfixed++;
-               /* fall into... */
-       default:
-               rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
-               etags->blockBad = (mtd->block_isbad)(mtd, addr);
-               return YAFFS_FAIL;
-       }
-
-       /* Check for a blank/erased chunk.
-        */
-       if (yaffs_CheckFF((__u8 *)&pt1, 8)) {
-               /* when blank, upper layers want eccResult to be <= NO_ERROR */
-               return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
-       }
-
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-       /* Read deleted status (bit) then return it to it's non-deleted
-        * state before performing tags mini-ECC check. pt1.deleted is
-        * inverted.
-        */
-       deleted = !pt1.deleted;
-       pt1.deleted = 1;
-#else
-       (void) deleted; /* not used */
-#endif
-
-       /* Check the packed tags mini-ECC and correct if necessary/possible.
-        */
-       retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1);
-       switch (retval) {
-       case 0:
-               /* no tags error, use MTD result */
-               break;
-       case 1:
-               /* recovered tags-ECC error */
-               dev->tagsEccFixed++;
-               eccres = YAFFS_ECC_RESULT_FIXED;
-               break;
-       default:
-               /* unrecovered tags-ECC error */
-               dev->tagsEccUnfixed++;
-               return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL);
-       }
-
-       /* Unpack the tags to extended form and set ECC result.
-        * [set shouldBeFF just to keep yaffs_UnpackTags1 happy]
-        */
-       pt1.shouldBeFF = 0xFFFFFFFF;
-       yaffs_UnpackTags1(etags, &pt1);
-       etags->eccResult = eccres;
-
-       /* Set deleted state.
-        */
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-       etags->chunkDeleted = deleted;
-#else
-       etags->chunkDeleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7);
-#endif
-       return YAFFS_OK;
-}
-
-/* Mark a block bad.
- *
- * This is a persistant state.
- * Use of this function should be rare.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
-       int retval;
-
-       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
-
-       retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
-       return (retval) ? YAFFS_FAIL : YAFFS_OK;
-}
-
-/* Check any MTD prerequists.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
-{
-       /* 2.6.18 has mtd->ecclayout->oobavail */
-       /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
-       int oobavail = mtd->ecclayout->oobavail;
-
-       if (oobavail < YTAG1_SIZE) {
-               yaffs_trace(YAFFS_TRACE_ERROR,
-                       "mtd device has only %d bytes for tags, need %d",
-                       oobavail, YTAG1_SIZE);
-               return YAFFS_FAIL;
-       }
-       return YAFFS_OK;
-}
-
-/* Query for the current state of a specific block.
- *
- * Examine the tags of the first chunk of the block and return the state:
- *  - YAFFS_BLOCK_STATE_DEAD, the block is marked bad
- *  - YAFFS_BLOCK_STATE_NEEDS_SCANNING, the block is in use
- *  - YAFFS_BLOCK_STATE_EMPTY, the block is clean
- *
- * Always returns YAFFS_OK.
- */
-int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-       yaffs_BlockState * pState, int *pSequenceNumber)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkNo = blockNo * dev->nChunksPerBlock;
-       yaffs_ExtendedTags etags;
-       int state = YAFFS_BLOCK_STATE_DEAD;
-       int seqnum = 0;
-       int retval;
-
-       /* We don't yet have a good place to test for MTD config prerequists.
-        * Do it here as we are called during the initial scan.
-        */
-       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
-               return YAFFS_FAIL;
-       }
-
-       retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
-       if (etags.blockBad) {
-               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
-                       "block %d is marked bad", blockNo);
-               state = YAFFS_BLOCK_STATE_DEAD;
-       }
-       else if (etags.chunkUsed) {
-               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
-               seqnum = etags.sequenceNumber;
-       }
-       else {
-               state = YAFFS_BLOCK_STATE_EMPTY;
-       }
-
-       *pState = state;
-       *pSequenceNumber = seqnum;
-
-       /* query always succeeds */
-       return YAFFS_OK;
-}
-
-#endif /*KERNEL_VERSION*/
-
---Boundary-00=_5LbTGmt62YoutxM--
-
-
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.c
deleted file mode 100644 (file)
index 36d5ade..0000000
+++ /dev/null
@@ -1,363 +0,0 @@
-/*
- * YAFFS: Yet another FFS. A NAND-flash specific file system.
- * yaffs_mtdif1.c  NAND mtd interface functions for small-page NAND.
- *
- * Copyright (C) 2002 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/*
- * This module provides the interface between yaffs_nand.c and the
- * MTD API.  This version is used when the MTD interface supports the
- * 'mtd_oob_ops' style calls to read_oob and write_oob, circa 2.6.17,
- * and we have small-page NAND device.
- *
- * These functions are invoked via function pointers in yaffs_nand.c.
- * This replaces functionality provided by functions in yaffs_mtdif.c
- * and the yaffs_TagsCompatability functions in yaffs_tagscompat.c that are
- * called in yaffs_mtdif.c when the function pointers are NULL.
- * We assume the MTD layer is performing ECC (useNANDECC is true).
- */
-
-#include "yportenv.h"
-#include "yaffs_guts.h"
-#include "yaffs_packedtags1.h"
-#include "yaffs_tagscompat.h"  // for yaffs_CalcTagsECC
-
-#include "linux/kernel.h"
-#include "linux/version.h"
-#include "linux/types.h"
-#include "linux/mtd/mtd.h"
-
-/* Don't compile this module if we don't have MTD's mtd_oob_ops interface */
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-
-const char *yaffs_mtdif1_c_version = "$Id: yaffs_mtdif1.c,v 1.3 2007/05/15 20:16:11 ian Exp $";
-
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-# define YTAG1_SIZE 8
-#else
-# define YTAG1_SIZE 9
-#endif
-
-#if 0
-/* Use the following nand_ecclayout with MTD when using
- * CONFIG_YAFFS_9BYTE_TAGS and the older on-NAND tags layout.
- * If you have existing Yaffs images and the byte order differs from this,
- * adjust 'oobfree' to match your existing Yaffs data.
- *
- * This nand_ecclayout scatters/gathers to/from the old-yaffs layout with the
- * pageStatus byte (at NAND spare offset 4) scattered/gathered from/to
- * the 9th byte.
- *
- * Old-style on-NAND format: T0,T1,T2,T3,P,B,T4,T5,E0,E1,E2,T6,T7,E3,E4,E5
- * We have/need PackedTags1 plus pageStatus: T0,T1,T2,T3,T4,T5,T6,T7,P
- * where Tn are the tag bytes, En are MTD's ECC bytes, P is the pageStatus
- * byte and B is the small-page bad-block indicator byte.
- */
-static struct nand_ecclayout nand_oob_16 = {
-       .eccbytes = 6,
-       .eccpos = { 8, 9, 10, 13, 14, 15 },
-       .oobavail = 9,
-       .oobfree = { { 0, 4 }, { 6, 2 }, { 11, 2 }, { 4, 1 } }
-};
-#endif
-
-/* Write a chunk (page) of data to NAND.
- *
- * Caller always provides ExtendedTags data which are converted to a more
- * compact (packed) form for storage in NAND.  A mini-ECC runs over the
- * contents of the tags meta-data; used to valid the tags when read.
- *
- *  - Pack ExtendedTags to PackedTags1 form
- *  - Compute mini-ECC for PackedTags1
- *  - Write data and packed tags to NAND.
- *
- * Note: Due to the use of the PackedTags1 meta-data which does not include
- * a full sequence number (as found in the larger PackedTags2 form) it is
- * necessary for Yaffs to re-write a chunk/page (just once) to mark it as
- * discarded and dirty.  This is not ideal: newer NAND parts are supposed
- * to be written just once.  When Yaffs performs this operation, this
- * function is called with a NULL data pointer -- calling MTD write_oob
- * without data is valid usage (2.6.17).
- *
- * Any underlying MTD error results in YAFFS_FAIL.
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device *dev,
-       int chunkInNAND, const __u8 * data, const yaffs_ExtendedTags * etags)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkBytes = dev->nDataBytesPerChunk;
-       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
-       struct mtd_oob_ops ops;
-       yaffs_PackedTags1 pt1;
-       int retval;
-
-       /* we assume that PackedTags1 and yaffs_Tags are compatible */
-       compile_time_assertion(sizeof(yaffs_PackedTags1) == 12);
-       compile_time_assertion(sizeof(yaffs_Tags) == 8);
-
-       dev->nPageWrites++;
-
-       yaffs_PackTags1(&pt1, etags);
-       yaffs_CalcTagsECC((yaffs_Tags *)&pt1);
-
-       /* When deleting a chunk, the upper layer provides only skeletal
-        * etags, one with chunkDeleted set.  However, we need to update the
-        * tags, not erase them completely.  So we use the NAND write property
-        * that only zeroed-bits stick and set tag bytes to all-ones and
-        * zero just the (not) deleted bit.
-        */
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-       if (etags->chunkDeleted) {
-               memset(&pt1, 0xff, 8);
-               /* clear delete status bit to indicate deleted */
-               pt1.deleted = 0;
-       }
-#else
-       ((__u8 *)&pt1)[8] = 0xff;
-       if (etags->chunkDeleted) {
-               memset(&pt1, 0xff, 8);
-               /* zero pageStatus byte to indicate deleted */
-               ((__u8 *)&pt1)[8] = 0;
-       }
-#endif
-
-       memset(&ops, 0, sizeof(ops));
-       ops.mode = MTD_OOB_AUTO;
-       ops.len = (data) ? chunkBytes : 0;
-       ops.ooblen = YTAG1_SIZE;
-       ops.datbuf = (__u8 *)data;
-       ops.oobbuf = (__u8 *)&pt1;
-
-       retval = mtd->write_oob(mtd, addr, &ops);
-       if (retval) {
-               yaffs_trace(YAFFS_TRACE_MTD,
-                       "write_oob failed, chunk %d, mtd error %d\n",
-                       chunkInNAND, retval);
-       }
-       return retval ? YAFFS_FAIL : YAFFS_OK;
-}
-
-/* Return with empty ExtendedTags but add eccResult.
- */
-static int rettags(yaffs_ExtendedTags * etags, int eccResult, int retval)
-{
-       if (etags) {
-               memset(etags, 0, sizeof(*etags));
-               etags->eccResult = eccResult;
-       }
-       return retval;
-}
-
-/* Read a chunk (page) from NAND.
- *
- * Caller expects ExtendedTags data to be usable even on error; that is,
- * all members except eccResult and blockBad are zeroed.
- *
- *  - Check ECC results for data (if applicable)
- *  - Check for blank/erased block (return empty ExtendedTags if blank)
- *  - Check the PackedTags1 mini-ECC (correct if necessary/possible)
- *  - Convert PackedTags1 to ExtendedTags
- *  - Update eccResult and blockBad members to refect state.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device *dev,
-       int chunkInNAND, __u8 * data, yaffs_ExtendedTags * etags)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkBytes = dev->nDataBytesPerChunk;
-       loff_t addr = ((loff_t)chunkInNAND) * chunkBytes;
-       int eccres = YAFFS_ECC_RESULT_NO_ERROR;
-       struct mtd_oob_ops ops;
-       yaffs_PackedTags1 pt1;
-       int retval;
-       int deleted;
-
-       dev->nPageReads++;
-
-       memset(&ops, 0, sizeof(ops));
-       ops.mode = MTD_OOB_AUTO;
-       ops.len = (data) ? chunkBytes : 0;
-       ops.ooblen = YTAG1_SIZE;
-       ops.datbuf = data;
-       ops.oobbuf = (__u8 *)&pt1;
-
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20))
-       /* In MTD 2.6.18 to 2.6.19 nand_base.c:nand_do_read_oob() has a bug;
-        * help it out with ops.len = ops.ooblen when ops.datbuf == NULL.
-        */
-       ops.len = (ops.datbuf) ? ops.len : ops.ooblen;
-#endif
-       /* Read page and oob using MTD.
-        * Check status and determine ECC result.
-        */
-       retval = mtd->read_oob(mtd, addr, &ops);
-       if (retval) {
-               yaffs_trace(YAFFS_TRACE_MTD,
-                       "read_oob failed, chunk %d, mtd error %d\n",
-                       chunkInNAND, retval);
-       }
-
-       switch (retval) {
-       case 0:
-               /* no error */
-               break;
-
-       case -EUCLEAN:
-               /* MTD's ECC fixed the data */
-               eccres = YAFFS_ECC_RESULT_FIXED;
-               dev->eccFixed++;
-               break;
-
-       case -EBADMSG:
-               /* MTD's ECC could not fix the data */
-               dev->eccUnfixed++;
-               /* fall into... */
-       default:
-               rettags(etags, YAFFS_ECC_RESULT_UNFIXED, 0);
-               etags->blockBad = (mtd->block_isbad)(mtd, addr);
-               return YAFFS_FAIL;
-       }
-
-       /* Check for a blank/erased chunk.
-        */
-       if (yaffs_CheckFF((__u8 *)&pt1, 8)) {
-               /* when blank, upper layers want eccResult to be <= NO_ERROR */
-               return rettags(etags, YAFFS_ECC_RESULT_NO_ERROR, YAFFS_OK);
-       }
-
-#ifndef CONFIG_YAFFS_9BYTE_TAGS
-       /* Read deleted status (bit) then return it to it's non-deleted
-        * state before performing tags mini-ECC check. pt1.deleted is
-        * inverted.
-        */
-       deleted = !pt1.deleted;
-       pt1.deleted = 1;
-#else
-       deleted = (yaffs_CountBits(((__u8 *)&pt1)[8]) < 7);
-#endif
-
-       /* Check the packed tags mini-ECC and correct if necessary/possible.
-        */
-       retval = yaffs_CheckECCOnTags((yaffs_Tags *)&pt1);
-       switch (retval) {
-       case 0:
-               /* no tags error, use MTD result */
-               break;
-       case 1:
-               /* recovered tags-ECC error */
-               dev->tagsEccFixed++;
-               if (eccres == YAFFS_ECC_RESULT_NO_ERROR)
-                       eccres = YAFFS_ECC_RESULT_FIXED;
-               break;
-       default:
-               /* unrecovered tags-ECC error */
-               dev->tagsEccUnfixed++;
-               return rettags(etags, YAFFS_ECC_RESULT_UNFIXED, YAFFS_FAIL);
-       }
-
-       /* Unpack the tags to extended form and set ECC result.
-        * [set shouldBeFF just to keep yaffs_UnpackTags1 happy]
-        */
-       pt1.shouldBeFF = 0xFFFFFFFF;
-       yaffs_UnpackTags1(etags, &pt1);
-       etags->eccResult = eccres;
-
-       /* Set deleted state */
-       etags->chunkDeleted = deleted;
-       return YAFFS_OK;
-}
-
-/* Mark a block bad.
- *
- * This is a persistant state.
- * Use of this function should be rare.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int blocksize = dev->nChunksPerBlock * dev->nDataBytesPerChunk;
-       int retval;
-
-       yaffs_trace(YAFFS_TRACE_BAD_BLOCKS, "marking block %d bad", blockNo);
-
-       retval = mtd->block_markbad(mtd, (loff_t)blocksize * blockNo);
-       return (retval) ? YAFFS_FAIL : YAFFS_OK;
-}
-
-/* Check any MTD prerequists.
- *
- * Returns YAFFS_OK or YAFFS_FAIL.
- */
-static int nandmtd1_TestPrerequists(struct mtd_info * mtd)
-{
-       /* 2.6.18 has mtd->ecclayout->oobavail */
-       /* 2.6.21 has mtd->ecclayout->oobavail and mtd->oobavail */
-       int oobavail = mtd->ecclayout->oobavail;
-
-       if (oobavail < YTAG1_SIZE) {
-               yaffs_trace(YAFFS_TRACE_ERROR,
-                       "mtd device has only %d bytes for tags, need %d\n",
-                       oobavail, YTAG1_SIZE);
-               return YAFFS_FAIL;
-       }
-       return YAFFS_OK;
-}
-
-/* Query for the current state of a specific block.
- *
- * Examine the tags of the first chunk of the block and return the state:
- *  - YAFFS_BLOCK_STATE_DEAD, the block is marked bad
- *  - YAFFS_BLOCK_STATE_NEEDS_SCANNING, the block is in use
- *  - YAFFS_BLOCK_STATE_EMPTY, the block is clean
- *
- * Always returns YAFFS_OK.
- */
-int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-       yaffs_BlockState * pState, int *pSequenceNumber)
-{
-       struct mtd_info * mtd = dev->genericDevice;
-       int chunkNo = blockNo * dev->nChunksPerBlock;
-       yaffs_ExtendedTags etags;
-       int state = YAFFS_BLOCK_STATE_DEAD;
-       int seqnum = 0;
-       int retval;
-
-       /* We don't yet have a good place to test for MTD config prerequists.
-        * Do it here as we are called during the initial scan.
-        */
-       if (nandmtd1_TestPrerequists(mtd) != YAFFS_OK) {
-               return YAFFS_FAIL;
-       }
-
-       retval = nandmtd1_ReadChunkWithTagsFromNAND(dev, chunkNo, NULL, &etags);
-       if (etags.blockBad) {
-               yaffs_trace(YAFFS_TRACE_BAD_BLOCKS,
-                       "block %d is marked bad", blockNo);
-               state = YAFFS_BLOCK_STATE_DEAD;
-       }
-       else if (etags.chunkUsed) {
-               state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
-               seqnum = etags.sequenceNumber;
-       }
-       else {
-               state = YAFFS_BLOCK_STATE_EMPTY;
-       }
-
-       *pState = state;
-       *pSequenceNumber = seqnum;
-
-       /* query always succeeds */
-       return YAFFS_OK;
-}
-
-#endif /*KERNEL_VERSION*/
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif1.h
deleted file mode 100644 (file)
index c4f6197..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_MTDIF1_H__
-#define __YAFFS_MTDIF1_H__
-
-int nandmtd1_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
-       const __u8 * data, const yaffs_ExtendedTags * tags);
-
-int nandmtd1_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-       __u8 * data, yaffs_ExtendedTags * tags);
-
-int nandmtd1_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
-
-int nandmtd1_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-       yaffs_BlockState * state, int *sequenceNumber);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.c
deleted file mode 100644 (file)
index cdad073..0000000
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-/* mtd interface for YAFFS2 */
-
-const char *yaffs_mtdif2_c_version =
-    "$Id: yaffs_mtdif2.c,v 1.17 2007-02-14 01:09:06 wookey Exp $";
-
-#include "yportenv.h"
-
-
-#include "yaffs_mtdif2.h"
-
-#include "linux/mtd/mtd.h"
-#include "linux/types.h"
-#include "linux/time.h"
-
-#include "yaffs_packedtags2.h"
-
-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
-                                     const __u8 * data,
-                                     const yaffs_ExtendedTags * tags)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       struct mtd_oob_ops ops;
-#else
-       size_t dummy;
-#endif
-       int retval = 0;
-
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
-
-       yaffs_PackedTags2 pt;
-
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_WriteChunkWithTagsToNAND chunk %d data %p tags %p"
-           TENDSTR), chunkInNAND, data, tags));
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       if (tags)
-               yaffs_PackTags2(&pt, tags);
-       else
-               BUG(); /* both tags and data should always be present */
-
-       if (data) {
-               ops.mode = MTD_OOB_AUTO;
-               ops.ooblen = sizeof(pt);
-               ops.len = dev->nDataBytesPerChunk;
-               ops.ooboffs = 0;
-               ops.datbuf = (__u8 *)data;
-               ops.oobbuf = (void *)&pt;
-               retval = mtd->write_oob(mtd, addr, &ops);
-       } else
-               BUG(); /* both tags and data should always be present */
-#else
-       if (tags) {
-               yaffs_PackTags2(&pt, tags);
-       }
-
-       if (data && tags) {
-               if (dev->useNANDECC)
-                       retval =
-                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                          &dummy, data, (__u8 *) & pt, NULL);
-               else
-                       retval =
-                           mtd->write_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                          &dummy, data, (__u8 *) & pt, NULL);
-       } else {
-               if (data)
-                       retval =
-                           mtd->write(mtd, addr, dev->nDataBytesPerChunk, &dummy,
-                                      data);
-               if (tags)
-                       retval =
-                           mtd->write_oob(mtd, addr, mtd->oobsize, &dummy,
-                                          (__u8 *) & pt);
-
-       }
-#endif
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-                                      __u8 * data, yaffs_ExtendedTags * tags)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       struct mtd_oob_ops ops;
-#endif
-       size_t dummy;
-       int retval = 0;
-
-       loff_t addr = ((loff_t) chunkInNAND) * dev->nDataBytesPerChunk;
-
-       yaffs_PackedTags2 pt;
-
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("nandmtd2_ReadChunkWithTagsFromNAND chunk %d data %p tags %p"
-           TENDSTR), chunkInNAND, data, tags));
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,17))
-       if (data && !tags)
-               retval = mtd->read(mtd, addr, dev->nDataBytesPerChunk,
-                               &dummy, data);
-       else if (tags) {
-               ops.mode = MTD_OOB_AUTO;
-               ops.ooblen = sizeof(pt);
-               ops.len = data ? dev->nDataBytesPerChunk : sizeof(pt);
-               ops.ooboffs = 0;
-               ops.datbuf = data;
-               ops.oobbuf = dev->spareBuffer;
-               retval = mtd->read_oob(mtd, addr, &ops);
-       }
-#else
-       if (data && tags) {
-               if (dev->useNANDECC) {
-                       retval =
-                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                         &dummy, data, dev->spareBuffer,
-                                         NULL);
-               } else {
-                       retval =
-                           mtd->read_ecc(mtd, addr, dev->nDataBytesPerChunk,
-                                         &dummy, data, dev->spareBuffer,
-                                         NULL);
-               }
-       } else {
-               if (data)
-                       retval =
-                           mtd->read(mtd, addr, dev->nDataBytesPerChunk, &dummy,
-                                     data);
-               if (tags)
-                       retval =
-                           mtd->read_oob(mtd, addr, mtd->oobsize, &dummy,
-                                         dev->spareBuffer);
-       }
-#endif
-
-       memcpy(&pt, dev->spareBuffer, sizeof(pt));
-
-       if (tags)
-               yaffs_UnpackTags2(tags, &pt);
-
-       if(tags && retval == -EBADMSG && tags->eccResult == YAFFS_ECC_RESULT_NO_ERROR)
-               tags->eccResult = YAFFS_ECC_RESULT_UNFIXED;
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
-int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-       int retval;
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_MarkNANDBlockBad %d" TENDSTR), blockNo));
-
-       retval =
-           mtd->block_markbad(mtd,
-                              blockNo * dev->nChunksPerBlock *
-                              dev->nDataBytesPerChunk);
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-
-}
-
-int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-                           yaffs_BlockState * state, int *sequenceNumber)
-{
-       struct mtd_info *mtd = (struct mtd_info *)(dev->genericDevice);
-       int retval;
-
-       T(YAFFS_TRACE_MTD,
-         (TSTR("nandmtd2_QueryNANDBlock %d" TENDSTR), blockNo));
-       retval =
-           mtd->block_isbad(mtd,
-                            blockNo * dev->nChunksPerBlock *
-                            dev->nDataBytesPerChunk);
-
-       if (retval) {
-               T(YAFFS_TRACE_MTD, (TSTR("block is bad" TENDSTR)));
-
-               *state = YAFFS_BLOCK_STATE_DEAD;
-               *sequenceNumber = 0;
-       } else {
-               yaffs_ExtendedTags t;
-               nandmtd2_ReadChunkWithTagsFromNAND(dev,
-                                                  blockNo *
-                                                  dev->nChunksPerBlock, NULL,
-                                                  &t);
-
-               if (t.chunkUsed) {
-                       *sequenceNumber = t.sequenceNumber;
-                       *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
-               } else {
-                       *sequenceNumber = 0;
-                       *state = YAFFS_BLOCK_STATE_EMPTY;
-               }
-       }
-       T(YAFFS_TRACE_MTD,
-         (TSTR("block is bad seq %d state %d" TENDSTR), *sequenceNumber,
-          *state));
-
-       if (retval == 0)
-               return YAFFS_OK;
-       else
-               return YAFFS_FAIL;
-}
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_mtdif2.h
deleted file mode 100644 (file)
index b67ba52..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_MTDIF2_H__
-#define __YAFFS_MTDIF2_H__
-
-#include "yaffs_guts.h"
-int nandmtd2_WriteChunkWithTagsToNAND(yaffs_Device * dev, int chunkInNAND,
-                                     const __u8 * data,
-                                     const yaffs_ExtendedTags * tags);
-int nandmtd2_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-                                      __u8 * data, yaffs_ExtendedTags * tags);
-int nandmtd2_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
-int nandmtd2_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-                           yaffs_BlockState * state, int *sequenceNumber);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.c
deleted file mode 100644 (file)
index 4e25033..0000000
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-const char *yaffs_nand_c_version =
-    "$Id: yaffs_nand.c,v 1.7 2007-02-14 01:09:06 wookey Exp $";
-
-#include "yaffs_nand.h"
-#include "yaffs_tagscompat.h"
-#include "yaffs_tagsvalidity.h"
-
-
-int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-                                          __u8 * buffer,
-                                          yaffs_ExtendedTags * tags)
-{
-       int result;
-       yaffs_ExtendedTags localTags;
-
-       int realignedChunkInNAND = chunkInNAND - dev->chunkOffset;
-
-       /* If there are no tags provided, use local tags to get prioritised gc working */
-       if(!tags)
-               tags = &localTags;
-
-       if (dev->readChunkWithTagsFromNAND)
-               result = dev->readChunkWithTagsFromNAND(dev, realignedChunkInNAND, buffer,
-                                                     tags);
-       else
-               result = yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(dev,
-                                                                       realignedChunkInNAND,
-                                                                       buffer,
-                                                                       tags);
-       if(tags &&
-          tags->eccResult > YAFFS_ECC_RESULT_NO_ERROR){
-
-               yaffs_BlockInfo *bi = yaffs_GetBlockInfo(dev, chunkInNAND/dev->nChunksPerBlock);
-                yaffs_HandleChunkError(dev,bi);
-       }
-
-       return result;
-}
-
-int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
-                                                  int chunkInNAND,
-                                                  const __u8 * buffer,
-                                                  yaffs_ExtendedTags * tags)
-{
-       chunkInNAND -= dev->chunkOffset;
-
-
-       if (tags) {
-               tags->sequenceNumber = dev->sequenceNumber;
-               tags->chunkUsed = 1;
-               if (!yaffs_ValidateTags(tags)) {
-                       T(YAFFS_TRACE_ERROR,
-                         (TSTR("Writing uninitialised tags" TENDSTR)));
-                       YBUG();
-               }
-               T(YAFFS_TRACE_WRITE,
-                 (TSTR("Writing chunk %d tags %d %d" TENDSTR), chunkInNAND,
-                  tags->objectId, tags->chunkId));
-       } else {
-               T(YAFFS_TRACE_ERROR, (TSTR("Writing with no tags" TENDSTR)));
-               YBUG();
-       }
-
-       if (dev->writeChunkWithTagsToNAND)
-               return dev->writeChunkWithTagsToNAND(dev, chunkInNAND, buffer,
-                                                    tags);
-       else
-               return yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(dev,
-                                                                      chunkInNAND,
-                                                                      buffer,
-                                                                      tags);
-}
-
-int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo)
-{
-       blockNo -= dev->blockOffset;
-
-;
-       if (dev->markNANDBlockBad)
-               return dev->markNANDBlockBad(dev, blockNo);
-       else
-               return yaffs_TagsCompatabilityMarkNANDBlockBad(dev, blockNo);
-}
-
-int yaffs_QueryInitialBlockState(yaffs_Device * dev,
-                                                int blockNo,
-                                                yaffs_BlockState * state,
-                                                unsigned *sequenceNumber)
-{
-       blockNo -= dev->blockOffset;
-
-       if (dev->queryNANDBlock)
-               return dev->queryNANDBlock(dev, blockNo, state, sequenceNumber);
-       else
-               return yaffs_TagsCompatabilityQueryNANDBlock(dev, blockNo,
-                                                            state,
-                                                            sequenceNumber);
-}
-
-
-int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
-                                 int blockInNAND)
-{
-       int result;
-
-       blockInNAND -= dev->blockOffset;
-
-
-       dev->nBlockErasures++;
-       result = dev->eraseBlockInNAND(dev, blockInNAND);
-
-       return result;
-}
-
-int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev)
-{
-       return dev->initialiseNAND(dev);
-}
-
-
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nand.h
deleted file mode 100644 (file)
index 5fa334b..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_NAND_H__
-#define __YAFFS_NAND_H__
-#include "yaffs_guts.h"
-
-
-
-int yaffs_ReadChunkWithTagsFromNAND(yaffs_Device * dev, int chunkInNAND,
-                                          __u8 * buffer,
-                                          yaffs_ExtendedTags * tags);
-
-int yaffs_WriteChunkWithTagsToNAND(yaffs_Device * dev,
-                                                  int chunkInNAND,
-                                                  const __u8 * buffer,
-                                                  yaffs_ExtendedTags * tags);
-
-int yaffs_MarkBlockBad(yaffs_Device * dev, int blockNo);
-
-int yaffs_QueryInitialBlockState(yaffs_Device * dev,
-                                                int blockNo,
-                                                yaffs_BlockState * state,
-                                                unsigned *sequenceNumber);
-
-int yaffs_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
-                                 int blockInNAND);
-
-int yaffs_InitialiseNAND(struct yaffs_DeviceStruct *dev);
-
-#endif
-
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nandemul2k.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_nandemul2k.h
deleted file mode 100644 (file)
index cd2e96f..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-/* Interface to emulated NAND functions (2k page size) */
-
-#ifndef __YAFFS_NANDEMUL2K_H__
-#define __YAFFS_NANDEMUL2K_H__
-
-#include "yaffs_guts.h"
-
-int nandemul2k_WriteChunkWithTagsToNAND(struct yaffs_DeviceStruct *dev,
-                                       int chunkInNAND, const __u8 * data,
-                                       yaffs_ExtendedTags * tags);
-int nandemul2k_ReadChunkWithTagsFromNAND(struct yaffs_DeviceStruct *dev,
-                                        int chunkInNAND, __u8 * data,
-                                        yaffs_ExtendedTags * tags);
-int nandemul2k_MarkNANDBlockBad(struct yaffs_DeviceStruct *dev, int blockNo);
-int nandemul2k_QueryNANDBlock(struct yaffs_DeviceStruct *dev, int blockNo,
-                             yaffs_BlockState * state, int *sequenceNumber);
-int nandemul2k_EraseBlockInNAND(struct yaffs_DeviceStruct *dev,
-                               int blockInNAND);
-int nandemul2k_InitialiseNAND(struct yaffs_DeviceStruct *dev);
-int nandemul2k_GetBytesPerChunk(void);
-int nandemul2k_GetChunksPerBlock(void);
-int nandemul2k_GetNumberOfBlocks(void);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.c
deleted file mode 100644 (file)
index f480bf1..0000000
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include "yaffs_packedtags1.h"
-#include "yportenv.h"
-
-void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t)
-{
-       pt->chunkId = t->chunkId;
-       pt->serialNumber = t->serialNumber;
-       pt->byteCount = t->byteCount;
-       pt->objectId = t->objectId;
-       pt->ecc = 0;
-       pt->deleted = (t->chunkDeleted) ? 0 : 1;
-       pt->unusedStuff = 0;
-       pt->shouldBeFF = 0xFFFFFFFF;
-
-}
-
-void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt)
-{
-       static const __u8 allFF[] =
-           { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-0xff };
-
-       if (memcmp(allFF, pt, sizeof(yaffs_PackedTags1))) {
-               t->blockBad = 0;
-               if (pt->shouldBeFF != 0xFFFFFFFF) {
-                       t->blockBad = 1;
-               }
-               t->chunkUsed = 1;
-               t->objectId = pt->objectId;
-               t->chunkId = pt->chunkId;
-               t->byteCount = pt->byteCount;
-               t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-               t->chunkDeleted = (pt->deleted) ? 0 : 1;
-               t->serialNumber = pt->serialNumber;
-       } else {
-               memset(t, 0, sizeof(yaffs_ExtendedTags));
-
-       }
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags1.h
deleted file mode 100644 (file)
index 776c5c2..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-/* This is used to pack YAFFS1 tags, not YAFFS2 tags. */
-
-#ifndef __YAFFS_PACKEDTAGS1_H__
-#define __YAFFS_PACKEDTAGS1_H__
-
-#include "yaffs_guts.h"
-
-typedef struct {
-       unsigned chunkId:20;
-       unsigned serialNumber:2;
-       unsigned byteCount:10;
-       unsigned objectId:18;
-       unsigned ecc:12;
-       unsigned deleted:1;
-       unsigned unusedStuff:1;
-       unsigned shouldBeFF;
-
-} yaffs_PackedTags1;
-
-void yaffs_PackTags1(yaffs_PackedTags1 * pt, const yaffs_ExtendedTags * t);
-void yaffs_UnpackTags1(yaffs_ExtendedTags * t, const yaffs_PackedTags1 * pt);
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.c
deleted file mode 100644 (file)
index e420f95..0000000
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include "yaffs_packedtags2.h"
-#include "yportenv.h"
-#include "yaffs_tagsvalidity.h"
-
-/* This code packs a set of extended tags into a binary structure for
- * NAND storage
- */
-
-/* Some of the information is "extra" struff which can be packed in to
- * speed scanning
- * This is defined by having the EXTRA_HEADER_INFO_FLAG set.
- */
-
-/* Extra flags applied to chunkId */
-
-#define EXTRA_HEADER_INFO_FLAG 0x80000000
-#define EXTRA_SHRINK_FLAG      0x40000000
-#define EXTRA_SHADOWS_FLAG     0x20000000
-#define EXTRA_SPARE_FLAGS      0x10000000
-
-#define ALL_EXTRA_FLAGS                0xF0000000
-
-/* Also, the top 4 bits of the object Id are set to the object type. */
-#define EXTRA_OBJECT_TYPE_SHIFT (28)
-#define EXTRA_OBJECT_TYPE_MASK  ((0x0F) << EXTRA_OBJECT_TYPE_SHIFT)
-
-static void yaffs_DumpPackedTags2(const yaffs_PackedTags2 * pt)
-{
-       T(YAFFS_TRACE_MTD,
-         (TSTR("packed tags obj %d chunk %d byte %d seq %d" TENDSTR),
-          pt->t.objectId, pt->t.chunkId, pt->t.byteCount,
-          pt->t.sequenceNumber));
-}
-
-static void yaffs_DumpTags2(const yaffs_ExtendedTags * t)
-{
-       T(YAFFS_TRACE_MTD,
-         (TSTR
-          ("ext.tags eccres %d blkbad %d chused %d obj %d chunk%d byte "
-           "%d del %d ser %d seq %d"
-           TENDSTR), t->eccResult, t->blockBad, t->chunkUsed, t->objectId,
-          t->chunkId, t->byteCount, t->chunkDeleted, t->serialNumber,
-          t->sequenceNumber));
-
-}
-
-void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t)
-{
-       pt->t.chunkId = t->chunkId;
-       pt->t.sequenceNumber = t->sequenceNumber;
-       pt->t.byteCount = t->byteCount;
-       pt->t.objectId = t->objectId;
-
-       if (t->chunkId == 0 && t->extraHeaderInfoAvailable) {
-               /* Store the extra header info instead */
-               /* We save the parent object in the chunkId */
-               pt->t.chunkId = EXTRA_HEADER_INFO_FLAG
-                       | t->extraParentObjectId;
-               if (t->extraIsShrinkHeader) {
-                       pt->t.chunkId |= EXTRA_SHRINK_FLAG;
-               }
-               if (t->extraShadows) {
-                       pt->t.chunkId |= EXTRA_SHADOWS_FLAG;
-               }
-
-               pt->t.objectId &= ~EXTRA_OBJECT_TYPE_MASK;
-               pt->t.objectId |=
-                   (t->extraObjectType << EXTRA_OBJECT_TYPE_SHIFT);
-
-               if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
-                       pt->t.byteCount = t->extraEquivalentObjectId;
-               } else if (t->extraObjectType == YAFFS_OBJECT_TYPE_FILE) {
-                       pt->t.byteCount = t->extraFileLength;
-               } else {
-                       pt->t.byteCount = 0;
-               }
-       }
-
-       yaffs_DumpPackedTags2(pt);
-       yaffs_DumpTags2(t);
-
-#ifndef YAFFS_IGNORE_TAGS_ECC
-       {
-               yaffs_ECCCalculateOther((unsigned char *)&pt->t,
-                                       sizeof(yaffs_PackedTags2TagsPart),
-                                       &pt->ecc);
-       }
-#endif
-}
-
-void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt)
-{
-
-       memset(t, 0, sizeof(yaffs_ExtendedTags));
-
-       yaffs_InitialiseTags(t);
-
-       if (pt->t.sequenceNumber != 0xFFFFFFFF) {
-               /* Page is in use */
-#ifdef YAFFS_IGNORE_TAGS_ECC
-               {
-                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-               }
-#else
-               {
-                       yaffs_ECCOther ecc;
-                       int result;
-                       yaffs_ECCCalculateOther((unsigned char *)&pt->t,
-                                               sizeof
-                                               (yaffs_PackedTags2TagsPart),
-                                               &ecc);
-                       result =
-                           yaffs_ECCCorrectOther((unsigned char *)&pt->t,
-                                                 sizeof
-                                                 (yaffs_PackedTags2TagsPart),
-                                                 &pt->ecc, &ecc);
-                       switch(result){
-                               case 0:
-                                       t->eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-                                       break;
-                               case 1:
-                                       t->eccResult = YAFFS_ECC_RESULT_FIXED;
-                                       break;
-                               case -1:
-                                       t->eccResult = YAFFS_ECC_RESULT_UNFIXED;
-                                       break;
-                               default:
-                                       t->eccResult = YAFFS_ECC_RESULT_UNKNOWN;
-                       }
-               }
-#endif
-               t->blockBad = 0;
-               t->chunkUsed = 1;
-               t->objectId = pt->t.objectId;
-               t->chunkId = pt->t.chunkId;
-               t->byteCount = pt->t.byteCount;
-               t->chunkDeleted = 0;
-               t->serialNumber = 0;
-               t->sequenceNumber = pt->t.sequenceNumber;
-
-               /* Do extra header info stuff */
-
-               if (pt->t.chunkId & EXTRA_HEADER_INFO_FLAG) {
-                       t->chunkId = 0;
-                       t->byteCount = 0;
-
-                       t->extraHeaderInfoAvailable = 1;
-                       t->extraParentObjectId =
-                           pt->t.chunkId & (~(ALL_EXTRA_FLAGS));
-                       t->extraIsShrinkHeader =
-                           (pt->t.chunkId & EXTRA_SHRINK_FLAG) ? 1 : 0;
-                       t->extraShadows =
-                           (pt->t.chunkId & EXTRA_SHADOWS_FLAG) ? 1 : 0;
-                       t->extraObjectType =
-                           pt->t.objectId >> EXTRA_OBJECT_TYPE_SHIFT;
-                       t->objectId &= ~EXTRA_OBJECT_TYPE_MASK;
-
-                       if (t->extraObjectType == YAFFS_OBJECT_TYPE_HARDLINK) {
-                               t->extraEquivalentObjectId = pt->t.byteCount;
-                       } else {
-                               t->extraFileLength = pt->t.byteCount;
-                       }
-               }
-       }
-
-       yaffs_DumpPackedTags2(pt);
-       yaffs_DumpTags2(t);
-
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_packedtags2.h
deleted file mode 100644 (file)
index c2242ff..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-/* This is used to pack YAFFS2 tags, not YAFFS1tags. */
-
-#ifndef __YAFFS_PACKEDTAGS2_H__
-#define __YAFFS_PACKEDTAGS2_H__
-
-#include "yaffs_guts.h"
-#include "yaffs_ecc.h"
-
-typedef struct {
-       unsigned sequenceNumber;
-       unsigned objectId;
-       unsigned chunkId;
-       unsigned byteCount;
-} yaffs_PackedTags2TagsPart;
-
-typedef struct {
-       yaffs_PackedTags2TagsPart t;
-       yaffs_ECCOther ecc;
-} yaffs_PackedTags2;
-
-void yaffs_PackTags2(yaffs_PackedTags2 * pt, const yaffs_ExtendedTags * t);
-void yaffs_UnpackTags2(yaffs_ExtendedTags * t, yaffs_PackedTags2 * pt);
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.c
deleted file mode 100644 (file)
index 474be9c..0000000
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * Copyright (c) 1992, 1993
- *     The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#include "yportenv.h"
-//#include <linux/string.h>
-
-/*
- * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function".
- */
-#define swapcode(TYPE, parmi, parmj, n) {              \
-       long i = (n) / sizeof (TYPE);                   \
-       register TYPE *pi = (TYPE *) (parmi);           \
-       register TYPE *pj = (TYPE *) (parmj);           \
-       do {                                            \
-               register TYPE   t = *pi;                \
-               *pi++ = *pj;                            \
-               *pj++ = t;                              \
-        } while (--i > 0);                             \
-}
-
-#define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \
-       es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1;
-
-static __inline void
-swapfunc(char *a, char *b, int n, int swaptype)
-{
-       if (swaptype <= 1)
-               swapcode(long, a, b, n)
-       else
-               swapcode(char, a, b, n)
-}
-
-#define swap(a, b)                                     \
-       if (swaptype == 0) {                            \
-               long t = *(long *)(a);                  \
-               *(long *)(a) = *(long *)(b);            \
-               *(long *)(b) = t;                       \
-       } else                                          \
-               swapfunc(a, b, es, swaptype)
-
-#define vecswap(a, b, n)       if ((n) > 0) swapfunc(a, b, n, swaptype)
-
-static __inline char *
-med3(char *a, char *b, char *c, int (*cmp)(const void *, const void *))
-{
-       return cmp(a, b) < 0 ?
-              (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a ))
-              :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c ));
-}
-
-#ifndef min
-#define min(a,b) (((a) < (b)) ? (a) : (b))
-#endif
-
-void
-yaffs_qsort(void *aa, size_t n, size_t es,
-       int (*cmp)(const void *, const void *))
-{
-       char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
-       int d, r, swaptype, swap_cnt;
-       register char *a = aa;
-
-loop:  SWAPINIT(a, es);
-       swap_cnt = 0;
-       if (n < 7) {
-               for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es)
-                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
-                            pl -= es)
-                               swap(pl, pl - es);
-               return;
-       }
-       pm = (char *)a + (n / 2) * es;
-       if (n > 7) {
-               pl = (char *)a;
-               pn = (char *)a + (n - 1) * es;
-               if (n > 40) {
-                       d = (n / 8) * es;
-                       pl = med3(pl, pl + d, pl + 2 * d, cmp);
-                       pm = med3(pm - d, pm, pm + d, cmp);
-                       pn = med3(pn - 2 * d, pn - d, pn, cmp);
-               }
-               pm = med3(pl, pm, pn, cmp);
-       }
-       swap(a, pm);
-       pa = pb = (char *)a + es;
-
-       pc = pd = (char *)a + (n - 1) * es;
-       for (;;) {
-               while (pb <= pc && (r = cmp(pb, a)) <= 0) {
-                       if (r == 0) {
-                               swap_cnt = 1;
-                               swap(pa, pb);
-                               pa += es;
-                       }
-                       pb += es;
-               }
-               while (pb <= pc && (r = cmp(pc, a)) >= 0) {
-                       if (r == 0) {
-                               swap_cnt = 1;
-                               swap(pc, pd);
-                               pd -= es;
-                       }
-                       pc -= es;
-               }
-               if (pb > pc)
-                       break;
-               swap(pb, pc);
-               swap_cnt = 1;
-               pb += es;
-               pc -= es;
-       }
-       if (swap_cnt == 0) {  /* Switch to insertion sort */
-               for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
-                       for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0;
-                            pl -= es)
-                               swap(pl, pl - es);
-               return;
-       }
-
-       pn = (char *)a + n * es;
-       r = min(pa - (char *)a, pb - pa);
-       vecswap(a, pb - r, r);
-       r = min((long)(pd - pc), (long)(pn - pd - es));
-       vecswap(pb, pn - r, r);
-       if ((r = pb - pa) > es)
-               yaffs_qsort(a, r / es, es, cmp);
-       if ((r = pd - pc) > es) {
-               /* Iterate rather than recurse to save stack space */
-               a = pn - r;
-               n = r / es;
-               goto loop;
-       }
-/*             yaffs_qsort(pn - r, r / es, es, cmp);*/
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_qsort.h
deleted file mode 100644 (file)
index 610b7ec..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-
-#ifndef __YAFFS_QSORT_H__
-#define __YAFFS_QSORT_H__
-
-extern void yaffs_qsort (void *const base, size_t total_elems, size_t size,
-                   int (*cmp)(const void *, const void *));
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.c
deleted file mode 100644 (file)
index 7622b1a..0000000
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include "yaffs_guts.h"
-#include "yaffs_tagscompat.h"
-#include "yaffs_ecc.h"
-
-static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND);
-#ifdef NOTYET
-static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND);
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_Spare * spare);
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_Spare * spare);
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND);
-#endif
-
-static const char yaffs_countBitsTable[256] = {
-       0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
-       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-       1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-       2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
-       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-       3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
-       4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
-};
-
-int yaffs_CountBits(__u8 x)
-{
-       int retVal;
-       retVal = yaffs_countBitsTable[x];
-       return retVal;
-}
-
-/********** Tags ECC calculations  *********/
-
-void yaffs_CalcECC(const __u8 * data, yaffs_Spare * spare)
-{
-       yaffs_ECCCalculate(data, spare->ecc1);
-       yaffs_ECCCalculate(&data[256], spare->ecc2);
-}
-
-void yaffs_CalcTagsECC(yaffs_Tags * tags)
-{
-       /* Calculate an ecc */
-
-       unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
-       unsigned i, j;
-       unsigned ecc = 0;
-       unsigned bit = 0;
-
-       tags->ecc = 0;
-
-       for (i = 0; i < 8; i++) {
-               for (j = 1; j & 0xff; j <<= 1) {
-                       bit++;
-                       if (b[i] & j) {
-                               ecc ^= bit;
-                       }
-               }
-       }
-
-       tags->ecc = ecc;
-
-}
-
-int yaffs_CheckECCOnTags(yaffs_Tags * tags)
-{
-       unsigned ecc = tags->ecc;
-
-       yaffs_CalcTagsECC(tags);
-
-       ecc ^= tags->ecc;
-
-       if (ecc && ecc <= 64) {
-               /* TODO: Handle the failure better. Retire? */
-               unsigned char *b = ((yaffs_TagsUnion *) tags)->asBytes;
-
-               ecc--;
-
-               b[ecc / 8] ^= (1 << (ecc & 7));
-
-               /* Now recvalc the ecc */
-               yaffs_CalcTagsECC(tags);
-
-               return 1;       /* recovered error */
-       } else if (ecc) {
-               /* Wierd ecc failure value */
-               /* TODO Need to do somethiong here */
-               return -1;      /* unrecovered error */
-       }
-
-       return 0;
-}
-
-/********** Tags **********/
-
-static void yaffs_LoadTagsIntoSpare(yaffs_Spare * sparePtr,
-                                   yaffs_Tags * tagsPtr)
-{
-       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
-
-       yaffs_CalcTagsECC(tagsPtr);
-
-       sparePtr->tagByte0 = tu->asBytes[0];
-       sparePtr->tagByte1 = tu->asBytes[1];
-       sparePtr->tagByte2 = tu->asBytes[2];
-       sparePtr->tagByte3 = tu->asBytes[3];
-       sparePtr->tagByte4 = tu->asBytes[4];
-       sparePtr->tagByte5 = tu->asBytes[5];
-       sparePtr->tagByte6 = tu->asBytes[6];
-       sparePtr->tagByte7 = tu->asBytes[7];
-}
-
-static void yaffs_GetTagsFromSpare(yaffs_Device * dev, yaffs_Spare * sparePtr,
-                                  yaffs_Tags * tagsPtr)
-{
-       yaffs_TagsUnion *tu = (yaffs_TagsUnion *) tagsPtr;
-       int result;
-
-       tu->asBytes[0] = sparePtr->tagByte0;
-       tu->asBytes[1] = sparePtr->tagByte1;
-       tu->asBytes[2] = sparePtr->tagByte2;
-       tu->asBytes[3] = sparePtr->tagByte3;
-       tu->asBytes[4] = sparePtr->tagByte4;
-       tu->asBytes[5] = sparePtr->tagByte5;
-       tu->asBytes[6] = sparePtr->tagByte6;
-       tu->asBytes[7] = sparePtr->tagByte7;
-
-       result = yaffs_CheckECCOnTags(tagsPtr);
-       if (result > 0) {
-               dev->tagsEccFixed++;
-       } else if (result < 0) {
-               dev->tagsEccUnfixed++;
-       }
-}
-
-static void yaffs_SpareInitialise(yaffs_Spare * spare)
-{
-       memset(spare, 0xFF, sizeof(yaffs_Spare));
-}
-
-static int yaffs_WriteChunkToNAND(struct yaffs_DeviceStruct *dev,
-                                 int chunkInNAND, const __u8 * data,
-                                 yaffs_Spare * spare)
-{
-       if (chunkInNAND < dev->startBlock * dev->nChunksPerBlock) {
-               T(YAFFS_TRACE_ERROR,
-                 (TSTR("**>> yaffs chunk %d is not valid" TENDSTR),
-                  chunkInNAND));
-               return YAFFS_FAIL;
-       }
-
-       dev->nPageWrites++;
-       return dev->writeChunkToNAND(dev, chunkInNAND, data, spare);
-}
-
-static int yaffs_ReadChunkFromNAND(struct yaffs_DeviceStruct *dev,
-                                  int chunkInNAND,
-                                  __u8 * data,
-                                  yaffs_Spare * spare,
-                                  yaffs_ECCResult * eccResult,
-                                  int doErrorCorrection)
-{
-       int retVal;
-       yaffs_Spare localSpare;
-
-       dev->nPageReads++;
-
-       if (!spare && data) {
-               /* If we don't have a real spare, then we use a local one. */
-               /* Need this for the calculation of the ecc */
-               spare = &localSpare;
-       }
-
-       if (!dev->useNANDECC) {
-               retVal = dev->readChunkFromNAND(dev, chunkInNAND, data, spare);
-               if (data && doErrorCorrection) {
-                       /* Do ECC correction */
-                       /* Todo handle any errors */
-                       int eccResult1, eccResult2;
-                       __u8 calcEcc[3];
-
-                       yaffs_ECCCalculate(data, calcEcc);
-                       eccResult1 =
-                           yaffs_ECCCorrect(data, spare->ecc1, calcEcc);
-                       yaffs_ECCCalculate(&data[256], calcEcc);
-                       eccResult2 =
-                           yaffs_ECCCorrect(&data[256], spare->ecc2, calcEcc);
-
-                       if (eccResult1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:0"
-                                   TENDSTR), chunkInNAND));
-                               dev->eccFixed++;
-                       } else if (eccResult1 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error unfixed on chunk %d:0"
-                                   TENDSTR), chunkInNAND));
-                               dev->eccUnfixed++;
-                       }
-
-                       if (eccResult2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error fix performed on chunk %d:1"
-                                   TENDSTR), chunkInNAND));
-                               dev->eccFixed++;
-                       } else if (eccResult2 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>yaffs ecc error unfixed on chunk %d:1"
-                                   TENDSTR), chunkInNAND));
-                               dev->eccUnfixed++;
-                       }
-
-                       if (eccResult1 || eccResult2) {
-                               /* We had a data problem on this page */
-                               yaffs_HandleReadDataError(dev, chunkInNAND);
-                       }
-
-                       if (eccResult1 < 0 || eccResult2 < 0)
-                               *eccResult = YAFFS_ECC_RESULT_UNFIXED;
-                       else if (eccResult1 > 0 || eccResult2 > 0)
-                               *eccResult = YAFFS_ECC_RESULT_FIXED;
-                       else
-                               *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-               }
-       } else {
-               /* Must allocate enough memory for spare+2*sizeof(int) */
-               /* for ecc results from device. */
-               struct yaffs_NANDSpare nspare;
-               retVal =
-                   dev->readChunkFromNAND(dev, chunkInNAND, data,
-                                          (yaffs_Spare *) & nspare);
-               memcpy(spare, &nspare, sizeof(yaffs_Spare));
-               if (data && doErrorCorrection) {
-                       if (nspare.eccres1 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:0"
-                                   TENDSTR), chunkInNAND));
-                       } else if (nspare.eccres1 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:0"
-                                   TENDSTR), chunkInNAND));
-                       }
-
-                       if (nspare.eccres2 > 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error fix performed on chunk %d:1"
-                                   TENDSTR), chunkInNAND));
-                       } else if (nspare.eccres2 < 0) {
-                               T(YAFFS_TRACE_ERROR,
-                                 (TSTR
-                                  ("**>>mtd ecc error unfixed on chunk %d:1"
-                                   TENDSTR), chunkInNAND));
-                       }
-
-                       if (nspare.eccres1 || nspare.eccres2) {
-                               /* We had a data problem on this page */
-                               yaffs_HandleReadDataError(dev, chunkInNAND);
-                       }
-
-                       if (nspare.eccres1 < 0 || nspare.eccres2 < 0)
-                               *eccResult = YAFFS_ECC_RESULT_UNFIXED;
-                       else if (nspare.eccres1 > 0 || nspare.eccres2 > 0)
-                               *eccResult = YAFFS_ECC_RESULT_FIXED;
-                       else
-                               *eccResult = YAFFS_ECC_RESULT_NO_ERROR;
-
-               }
-       }
-       return retVal;
-}
-
-#ifdef NOTYET
-static int yaffs_CheckChunkErased(struct yaffs_DeviceStruct *dev,
-                                 int chunkInNAND)
-{
-
-       static int init = 0;
-       static __u8 cmpbuf[YAFFS_BYTES_PER_CHUNK];
-       static __u8 data[YAFFS_BYTES_PER_CHUNK];
-       /* Might as well always allocate the larger size for */
-       /* dev->useNANDECC == true; */
-       static __u8 spare[sizeof(struct yaffs_NANDSpare)];
-
-       dev->readChunkFromNAND(dev, chunkInNAND, data, (yaffs_Spare *) spare);
-
-       if (!init) {
-               memset(cmpbuf, 0xff, YAFFS_BYTES_PER_CHUNK);
-               init = 1;
-       }
-
-       if (memcmp(cmpbuf, data, YAFFS_BYTES_PER_CHUNK))
-               return YAFFS_FAIL;
-       if (memcmp(cmpbuf, spare, 16))
-               return YAFFS_FAIL;
-
-       return YAFFS_OK;
-
-}
-#endif
-
-/*
- * Functions for robustisizing
- */
-
-static void yaffs_HandleReadDataError(yaffs_Device * dev, int chunkInNAND)
-{
-       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
-
-       /* Mark the block for retirement */
-       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
-       T(YAFFS_TRACE_ERROR | YAFFS_TRACE_BAD_BLOCKS,
-         (TSTR("**>>Block %d marked for retirement" TENDSTR), blockInNAND));
-
-       /* TODO:
-        * Just do a garbage collection on the affected block
-        * then retire the block
-        * NB recursion
-        */
-}
-
-#ifdef NOTYET
-static void yaffs_CheckWrittenBlock(yaffs_Device * dev, int chunkInNAND)
-{
-}
-
-static void yaffs_HandleWriteChunkOk(yaffs_Device * dev, int chunkInNAND,
-                                    const __u8 * data,
-                                    const yaffs_Spare * spare)
-{
-}
-
-static void yaffs_HandleUpdateChunk(yaffs_Device * dev, int chunkInNAND,
-                                   const yaffs_Spare * spare)
-{
-}
-
-static void yaffs_HandleWriteChunkError(yaffs_Device * dev, int chunkInNAND)
-{
-       int blockInNAND = chunkInNAND / dev->nChunksPerBlock;
-
-       /* Mark the block for retirement */
-       yaffs_GetBlockInfo(dev, blockInNAND)->needsRetiring = 1;
-       /* Delete the chunk */
-       yaffs_DeleteChunk(dev, chunkInNAND, 1, __LINE__);
-}
-
-static int yaffs_VerifyCompare(const __u8 * d0, const __u8 * d1,
-                              const yaffs_Spare * s0, const yaffs_Spare * s1)
-{
-
-       if (memcmp(d0, d1, YAFFS_BYTES_PER_CHUNK) != 0 ||
-           s0->tagByte0 != s1->tagByte0 ||
-           s0->tagByte1 != s1->tagByte1 ||
-           s0->tagByte2 != s1->tagByte2 ||
-           s0->tagByte3 != s1->tagByte3 ||
-           s0->tagByte4 != s1->tagByte4 ||
-           s0->tagByte5 != s1->tagByte5 ||
-           s0->tagByte6 != s1->tagByte6 ||
-           s0->tagByte7 != s1->tagByte7 ||
-           s0->ecc1[0] != s1->ecc1[0] ||
-           s0->ecc1[1] != s1->ecc1[1] ||
-           s0->ecc1[2] != s1->ecc1[2] ||
-           s0->ecc2[0] != s1->ecc2[0] ||
-           s0->ecc2[1] != s1->ecc2[1] || s0->ecc2[2] != s1->ecc2[2]) {
-               return 0;
-       }
-
-       return 1;
-}
-#endif                         /* NOTYET */
-
-int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
-                                                   int chunkInNAND,
-                                                   const __u8 * data,
-                                                   const yaffs_ExtendedTags *
-                                                   eTags)
-{
-       yaffs_Spare spare;
-       yaffs_Tags tags;
-
-       yaffs_SpareInitialise(&spare);
-
-       if (eTags->chunkDeleted) {
-               spare.pageStatus = 0;
-       } else {
-               tags.objectId = eTags->objectId;
-               tags.chunkId = eTags->chunkId;
-               tags.byteCount = eTags->byteCount;
-               tags.serialNumber = eTags->serialNumber;
-
-               if (!dev->useNANDECC && data) {
-                       yaffs_CalcECC(data, &spare);
-               }
-               yaffs_LoadTagsIntoSpare(&spare, &tags);
-
-       }
-
-       return yaffs_WriteChunkToNAND(dev, chunkInNAND, data, &spare);
-}
-
-int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
-                                                    int chunkInNAND,
-                                                    __u8 * data,
-                                                    yaffs_ExtendedTags * eTags)
-{
-
-       yaffs_Spare spare;
-       yaffs_Tags tags;
-       yaffs_ECCResult eccResult;
-
-       static yaffs_Spare spareFF;
-       static int init;
-
-       if (!init) {
-               memset(&spareFF, 0xFF, sizeof(spareFF));
-               init = 1;
-       }
-
-       if (yaffs_ReadChunkFromNAND
-           (dev, chunkInNAND, data, &spare, &eccResult, 1)) {
-               /* eTags may be NULL */
-               if (eTags) {
-
-                       int deleted =
-                           (yaffs_CountBits(spare.pageStatus) < 7) ? 1 : 0;
-
-                       eTags->chunkDeleted = deleted;
-                       eTags->eccResult = eccResult;
-                       eTags->blockBad = 0;    /* We're reading it */
-                       /* therefore it is not a bad block */
-                       eTags->chunkUsed =
-                           (memcmp(&spareFF, &spare, sizeof(spareFF)) !=
-                            0) ? 1 : 0;
-
-                       if (eTags->chunkUsed) {
-                               yaffs_GetTagsFromSpare(dev, &spare, &tags);
-
-                               eTags->objectId = tags.objectId;
-                               eTags->chunkId = tags.chunkId;
-                               eTags->byteCount = tags.byteCount;
-                               eTags->serialNumber = tags.serialNumber;
-                       }
-               }
-
-               return YAFFS_OK;
-       } else {
-               return YAFFS_FAIL;
-       }
-}
-
-int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
-                                           int blockInNAND)
-{
-
-       yaffs_Spare spare;
-
-       memset(&spare, 0xff, sizeof(yaffs_Spare));
-
-       spare.blockStatus = 'Y';
-
-       yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock, NULL,
-                              &spare);
-       yaffs_WriteChunkToNAND(dev, blockInNAND * dev->nChunksPerBlock + 1,
-                              NULL, &spare);
-
-       return YAFFS_OK;
-
-}
-
-int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
-                                         int blockNo, yaffs_BlockState *
-                                         state,
-                                         int *sequenceNumber)
-{
-
-       yaffs_Spare spare0, spare1;
-       static yaffs_Spare spareFF;
-       static int init;
-       yaffs_ECCResult dummy;
-
-       if (!init) {
-               memset(&spareFF, 0xFF, sizeof(spareFF));
-               init = 1;
-       }
-
-       *sequenceNumber = 0;
-
-       yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock, NULL,
-                               &spare0, &dummy, 1);
-       yaffs_ReadChunkFromNAND(dev, blockNo * dev->nChunksPerBlock + 1, NULL,
-                               &spare1, &dummy, 1);
-
-       if (yaffs_CountBits(spare0.blockStatus & spare1.blockStatus) < 7)
-               *state = YAFFS_BLOCK_STATE_DEAD;
-       else if (memcmp(&spareFF, &spare0, sizeof(spareFF)) == 0)
-               *state = YAFFS_BLOCK_STATE_EMPTY;
-       else
-               *state = YAFFS_BLOCK_STATE_NEEDS_SCANNING;
-
-       return YAFFS_OK;
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagscompat.h
deleted file mode 100644 (file)
index a61e3ba..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFS_TAGSCOMPAT_H__
-#define __YAFFS_TAGSCOMPAT_H__
-
-#include "yaffs_guts.h"
-int yaffs_TagsCompatabilityWriteChunkWithTagsToNAND(yaffs_Device * dev,
-                                                   int chunkInNAND,
-                                                   const __u8 * data,
-                                                   const yaffs_ExtendedTags *
-                                                   tags);
-int yaffs_TagsCompatabilityReadChunkWithTagsFromNAND(yaffs_Device * dev,
-                                                    int chunkInNAND,
-                                                    __u8 * data,
-                                                    yaffs_ExtendedTags *
-                                                    tags);
-int yaffs_TagsCompatabilityMarkNANDBlockBad(struct yaffs_DeviceStruct *dev,
-                                           int blockNo);
-int yaffs_TagsCompatabilityQueryNANDBlock(struct yaffs_DeviceStruct *dev,
-                                         int blockNo, yaffs_BlockState *
-                                         state, int *sequenceNumber);
-
-void yaffs_CalcTagsECC(yaffs_Tags * tags);
-int yaffs_CheckECCOnTags(yaffs_Tags * tags);
-int yaffs_CountBits(__u8 byte);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.c b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.c
deleted file mode 100644 (file)
index 9e0bd1c..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * YAFFS: Yet Another Flash File System. A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#include "yaffs_tagsvalidity.h"
-
-void yaffs_InitialiseTags(yaffs_ExtendedTags * tags)
-{
-       memset(tags, 0, sizeof(yaffs_ExtendedTags));
-       tags->validMarker0 = 0xAAAAAAAA;
-       tags->validMarker1 = 0x55555555;
-}
-
-int yaffs_ValidateTags(yaffs_ExtendedTags * tags)
-{
-       return (tags->validMarker0 == 0xAAAAAAAA &&
-               tags->validMarker1 == 0x55555555);
-
-}
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffs_tagsvalidity.h
deleted file mode 100644 (file)
index 2fd0c24..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-
-#ifndef __YAFFS_TAGS_VALIDITY_H__
-#define __YAFFS_TAGS_VALIDITY_H__
-
-#include "yaffs_guts.h"
-
-void yaffs_InitialiseTags(yaffs_ExtendedTags * tags);
-int yaffs_ValidateTags(yaffs_ExtendedTags * tags);
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yaffsinterface.h b/target/linux/generic-2.6/files/fs/yaffs2/yaffsinterface.h
deleted file mode 100644 (file)
index 810837a..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-#ifndef __YAFFSINTERFACE_H__
-#define __YAFFSINTERFACE_H__
-
-int yaffs_Initialise(unsigned nBlocks);
-
-#endif
diff --git a/target/linux/generic-2.6/files/fs/yaffs2/yportenv.h b/target/linux/generic-2.6/files/fs/yaffs2/yportenv.h
deleted file mode 100644 (file)
index 15ac281..0000000
+++ /dev/null
@@ -1,187 +0,0 @@
-/*
- * YAFFS: Yet another Flash File System . A NAND-flash specific file system.
- *
- * Copyright (C) 2002-2007 Aleph One Ltd.
- *   for Toby Churchill Ltd and Brightstar Engineering
- *
- * Created by Charles Manning <charles@aleph1.co.uk>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2.1 as
- * published by the Free Software Foundation.
- *
- * Note: Only YAFFS headers are LGPL, YAFFS C code is covered by GPL.
- */
-
-
-#ifndef __YPORTENV_H__
-#define __YPORTENV_H__
-
-#if defined CONFIG_YAFFS_WINCE
-
-#include "ywinceenv.h"
-
-#elif  defined __KERNEL__
-
-#include "moduleconfig.h"
-
-/* Linux kernel */
-#include <linux/version.h>
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19))
-#include <linux/config.h>
-#endif
-#include <linux/kernel.h>
-#include <linux/mm.h>
-#include <linux/sched.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-
-#define YCHAR char
-#define YUCHAR unsigned char
-#define _Y(x)     x
-#define yaffs_strcpy(a,b)    strcpy(a,b)
-#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
-#define yaffs_strncmp(a,b,c) strncmp(a,b,c)
-#define yaffs_strlen(s)             strlen(s)
-#define yaffs_sprintf       sprintf
-#define yaffs_toupper(a)     toupper(a)
-
-#define Y_INLINE inline
-
-#define YAFFS_LOSTNFOUND_NAME          "lost+found"
-#define YAFFS_LOSTNFOUND_PREFIX                "obj"
-
-/* #define YPRINTF(x) printk x */
-#define YMALLOC(x) kmalloc(x,GFP_KERNEL)
-#define YFREE(x)   kfree(x)
-#define YMALLOC_ALT(x) vmalloc(x)
-#define YFREE_ALT(x)   vfree(x)
-#define YMALLOC_DMA(x) YMALLOC(x)
-
-// KR - added for use in scan so processes aren't blocked indefinitely.
-#define YYIELD() schedule()
-
-#define YAFFS_ROOT_MODE                        0666
-#define YAFFS_LOSTNFOUND_MODE          0666
-
-#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
-#define Y_CURRENT_TIME CURRENT_TIME.tv_sec
-#define Y_TIME_CONVERT(x) (x).tv_sec
-#else
-#define Y_CURRENT_TIME CURRENT_TIME
-#define Y_TIME_CONVERT(x) (x)
-#endif
-
-#define yaffs_SumCompare(x,y) ((x) == (y))
-#define yaffs_strcmp(a,b) strcmp(a,b)
-
-#define TENDSTR "\n"
-#define TSTR(x) KERN_WARNING x
-#define TOUT(p) printk p
-
-#define yaffs_trace(mask, fmt, args...) \
-       do { if ((mask) & (yaffs_traceMask|YAFFS_TRACE_ERROR)) \
-               printk(KERN_WARNING "yaffs: " fmt, ## args); \
-       } while (0)
-
-#define compile_time_assertion(assertion) \
-       ({ int x = __builtin_choose_expr(assertion, 0, (void)0); (void) x; })
-
-#elif defined CONFIG_YAFFS_DIRECT
-
-/* Direct interface */
-#include "ydirectenv.h"
-
-#elif defined CONFIG_YAFFS_UTIL
-
-/* Stuff for YAFFS utilities */
-
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
-
-#include "devextras.h"
-
-#define YMALLOC(x) malloc(x)
-#define YFREE(x)   free(x)
-#define YMALLOC_ALT(x) malloc(x)
-#define YFREE_ALT(x) free(x)
-
-#define YCHAR char
-#define YUCHAR unsigned char
-#define _Y(x)     x
-#define yaffs_strcpy(a,b)    strcpy(a,b)
-#define yaffs_strncpy(a,b,c) strncpy(a,b,c)
-#define yaffs_strlen(s)             strlen(s)
-#define yaffs_sprintf       sprintf
-#define yaffs_toupper(a)     toupper(a)
-
-#define Y_INLINE inline
-
-/* #define YINFO(s) YPRINTF(( __FILE__ " %d %s\n",__LINE__,s)) */
-/* #define YALERT(s) YINFO(s) */
-
-#define TENDSTR "\n"
-#define TSTR(x) x
-#define TOUT(p) printf p
-
-#define YAFFS_LOSTNFOUND_NAME          "lost+found"
-#define YAFFS_LOSTNFOUND_PREFIX                "obj"
-/* #define YPRINTF(x) printf x */
-
-#define YAFFS_ROOT_MODE                                0666
-#define YAFFS_LOSTNFOUND_MODE          0666
-
-#define yaffs_SumCompare(x,y) ((x) == (y))
-#define yaffs_strcmp(a,b) strcmp(a,b)
-
-#else
-/* Should have specified a configuration type */
-#error Unknown configuration
-
-#endif
-
-/* see yaffs_fs.c */
-extern unsigned int yaffs_traceMask;
-extern unsigned int yaffs_wr_attempts;
-
-/*
- * Tracing flags.
- * The flags masked in YAFFS_TRACE_ALWAYS are always traced.
- */
-
-#define YAFFS_TRACE_OS                 0x00000002
-#define YAFFS_TRACE_ALLOCATE           0x00000004
-#define YAFFS_TRACE_SCAN               0x00000008
-#define YAFFS_TRACE_BAD_BLOCKS         0x00000010
-#define YAFFS_TRACE_ERASE              0x00000020
-#define YAFFS_TRACE_GC                 0x00000040
-#define YAFFS_TRACE_WRITE              0x00000080
-#define YAFFS_TRACE_TRACING            0x00000100
-#define YAFFS_TRACE_DELETION           0x00000200
-#define YAFFS_TRACE_BUFFERS            0x00000400
-#define YAFFS_TRACE_NANDACCESS         0x00000800
-#define YAFFS_TRACE_GC_DETAIL          0x00001000
-#define YAFFS_TRACE_SCAN_DEBUG         0x00002000
-#define YAFFS_TRACE_MTD                        0x00004000
-#define YAFFS_TRACE_CHECKPOINT         0x00008000
-
-#define YAFFS_TRACE_VERIFY             0x00010000
-#define YAFFS_TRACE_VERIFY_NAND                0x00020000
-#define YAFFS_TRACE_VERIFY_FULL                0x00040000
-#define YAFFS_TRACE_VERIFY_ALL         0x000F0000
-
-
-#define YAFFS_TRACE_ERROR              0x40000000
-#define YAFFS_TRACE_BUG                        0x80000000
-#define YAFFS_TRACE_ALWAYS             0xF0000000
-
-
-#define T(mask,p) do{ if((mask) & (yaffs_traceMask | YAFFS_TRACE_ALWAYS)) TOUT(p);} while(0)
-
-#ifndef CONFIG_YAFFS_WINCE
-#define YBUG() T(YAFFS_TRACE_BUG,(TSTR("==>> yaffs bug: " __FILE__ " %d" TENDSTR),__LINE__))
-#endif
-
-#endif
diff --git a/target/linux/generic-2.6/files/include/linux/gpio_buttons.h b/target/linux/generic-2.6/files/include/linux/gpio_buttons.h
deleted file mode 100644 (file)
index f5e6297..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- *  Definitions for the GPIO buttons interface driver
- *
- *  Copyright (C) 2007,2008 Gabor Juhos <juhosg at openwrt.org>
- *
- *  This file was based on: /include/linux/gpio_keys.h
- *     The original gpio_keys.h seems not to have a license.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- *
- */
-
-#ifndef _GPIO_BUTTONS_H_
-#define _GPIO_BUTTONS_H_
-
-struct gpio_button {
-       int     gpio;           /* GPIO line number */
-       int     active_low;
-       char    *desc;          /* button description */
-       int     type;           /* input event type (EV_KEY, EV_SW) */
-       int     code;           /* input event code (KEY_*, SW_*) */
-       int     count;
-       int     threshold;      /* count threshold */
-};
-
-struct gpio_buttons_platform_data {
-       struct gpio_button *buttons;
-       int     nbuttons;               /* number of buttons */
-       int     poll_interval;          /* polling interval */
-};
-
-#endif /* _GPIO_BUTTONS_H_ */
-
diff --git a/target/linux/generic-2.6/files/include/linux/gpio_dev.h b/target/linux/generic-2.6/files/include/linux/gpio_dev.h
deleted file mode 100644 (file)
index 3f3c9c7..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef _GPIODEV_H__
-#define _GPIODEV_H__
-
-#define IOC_GPIODEV_MAGIC  'B'
-#define GPIO_GET        _IO(IOC_GPIODEV_MAGIC, 10)
-#define GPIO_SET        _IO(IOC_GPIODEV_MAGIC, 11)
-#define GPIO_CLEAR      _IO(IOC_GPIODEV_MAGIC, 12)
-#define GPIO_DIR_IN     _IO(IOC_GPIODEV_MAGIC, 13)
-#define GPIO_DIR_OUT    _IO(IOC_GPIODEV_MAGIC, 14)
-
-#endif
diff --git a/target/linux/generic-2.6/files/include/linux/spi/spi_gpio.h b/target/linux/generic-2.6/files/include/linux/spi/spi_gpio.h
deleted file mode 100644 (file)
index 8e7d4b1..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * spi_gpio interface to platform code
- *
- * Copyright (c) 2008 Piotr Skamruk
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-#ifndef _LINUX_SPI_SPI_GPIO
-#define _LINUX_SPI_SPI_GPIO
-
-#include <linux/types.h>
-#include <linux/spi/spi.h>
-
-
-/** struct spi_gpio_platform_data - Data definitions for a SPI-GPIO device.
- * This structure holds information about a GPIO-based SPI device.
- *
- * @pin_clk: The GPIO pin number of the CLOCK pin.
- *
- * @pin_miso: The GPIO pin number of the MISO pin.
- *
- * @pin_mosi: The GPIO pin number of the MOSI pin.
- *
- * @pin_cs: The GPIO pin number of the CHIPSELECT pin.
- *
- * @cs_activelow: If true, the chip is selected when the CS line is low.
- *
- * @no_spi_delay: If true, no delay is done in the lowlevel bitbanging.
- *                Note that doing no delay is not standards compliant,
- *                but it might be needed to speed up transfers on some
- *                slow embedded machines.
- *
- * @boardinfo_setup: This callback is called after the
- *                   SPI master device was registered, but before the
- *                   device is registered.
- * @boardinfo_setup_data: Data argument passed to boardinfo_setup().
- */
-struct spi_gpio_platform_data {
-       unsigned int pin_clk;
-       unsigned int pin_miso;
-       unsigned int pin_mosi;
-       unsigned int pin_cs;
-       bool cs_activelow;
-       bool no_spi_delay;
-       int (*boardinfo_setup)(struct spi_board_info *bi,
-                              struct spi_master *master,
-                              void *data);
-       void *boardinfo_setup_data;
-};
-
-#endif /* _LINUX_SPI_SPI_GPIO */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb.h
deleted file mode 100644 (file)
index 9d5da8b..0000000
+++ /dev/null
@@ -1,404 +0,0 @@
-#ifndef LINUX_SSB_H_
-#define LINUX_SSB_H_
-
-#include <linux/device.h>
-#include <linux/list.h>
-#include <linux/types.h>
-#include <linux/spinlock.h>
-#include <linux/pci.h>
-#include <linux/mod_devicetable.h>
-
-#include <linux/ssb/ssb_regs.h>
-
-
-struct pcmcia_device;
-struct ssb_bus;
-struct ssb_driver;
-
-struct ssb_sprom {
-       u8 revision;
-       u8 il0mac[6];           /* MAC address for 802.11b/g */
-       u8 et0mac[6];           /* MAC address for Ethernet */
-       u8 et1mac[6];           /* MAC address for 802.11a */
-       u8 et0phyaddr;          /* MII address for enet0 */
-       u8 et1phyaddr;          /* MII address for enet1 */
-       u8 et0mdcport;          /* MDIO for enet0 */
-       u8 et1mdcport;          /* MDIO for enet1 */
-       u8 board_rev;           /* Board revision number from SPROM. */
-       u8 country_code;        /* Country Code */
-       u8 ant_available_a;     /* A-PHY antenna available bits (up to 4) */
-       u8 ant_available_bg;    /* B/G-PHY antenna available bits (up to 4) */
-       u16 pa0b0;
-       u16 pa0b1;
-       u16 pa0b2;
-       u16 pa1b0;
-       u16 pa1b1;
-       u16 pa1b2;
-       u8 gpio0;               /* GPIO pin 0 */
-       u8 gpio1;               /* GPIO pin 1 */
-       u8 gpio2;               /* GPIO pin 2 */
-       u8 gpio3;               /* GPIO pin 3 */
-       u16 maxpwr_a;           /* A-PHY Amplifier Max Power (in dBm Q5.2) */
-       u16 maxpwr_bg;          /* B/G-PHY Amplifier Max Power (in dBm Q5.2) */
-       u8 itssi_a;             /* Idle TSSI Target for A-PHY */
-       u8 itssi_bg;            /* Idle TSSI Target for B/G-PHY */
-       u16 boardflags_lo;      /* Boardflags (low 16 bits) */
-       u16 boardflags_hi;      /* Boardflags (high 16 bits) */
-
-       /* Antenna gain values for up to 4 antennas
-        * on each band. Values in dBm/4 (Q5.2). Negative gain means the
-        * loss in the connectors is bigger than the gain. */
-       struct {
-               struct {
-                       s8 a0, a1, a2, a3;
-               } ghz24;        /* 2.4GHz band */
-               struct {
-                       s8 a0, a1, a2, a3;
-               } ghz5;         /* 5GHz band */
-       } antenna_gain;
-
-       /* TODO - add any parameters needed from rev 2, 3, or 4 SPROMs */
-};
-
-/* Information about the PCB the circuitry is soldered on. */
-struct ssb_boardinfo {
-       u16 vendor;
-       u16 type;
-       u16 rev;
-};
-
-
-struct ssb_device;
-/* Lowlevel read/write operations on the device MMIO.
- * Internal, don't use that outside of ssb. */
-struct ssb_bus_ops {
-       u16 (*read16)(struct ssb_device *dev, u16 offset);
-       u32 (*read32)(struct ssb_device *dev, u16 offset);
-       void (*write16)(struct ssb_device *dev, u16 offset, u16 value);
-       void (*write32)(struct ssb_device *dev, u16 offset, u32 value);
-};
-
-
-/* Core-ID values. */
-#define SSB_DEV_CHIPCOMMON     0x800
-#define SSB_DEV_ILINE20                0x801
-#define SSB_DEV_SDRAM          0x803
-#define SSB_DEV_PCI            0x804
-#define SSB_DEV_MIPS           0x805
-#define SSB_DEV_ETHERNET       0x806
-#define SSB_DEV_V90            0x807
-#define SSB_DEV_USB11_HOSTDEV  0x808
-#define SSB_DEV_ADSL           0x809
-#define SSB_DEV_ILINE100       0x80A
-#define SSB_DEV_IPSEC          0x80B
-#define SSB_DEV_PCMCIA         0x80D
-#define SSB_DEV_INTERNAL_MEM   0x80E
-#define SSB_DEV_MEMC_SDRAM     0x80F
-#define SSB_DEV_EXTIF          0x811
-#define SSB_DEV_80211          0x812
-#define SSB_DEV_MIPS_3302      0x816
-#define SSB_DEV_USB11_HOST     0x817
-#define SSB_DEV_USB11_DEV      0x818
-#define SSB_DEV_USB20_HOST     0x819
-#define SSB_DEV_USB20_DEV      0x81A
-#define SSB_DEV_SDIO_HOST      0x81B
-#define SSB_DEV_ROBOSWITCH     0x81C
-#define SSB_DEV_PARA_ATA       0x81D
-#define SSB_DEV_SATA_XORDMA    0x81E
-#define SSB_DEV_ETHERNET_GBIT  0x81F
-#define SSB_DEV_PCIE           0x820
-#define SSB_DEV_MIMO_PHY       0x821
-#define SSB_DEV_SRAM_CTRLR     0x822
-#define SSB_DEV_MINI_MACPHY    0x823
-#define SSB_DEV_ARM_1176       0x824
-#define SSB_DEV_ARM_7TDMI      0x825
-
-/* Vendor-ID values */
-#define SSB_VENDOR_BROADCOM    0x4243
-
-/* Some kernel subsystems poke with dev->drvdata, so we must use the
- * following ugly workaround to get from struct device to struct ssb_device */
-struct __ssb_dev_wrapper {
-       struct device dev;
-       struct ssb_device *sdev;
-};
-
-struct ssb_device {
-       /* Having a copy of the ops pointer in each dev struct
-        * is an optimization. */
-       const struct ssb_bus_ops *ops;
-
-       struct device *dev;
-       struct ssb_bus *bus;
-       struct ssb_device_id id;
-
-       u8 core_index;
-       unsigned int irq;
-
-       /* Internal-only stuff follows. */
-       void *drvdata;          /* Per-device data */
-       void *devtypedata;      /* Per-devicetype (eg 802.11) data */
-};
-
-/* Go from struct device to struct ssb_device. */
-static inline
-struct ssb_device * dev_to_ssb_dev(struct device *dev)
-{
-       struct __ssb_dev_wrapper *wrap;
-       wrap = container_of(dev, struct __ssb_dev_wrapper, dev);
-       return wrap->sdev;
-}
-
-/* Device specific user data */
-static inline
-void ssb_set_drvdata(struct ssb_device *dev, void *data)
-{
-       dev->drvdata = data;
-}
-static inline
-void * ssb_get_drvdata(struct ssb_device *dev)
-{
-       return dev->drvdata;
-}
-
-/* Devicetype specific user data. This is per device-type (not per device) */
-void ssb_set_devtypedata(struct ssb_device *dev, void *data);
-static inline
-void * ssb_get_devtypedata(struct ssb_device *dev)
-{
-       return dev->devtypedata;
-}
-
-
-struct ssb_driver {
-       const char *name;
-       const struct ssb_device_id *id_table;
-
-       int (*probe)(struct ssb_device *dev, const struct ssb_device_id *id);
-       void (*remove)(struct ssb_device *dev);
-       int (*suspend)(struct ssb_device *dev, pm_message_t state);
-       int (*resume)(struct ssb_device *dev);
-       void (*shutdown)(struct ssb_device *dev);
-
-       struct device_driver drv;
-};
-#define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv)
-
-extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner);
-static inline int ssb_driver_register(struct ssb_driver *drv)
-{
-       return __ssb_driver_register(drv, THIS_MODULE);
-}
-extern void ssb_driver_unregister(struct ssb_driver *drv);
-
-
-
-
-enum ssb_bustype {
-       SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */
-       SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */
-       SSB_BUSTYPE_PCMCIA,     /* SSB is connected to PCMCIA bus */
-};
-
-/* board_vendor */
-#define SSB_BOARDVENDOR_BCM    0x14E4  /* Broadcom */
-#define SSB_BOARDVENDOR_DELL   0x1028  /* Dell */
-#define SSB_BOARDVENDOR_HP     0x0E11  /* HP */
-/* board_type */
-#define SSB_BOARD_BCM94306MP   0x0418
-#define SSB_BOARD_BCM4309G     0x0421
-#define SSB_BOARD_BCM4306CB    0x0417
-#define SSB_BOARD_BCM4309MP    0x040C
-#define SSB_BOARD_MP4318       0x044A
-#define SSB_BOARD_BU4306       0x0416
-#define SSB_BOARD_BU4309       0x040A
-/* chip_package */
-#define SSB_CHIPPACK_BCM4712S  1       /* Small 200pin 4712 */
-#define SSB_CHIPPACK_BCM4712M  2       /* Medium 225pin 4712 */
-#define SSB_CHIPPACK_BCM4712L  0       /* Large 340pin 4712 */
-
-#include <linux/ssb/ssb_driver_chipcommon.h>
-#include <linux/ssb/ssb_driver_mips.h>
-#include <linux/ssb/ssb_driver_extif.h>
-#include <linux/ssb/ssb_driver_pci.h>
-
-struct ssb_bus {
-       /* The MMIO area. */
-       void __iomem *mmio;
-
-       const struct ssb_bus_ops *ops;
-
-       /* The core in the basic address register window. (PCI bus only) */
-       struct ssb_device *mapped_device;
-       /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */
-       u8 mapped_pcmcia_seg;
-       /* Lock for core and segment switching.
-        * On PCMCIA-host busses this is used to protect the whole MMIO access. */
-       spinlock_t bar_lock;
-
-       /* The bus this backplane is running on. */
-       enum ssb_bustype bustype;
-       /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */
-       struct pci_dev *host_pci;
-       /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */
-       struct pcmcia_device *host_pcmcia;
-
-#ifdef CONFIG_SSB_PCIHOST
-       /* Mutex to protect the SPROM writing. */
-       struct mutex pci_sprom_mutex;
-#endif
-
-       /* ID information about the Chip. */
-       u16 chip_id;
-       u16 chip_rev;
-       u16 sprom_size;         /* number of words in sprom */
-       u8 chip_package;
-
-       /* List of devices (cores) on the backplane. */
-       struct ssb_device devices[SSB_MAX_NR_CORES];
-       u8 nr_devices;
-
-       /* Reference count. Number of suspended devices. */
-       u8 suspend_cnt;
-
-       /* Software ID number for this bus. */
-       unsigned int busnumber;
-
-       /* The ChipCommon device (if available). */
-       struct ssb_chipcommon chipco;
-       /* The PCI-core device (if available). */
-       struct ssb_pcicore pcicore;
-       /* The MIPS-core device (if available). */
-       struct ssb_mipscore mipscore;
-       /* The EXTif-core device (if available). */
-       struct ssb_extif extif;
-
-       /* The following structure elements are not available in early
-        * SSB initialization. Though, they are available for regular
-        * registered drivers at any stage. So be careful when
-        * using them in the ssb core code. */
-
-       /* ID information about the PCB. */
-       struct ssb_boardinfo boardinfo;
-       /* Contents of the SPROM. */
-       struct ssb_sprom sprom;
-
-       /* Internal-only stuff follows. Do not touch. */
-       struct list_head list;
-#ifdef CONFIG_SSB_DEBUG
-       /* Is the bus already powered up? */
-       bool powered_up;
-       int power_warn_count;
-#endif /* DEBUG */
-};
-
-/* The initialization-invariants. */
-struct ssb_init_invariants {
-       struct ssb_boardinfo boardinfo;
-       struct ssb_sprom sprom;
-};
-/* Type of function to fetch the invariants. */
-typedef int (*ssb_invariants_func_t)(struct ssb_bus *bus,
-                                    struct ssb_init_invariants *iv);
-
-/* Register a SSB system bus. get_invariants() is called after the
- * basic system devices are initialized.
- * The invariants are usually fetched from some NVRAM.
- * Put the invariants into the struct pointed to by iv. */
-extern int ssb_bus_ssbbus_register(struct ssb_bus *bus,
-                                  unsigned long baseaddr,
-                                  ssb_invariants_func_t get_invariants);
-#ifdef CONFIG_SSB_PCIHOST
-extern int ssb_bus_pcibus_register(struct ssb_bus *bus,
-                                  struct pci_dev *host_pci);
-#endif /* CONFIG_SSB_PCIHOST */
-#ifdef CONFIG_SSB_PCMCIAHOST
-extern int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
-                                     struct pcmcia_device *pcmcia_dev,
-                                     unsigned long baseaddr);
-#endif /* CONFIG_SSB_PCMCIAHOST */
-
-extern void ssb_bus_unregister(struct ssb_bus *bus);
-
-extern u32 ssb_clockspeed(struct ssb_bus *bus);
-
-/* Is the device enabled in hardware? */
-int ssb_device_is_enabled(struct ssb_device *dev);
-/* Enable a device and pass device-specific SSB_TMSLOW flags.
- * If no device-specific flags are available, use 0. */
-void ssb_device_enable(struct ssb_device *dev, u32 core_specific_flags);
-/* Disable a device in hardware and pass SSB_TMSLOW flags (if any). */
-void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags);
-
-
-/* Device MMIO register read/write functions. */
-static inline u16 ssb_read16(struct ssb_device *dev, u16 offset)
-{
-       return dev->ops->read16(dev, offset);
-}
-static inline u32 ssb_read32(struct ssb_device *dev, u16 offset)
-{
-       return dev->ops->read32(dev, offset);
-}
-static inline void ssb_write16(struct ssb_device *dev, u16 offset, u16 value)
-{
-       dev->ops->write16(dev, offset, value);
-}
-static inline void ssb_write32(struct ssb_device *dev, u16 offset, u32 value)
-{
-       dev->ops->write32(dev, offset, value);
-}
-
-
-/* Translation (routing) bits that need to be ORed to DMA
- * addresses before they are given to a device. */
-extern u32 ssb_dma_translation(struct ssb_device *dev);
-#define SSB_DMA_TRANSLATION_MASK       0xC0000000
-#define SSB_DMA_TRANSLATION_SHIFT      30
-
-extern int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask);
-
-
-#ifdef CONFIG_SSB_PCIHOST
-/* PCI-host wrapper driver */
-extern int ssb_pcihost_register(struct pci_driver *driver);
-static inline void ssb_pcihost_unregister(struct pci_driver *driver)
-{
-       pci_unregister_driver(driver);
-}
-
-static inline
-void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state)
-{
-       if (sdev->bus->bustype == SSB_BUSTYPE_PCI)
-               pci_set_power_state(sdev->bus->host_pci, state);
-}
-#else
-static inline void ssb_pcihost_unregister(struct pci_driver *driver)
-{
-}
-
-static inline
-void ssb_pcihost_set_power_state(struct ssb_device *sdev, pci_power_t state)
-{
-}
-#endif /* CONFIG_SSB_PCIHOST */
-
-
-/* If a driver is shutdown or suspended, call this to signal
- * that the bus may be completely powered down. SSB will decide,
- * if it's really time to power down the bus, based on if there
- * are other devices that want to run. */
-extern int ssb_bus_may_powerdown(struct ssb_bus *bus);
-/* Before initializing and enabling a device, call this to power-up the bus.
- * If you want to allow use of dynamic-power-control, pass the flag.
- * Otherwise static always-on powercontrol will be used. */
-extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl);
-
-
-/* Various helper functions */
-extern u32 ssb_admatch_base(u32 adm);
-extern u32 ssb_admatch_size(u32 adm);
-
-
-#endif /* LINUX_SSB_H_ */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_chipcommon.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_chipcommon.h
deleted file mode 100644 (file)
index 4cb9954..0000000
+++ /dev/null
@@ -1,396 +0,0 @@
-#ifndef LINUX_SSB_CHIPCO_H_
-#define LINUX_SSB_CHIPCO_H_
-
-/* SonicsSiliconBackplane CHIPCOMMON core hardware definitions
- *
- * The chipcommon core provides chip identification, SB control,
- * jtag, 0/1/2 uarts, clock frequency control, a watchdog interrupt timer,
- * gpio interface, extbus, and support for serial and parallel flashes.
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, Michael Buesch <mb@bu3sch.de>
- *
- * Licensed under the GPL version 2. See COPYING for details.
- */
-
-/** ChipCommon core registers. **/
-
-#define SSB_CHIPCO_CHIPID              0x0000
-#define  SSB_CHIPCO_IDMASK             0x0000FFFF
-#define  SSB_CHIPCO_REVMASK            0x000F0000
-#define  SSB_CHIPCO_REVSHIFT           16
-#define  SSB_CHIPCO_PACKMASK           0x00F00000
-#define  SSB_CHIPCO_PACKSHIFT          20
-#define  SSB_CHIPCO_NRCORESMASK                0x0F000000
-#define  SSB_CHIPCO_NRCORESSHIFT       24
-#define SSB_CHIPCO_CAP                 0x0004          /* Capabilities */
-#define  SSB_CHIPCO_CAP_NRUART         0x00000003      /* # of UARTs */
-#define  SSB_CHIPCO_CAP_MIPSEB         0x00000004      /* MIPS in BigEndian Mode */
-#define  SSB_CHIPCO_CAP_UARTCLK                0x00000018      /* UART clock select */
-#define   SSB_CHIPCO_CAP_UARTCLK_INT   0x00000008      /* UARTs are driven by internal divided clock */
-#define  SSB_CHIPCO_CAP_UARTGPIO       0x00000020      /* UARTs on GPIO 15-12 */
-#define  SSB_CHIPCO_CAP_EXTBUS         0x000000C0      /* External buses present */
-#define  SSB_CHIPCO_CAP_FLASHT         0x00000700      /* Flash Type */
-#define   SSB_CHIPCO_FLASHT_NONE       0x00000000      /* No flash */
-#define   SSB_CHIPCO_FLASHT_STSER      0x00000100      /* ST serial flash */
-#define   SSB_CHIPCO_FLASHT_ATSER      0x00000200      /* Atmel serial flash */
-#define          SSB_CHIPCO_FLASHT_PARA        0x00000700      /* Parallel flash */
-#define  SSB_CHIPCO_CAP_PLLT           0x00038000      /* PLL Type */
-#define   SSB_PLLTYPE_NONE             0x00000000
-#define   SSB_PLLTYPE_1                        0x00010000      /* 48Mhz base, 3 dividers */
-#define   SSB_PLLTYPE_2                        0x00020000      /* 48Mhz, 4 dividers */
-#define   SSB_PLLTYPE_3                        0x00030000      /* 25Mhz, 2 dividers */
-#define   SSB_PLLTYPE_4                        0x00008000      /* 48Mhz, 4 dividers */
-#define   SSB_PLLTYPE_5                        0x00018000      /* 25Mhz, 4 dividers */
-#define   SSB_PLLTYPE_6                        0x00028000      /* 100/200 or 120/240 only */
-#define   SSB_PLLTYPE_7                        0x00038000      /* 25Mhz, 4 dividers */
-#define  SSB_CHIPCO_CAP_PCTL           0x00040000      /* Power Control */
-#define  SSB_CHIPCO_CAP_OTPS           0x00380000      /* OTP size */
-#define  SSB_CHIPCO_CAP_OTPS_SHIFT     19
-#define  SSB_CHIPCO_CAP_OTPS_BASE      5
-#define  SSB_CHIPCO_CAP_JTAGM          0x00400000      /* JTAG master present */
-#define  SSB_CHIPCO_CAP_BROM           0x00800000      /* Internal boot ROM active */
-#define  SSB_CHIPCO_CAP_64BIT          0x08000000      /* 64-bit Backplane */
-#define SSB_CHIPCO_CORECTL             0x0008
-#define  SSB_CHIPCO_CORECTL_UARTCLK0   0x00000001      /* Drive UART with internal clock */
-#define         SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */
-#define SSB_CHIPCO_BIST                        0x000C
-#define SSB_CHIPCO_OTPS                        0x0010          /* OTP status */
-#define         SSB_CHIPCO_OTPS_PROGFAIL       0x80000000
-#define         SSB_CHIPCO_OTPS_PROTECT        0x00000007
-#define         SSB_CHIPCO_OTPS_HW_PROTECT     0x00000001
-#define         SSB_CHIPCO_OTPS_SW_PROTECT     0x00000002
-#define         SSB_CHIPCO_OTPS_CID_PROTECT    0x00000004
-#define SSB_CHIPCO_OTPC                        0x0014          /* OTP control */
-#define         SSB_CHIPCO_OTPC_RECWAIT        0xFF000000
-#define         SSB_CHIPCO_OTPC_PROGWAIT       0x00FFFF00
-#define         SSB_CHIPCO_OTPC_PRW_SHIFT      8
-#define         SSB_CHIPCO_OTPC_MAXFAIL        0x00000038
-#define         SSB_CHIPCO_OTPC_VSEL           0x00000006
-#define         SSB_CHIPCO_OTPC_SELVL          0x00000001
-#define SSB_CHIPCO_OTPP                        0x0018          /* OTP prog */
-#define         SSB_CHIPCO_OTPP_COL            0x000000FF
-#define         SSB_CHIPCO_OTPP_ROW            0x0000FF00
-#define         SSB_CHIPCO_OTPP_ROW_SHIFT      8
-#define         SSB_CHIPCO_OTPP_READERR        0x10000000
-#define         SSB_CHIPCO_OTPP_VALUE          0x20000000
-#define         SSB_CHIPCO_OTPP_READ           0x40000000
-#define         SSB_CHIPCO_OTPP_START          0x80000000
-#define         SSB_CHIPCO_OTPP_BUSY           0x80000000
-#define SSB_CHIPCO_IRQSTAT             0x0020
-#define SSB_CHIPCO_IRQMASK             0x0024
-#define         SSB_CHIPCO_IRQ_GPIO            0x00000001      /* gpio intr */
-#define         SSB_CHIPCO_IRQ_EXT             0x00000002      /* ro: ext intr pin (corerev >= 3) */
-#define         SSB_CHIPCO_IRQ_WDRESET         0x80000000      /* watchdog reset occurred */
-#define SSB_CHIPCO_CHIPCTL             0x0028          /* Rev >= 11 only */
-#define SSB_CHIPCO_CHIPSTAT            0x002C          /* Rev >= 11 only */
-#define SSB_CHIPCO_JCMD                        0x0030          /* Rev >= 10 only */
-#define  SSB_CHIPCO_JCMD_START         0x80000000
-#define  SSB_CHIPCO_JCMD_BUSY          0x80000000
-#define  SSB_CHIPCO_JCMD_PAUSE         0x40000000
-#define  SSB_CHIPCO_JCMD0_ACC_MASK     0x0000F000
-#define  SSB_CHIPCO_JCMD0_ACC_IRDR     0x00000000
-#define  SSB_CHIPCO_JCMD0_ACC_DR       0x00001000
-#define  SSB_CHIPCO_JCMD0_ACC_IR       0x00002000
-#define  SSB_CHIPCO_JCMD0_ACC_RESET    0x00003000
-#define  SSB_CHIPCO_JCMD0_ACC_IRPDR    0x00004000
-#define  SSB_CHIPCO_JCMD0_ACC_PDR      0x00005000
-#define  SSB_CHIPCO_JCMD0_IRW_MASK     0x00000F00
-#define  SSB_CHIPCO_JCMD_ACC_MASK      0x000F0000      /* Changes for corerev 11 */
-#define  SSB_CHIPCO_JCMD_ACC_IRDR      0x00000000
-#define  SSB_CHIPCO_JCMD_ACC_DR                0x00010000
-#define  SSB_CHIPCO_JCMD_ACC_IR                0x00020000
-#define  SSB_CHIPCO_JCMD_ACC_RESET     0x00030000
-#define  SSB_CHIPCO_JCMD_ACC_IRPDR     0x00040000
-#define  SSB_CHIPCO_JCMD_ACC_PDR       0x00050000
-#define  SSB_CHIPCO_JCMD_IRW_MASK      0x00001F00
-#define  SSB_CHIPCO_JCMD_IRW_SHIFT     8
-#define  SSB_CHIPCO_JCMD_DRW_MASK      0x0000003F
-#define SSB_CHIPCO_JIR                 0x0034          /* Rev >= 10 only */
-#define SSB_CHIPCO_JDR                 0x0038          /* Rev >= 10 only */
-#define SSB_CHIPCO_JCTL                        0x003C          /* Rev >= 10 only */
-#define  SSB_CHIPCO_JCTL_FORCE_CLK     4               /* Force clock */
-#define  SSB_CHIPCO_JCTL_EXT_EN                2               /* Enable external targets */
-#define  SSB_CHIPCO_JCTL_EN            1               /* Enable Jtag master */
-#define SSB_CHIPCO_FLASHCTL            0x0040
-#define  SSB_CHIPCO_FLASHCTL_START     0x80000000
-#define  SSB_CHIPCO_FLASHCTL_BUSY      SSB_CHIPCO_FLASHCTL_START
-#define SSB_CHIPCO_FLASHADDR           0x0044
-#define SSB_CHIPCO_FLASHDATA           0x0048
-#define SSB_CHIPCO_BCAST_ADDR          0x0050
-#define SSB_CHIPCO_BCAST_DATA          0x0054
-#define SSB_CHIPCO_GPIOIN              0x0060
-#define SSB_CHIPCO_GPIOOUT             0x0064
-#define SSB_CHIPCO_GPIOOUTEN           0x0068
-#define SSB_CHIPCO_GPIOCTL             0x006C
-#define SSB_CHIPCO_GPIOPOL             0x0070
-#define SSB_CHIPCO_GPIOIRQ             0x0074
-#define SSB_CHIPCO_WATCHDOG            0x0080
-#define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */
-#define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16
-#define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */
-#define SSB_CHIPCO_CLOCK_N             0x0090
-#define SSB_CHIPCO_CLOCK_SB            0x0094
-#define SSB_CHIPCO_CLOCK_PCI           0x0098
-#define SSB_CHIPCO_CLOCK_M2            0x009C
-#define SSB_CHIPCO_CLOCK_MIPS          0x00A0
-#define SSB_CHIPCO_CLKDIV              0x00A4          /* Rev >= 3 only */
-#define         SSB_CHIPCO_CLKDIV_SFLASH       0x0F000000
-#define         SSB_CHIPCO_CLKDIV_SFLASH_SHIFT 24
-#define         SSB_CHIPCO_CLKDIV_OTP          0x000F0000
-#define         SSB_CHIPCO_CLKDIV_OTP_SHIFT    16
-#define         SSB_CHIPCO_CLKDIV_JTAG         0x00000F00
-#define         SSB_CHIPCO_CLKDIV_JTAG_SHIFT   8
-#define         SSB_CHIPCO_CLKDIV_UART         0x000000FF
-#define SSB_CHIPCO_PLLONDELAY          0x00B0          /* Rev >= 4 only */
-#define SSB_CHIPCO_FREFSELDELAY                0x00B4          /* Rev >= 4 only */
-#define SSB_CHIPCO_SLOWCLKCTL          0x00B8          /* 6 <= Rev <= 9 only */
-#define  SSB_CHIPCO_SLOWCLKCTL_SRC     0x00000007      /* slow clock source mask */
-#define          SSB_CHIPCO_SLOWCLKCTL_SRC_LPO         0x00000000      /* source of slow clock is LPO */
-#define   SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL       0x00000001      /* source of slow clock is crystal */
-#define          SSB_CHIPCO_SLOECLKCTL_SRC_PCI         0x00000002      /* source of slow clock is PCI */
-#define  SSB_CHIPCO_SLOWCLKCTL_LPOFREQ 0x00000200      /* LPOFreqSel, 1: 160Khz, 0: 32KHz */
-#define  SSB_CHIPCO_SLOWCLKCTL_LPOPD   0x00000400      /* LPOPowerDown, 1: LPO is disabled, 0: LPO is enabled */
-#define  SSB_CHIPCO_SLOWCLKCTL_FSLOW   0x00000800      /* ForceSlowClk, 1: sb/cores running on slow clock, 0: power logic control */
-#define  SSB_CHIPCO_SLOWCLKCTL_IPLL    0x00001000      /* IgnorePllOffReq, 1/0: power logic ignores/honors PLL clock disable requests from core */
-#define  SSB_CHIPCO_SLOWCLKCTL_ENXTAL  0x00002000      /* XtalControlEn, 1/0: power logic does/doesn't disable crystal when appropriate */
-#define  SSB_CHIPCO_SLOWCLKCTL_XTALPU  0x00004000      /* XtalPU (RO), 1/0: crystal running/disabled */
-#define  SSB_CHIPCO_SLOWCLKCTL_CLKDIV  0xFFFF0000      /* ClockDivider (SlowClk = 1/(4+divisor)) */
-#define  SSB_CHIPCO_SLOWCLKCTL_CLKDIV_SHIFT    16
-#define SSB_CHIPCO_SYSCLKCTL           0x00C0          /* Rev >= 3 only */
-#define         SSB_CHIPCO_SYSCLKCTL_IDLPEN    0x00000001      /* ILPen: Enable Idle Low Power */
-#define         SSB_CHIPCO_SYSCLKCTL_ALPEN     0x00000002      /* ALPen: Enable Active Low Power */
-#define         SSB_CHIPCO_SYSCLKCTL_PLLEN     0x00000004      /* ForcePLLOn */
-#define         SSB_CHIPCO_SYSCLKCTL_FORCEALP  0x00000008      /* Force ALP (or HT if ALPen is not set */
-#define         SSB_CHIPCO_SYSCLKCTL_FORCEHT   0x00000010      /* Force HT */
-#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV   0xFFFF0000      /* ClkDiv  (ILP = 1/(4+divisor)) */
-#define  SSB_CHIPCO_SYSCLKCTL_CLKDIV_SHIFT     16
-#define SSB_CHIPCO_CLKSTSTR            0x00C4          /* Rev >= 3 only */
-#define SSB_CHIPCO_PCMCIA_CFG          0x0100
-#define SSB_CHIPCO_PCMCIA_MEMWAIT      0x0104
-#define SSB_CHIPCO_PCMCIA_ATTRWAIT     0x0108
-#define SSB_CHIPCO_PCMCIA_IOWAIT       0x010C
-#define SSB_CHIPCO_IDE_CFG             0x0110
-#define SSB_CHIPCO_IDE_MEMWAIT         0x0114
-#define SSB_CHIPCO_IDE_ATTRWAIT                0x0118
-#define SSB_CHIPCO_IDE_IOWAIT          0x011C
-#define SSB_CHIPCO_PROG_CFG            0x0120
-#define SSB_CHIPCO_PROG_WAITCNT                0x0124
-#define SSB_CHIPCO_FLASH_CFG           0x0128
-#define SSB_CHIPCO_FLASH_WAITCNT       0x012C
-#define SSB_CHIPCO_UART0_DATA          0x0300
-#define SSB_CHIPCO_UART0_IMR           0x0304
-#define SSB_CHIPCO_UART0_FCR           0x0308
-#define SSB_CHIPCO_UART0_LCR           0x030C
-#define SSB_CHIPCO_UART0_MCR           0x0310
-#define SSB_CHIPCO_UART0_LSR           0x0314
-#define SSB_CHIPCO_UART0_MSR           0x0318
-#define SSB_CHIPCO_UART0_SCRATCH       0x031C
-#define SSB_CHIPCO_UART1_DATA          0x0400
-#define SSB_CHIPCO_UART1_IMR           0x0404
-#define SSB_CHIPCO_UART1_FCR           0x0408
-#define SSB_CHIPCO_UART1_LCR           0x040C
-#define SSB_CHIPCO_UART1_MCR           0x0410
-#define SSB_CHIPCO_UART1_LSR           0x0414
-#define SSB_CHIPCO_UART1_MSR           0x0418
-#define SSB_CHIPCO_UART1_SCRATCH       0x041C
-
-
-
-/** Clockcontrol masks and values **/
-
-/* SSB_CHIPCO_CLOCK_N */
-#define        SSB_CHIPCO_CLK_N1               0x0000003F      /* n1 control */
-#define        SSB_CHIPCO_CLK_N2               0x00003F00      /* n2 control */
-#define        SSB_CHIPCO_CLK_N2_SHIFT         8
-#define        SSB_CHIPCO_CLK_PLLC             0x000F0000      /* pll control */
-#define        SSB_CHIPCO_CLK_PLLC_SHIFT       16
-
-/* SSB_CHIPCO_CLOCK_SB/PCI/UART */
-#define        SSB_CHIPCO_CLK_M1               0x0000003F      /* m1 control */
-#define        SSB_CHIPCO_CLK_M2               0x00003F00      /* m2 control */
-#define        SSB_CHIPCO_CLK_M2_SHIFT         8
-#define        SSB_CHIPCO_CLK_M3               0x003F0000      /* m3 control */
-#define        SSB_CHIPCO_CLK_M3_SHIFT         16
-#define        SSB_CHIPCO_CLK_MC               0x1F000000      /* mux control */
-#define        SSB_CHIPCO_CLK_MC_SHIFT         24
-
-/* N3M Clock control magic field values */
-#define        SSB_CHIPCO_CLK_F6_2             0x02            /* A factor of 2 in */
-#define        SSB_CHIPCO_CLK_F6_3             0x03            /* 6-bit fields like */
-#define        SSB_CHIPCO_CLK_F6_4             0x05            /* N1, M1 or M3 */
-#define        SSB_CHIPCO_CLK_F6_5             0x09
-#define        SSB_CHIPCO_CLK_F6_6             0x11
-#define        SSB_CHIPCO_CLK_F6_7             0x21
-
-#define        SSB_CHIPCO_CLK_F5_BIAS          5               /* 5-bit fields get this added */
-
-#define        SSB_CHIPCO_CLK_MC_BYPASS        0x08
-#define        SSB_CHIPCO_CLK_MC_M1            0x04
-#define        SSB_CHIPCO_CLK_MC_M1M2          0x02
-#define        SSB_CHIPCO_CLK_MC_M1M2M3        0x01
-#define        SSB_CHIPCO_CLK_MC_M1M3          0x11
-
-/* Type 2 Clock control magic field values */
-#define        SSB_CHIPCO_CLK_T2_BIAS          2               /* n1, n2, m1 & m3 bias */
-#define        SSB_CHIPCO_CLK_T2M2_BIAS        3               /* m2 bias */
-
-#define        SSB_CHIPCO_CLK_T2MC_M1BYP       1
-#define        SSB_CHIPCO_CLK_T2MC_M2BYP       2
-#define        SSB_CHIPCO_CLK_T2MC_M3BYP       4
-
-/* Type 6 Clock control magic field values */
-#define        SSB_CHIPCO_CLK_T6_MMASK         1               /* bits of interest in m */
-#define        SSB_CHIPCO_CLK_T6_M0            120000000       /* sb clock for m = 0 */
-#define        SSB_CHIPCO_CLK_T6_M1            100000000       /* sb clock for m = 1 */
-#define        SSB_CHIPCO_CLK_SB2MIPS_T6(sb)   (2 * (sb))
-
-/* Common clock base */
-#define        SSB_CHIPCO_CLK_BASE1            24000000        /* Half the clock freq */
-#define SSB_CHIPCO_CLK_BASE2           12500000        /* Alternate crystal on some PLL's */
-
-/* Clock control values for 200Mhz in 5350 */
-#define        SSB_CHIPCO_CLK_5350_N           0x0311
-#define        SSB_CHIPCO_CLK_5350_M           0x04020009
-
-
-/** Bits in the config registers **/
-
-#define        SSB_CHIPCO_CFG_EN               0x0001          /* Enable */
-#define        SSB_CHIPCO_CFG_EXTM             0x000E          /* Extif Mode */
-#define         SSB_CHIPCO_CFG_EXTM_ASYNC      0x0002          /* Async/Parallel flash */
-#define         SSB_CHIPCO_CFG_EXTM_SYNC       0x0004          /* Synchronous */
-#define         SSB_CHIPCO_CFG_EXTM_PCMCIA     0x0008          /* PCMCIA */
-#define         SSB_CHIPCO_CFG_EXTM_IDE        0x000A          /* IDE */
-#define        SSB_CHIPCO_CFG_DS16             0x0010          /* Data size, 0=8bit, 1=16bit */
-#define        SSB_CHIPCO_CFG_CLKDIV           0x0060          /* Sync: Clock divisor */
-#define        SSB_CHIPCO_CFG_CLKEN            0x0080          /* Sync: Clock enable */
-#define        SSB_CHIPCO_CFG_BSTRO            0x0100          /* Sync: Size/Bytestrobe */
-
-
-/** Flash-specific control/status values */
-
-/* flashcontrol opcodes for ST flashes */
-#define SSB_CHIPCO_FLASHCTL_ST_WREN    0x0006          /* Write Enable */
-#define SSB_CHIPCO_FLASHCTL_ST_WRDIS   0x0004          /* Write Disable */
-#define SSB_CHIPCO_FLASHCTL_ST_RDSR    0x0105          /* Read Status Register */
-#define SSB_CHIPCO_FLASHCTL_ST_WRSR    0x0101          /* Write Status Register */
-#define SSB_CHIPCO_FLASHCTL_ST_READ    0x0303          /* Read Data Bytes */
-#define SSB_CHIPCO_FLASHCTL_ST_PP      0x0302          /* Page Program */
-#define SSB_CHIPCO_FLASHCTL_ST_SE      0x02D8          /* Sector Erase */
-#define SSB_CHIPCO_FLASHCTL_ST_BE      0x00C7          /* Bulk Erase */
-#define SSB_CHIPCO_FLASHCTL_ST_DP      0x00B9          /* Deep Power-down */
-#define SSB_CHIPCO_FLASHCTL_ST_RSIG    0x03AB          /* Read Electronic Signature */
-
-/* Status register bits for ST flashes */
-#define SSB_CHIPCO_FLASHSTA_ST_WIP     0x01            /* Write In Progress */
-#define SSB_CHIPCO_FLASHSTA_ST_WEL     0x02            /* Write Enable Latch */
-#define SSB_CHIPCO_FLASHSTA_ST_BP      0x1C            /* Block Protect */
-#define SSB_CHIPCO_FLASHSTA_ST_BP_SHIFT        2
-#define SSB_CHIPCO_FLASHSTA_ST_SRWD    0x80            /* Status Register Write Disable */
-
-/* flashcontrol opcodes for Atmel flashes */
-#define SSB_CHIPCO_FLASHCTL_AT_READ            0x07E8
-#define SSB_CHIPCO_FLASHCTL_AT_PAGE_READ       0x07D2
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_READ       /* FIXME */
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_READ       /* FIXME */
-#define SSB_CHIPCO_FLASHCTL_AT_STATUS          0x01D7
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_WRITE      0x0384
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_WRITE      0x0387
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_ERASE_PRGM 0x0283  /* Erase program */
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_ERASE_PRGM 0x0286  /* Erase program */
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_PROGRAM    0x0288
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_PROGRAM    0x0289
-#define SSB_CHIPCO_FLASHCTL_AT_PAGE_ERASE      0x0281
-#define SSB_CHIPCO_FLASHCTL_AT_BLOCK_ERASE     0x0250
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_WRER_PRGM  0x0382  /* Write erase program */
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_WRER_PRGM  0x0385  /* Write erase program */
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_LOAD       0x0253
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_LOAD       0x0255
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_COMPARE    0x0260
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_COMPARE    0x0261
-#define SSB_CHIPCO_FLASHCTL_AT_BUF1_REPROGRAM  0x0258
-#define SSB_CHIPCO_FLASHCTL_AT_BUF2_REPROGRAM  0x0259
-
-/* Status register bits for Atmel flashes */
-#define SSB_CHIPCO_FLASHSTA_AT_READY   0x80
-#define SSB_CHIPCO_FLASHSTA_AT_MISMATCH        0x40
-#define SSB_CHIPCO_FLASHSTA_AT_ID      0x38
-#define SSB_CHIPCO_FLASHSTA_AT_ID_SHIFT        3
-
-
-/** OTP **/
-
-/* OTP regions */
-#define        SSB_CHIPCO_OTP_HW_REGION        SSB_CHIPCO_OTPS_HW_PROTECT
-#define        SSB_CHIPCO_OTP_SW_REGION        SSB_CHIPCO_OTPS_SW_PROTECT
-#define        SSB_CHIPCO_OTP_CID_REGION       SSB_CHIPCO_OTPS_CID_PROTECT
-
-/* OTP regions (Byte offsets from otp size) */
-#define        SSB_CHIPCO_OTP_SWLIM_OFF        (-8)
-#define        SSB_CHIPCO_OTP_CIDBASE_OFF      0
-#define        SSB_CHIPCO_OTP_CIDLIM_OFF       8
-
-/* Predefined OTP words (Word offset from otp size) */
-#define        SSB_CHIPCO_OTP_BOUNDARY_OFF     (-4)
-#define        SSB_CHIPCO_OTP_HWSIGN_OFF       (-3)
-#define        SSB_CHIPCO_OTP_SWSIGN_OFF       (-2)
-#define        SSB_CHIPCO_OTP_CIDSIGN_OFF      (-1)
-
-#define        SSB_CHIPCO_OTP_CID_OFF          0
-#define        SSB_CHIPCO_OTP_PKG_OFF          1
-#define        SSB_CHIPCO_OTP_FID_OFF          2
-#define        SSB_CHIPCO_OTP_RSV_OFF          3
-#define        SSB_CHIPCO_OTP_LIM_OFF          4
-
-#define        SSB_CHIPCO_OTP_SIGNATURE        0x578A
-#define        SSB_CHIPCO_OTP_MAGIC            0x4E56
-
-
-struct ssb_device;
-struct ssb_serial_port;
-
-struct ssb_chipcommon {
-       struct ssb_device *dev;
-       u32 capabilities;
-       /* Fast Powerup Delay constant */
-       u16 fast_pwrup_delay;
-};
-
-extern void ssb_chipcommon_init(struct ssb_chipcommon *cc);
-
-#include <linux/pm.h>
-extern void ssb_chipco_suspend(struct ssb_chipcommon *cc, pm_message_t state);
-extern void ssb_chipco_resume(struct ssb_chipcommon *cc);
-
-extern void ssb_chipco_get_clockcpu(struct ssb_chipcommon *cc,
-                                    u32 *plltype, u32 *n, u32 *m);
-extern void ssb_chipco_get_clockcontrol(struct ssb_chipcommon *cc,
-                                       u32 *plltype, u32 *n, u32 *m);
-extern void ssb_chipco_timing_init(struct ssb_chipcommon *cc,
-                                  unsigned long ns_per_cycle);
-
-enum ssb_clkmode {
-       SSB_CLKMODE_SLOW,
-       SSB_CLKMODE_FAST,
-       SSB_CLKMODE_DYNAMIC,
-};
-
-extern void ssb_chipco_set_clockmode(struct ssb_chipcommon *cc,
-                                    enum ssb_clkmode mode);
-
-extern void ssb_chipco_watchdog_timer_set(struct ssb_chipcommon *cc,
-                                         u32 ticks);
-
-u32 ssb_chipco_gpio_in(struct ssb_chipcommon *cc, u32 mask);
-
-void ssb_chipco_gpio_out(struct ssb_chipcommon *cc, u32 mask, u32 value);
-
-void ssb_chipco_gpio_outen(struct ssb_chipcommon *cc, u32 mask, u32 value);
-
-#ifdef CONFIG_SSB_SERIAL
-extern int ssb_chipco_serial_init(struct ssb_chipcommon *cc,
-                                 struct ssb_serial_port *ports);
-#endif /* CONFIG_SSB_SERIAL */
-
-#endif /* LINUX_SSB_CHIPCO_H_ */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_extif.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_extif.h
deleted file mode 100644 (file)
index a916435..0000000
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Hardware-specific External Interface I/O core definitions
- * for the BCM47xx family of SiliconBackplane-based chips.
- *
- * The External Interface core supports a total of three external chip selects
- * supporting external interfaces. One of the external chip selects is
- * used for Flash, one is used for PCMCIA, and the other may be
- * programmed to support either a synchronous interface or an
- * asynchronous interface. The asynchronous interface can be used to
- * support external devices such as UARTs and the BCM2019 Bluetooth
- * baseband processor.
- * The external interface core also contains 2 on-chip 16550 UARTs, clock
- * frequency control, a watchdog interrupt timer, and a GPIO interface.
- *
- * Copyright 2005, Broadcom Corporation
- * Copyright 2006, Michael Buesch
- *
- * Licensed under the GPL version 2. See COPYING for details.
- */
-#ifndef LINUX_SSB_EXTIFCORE_H_
-#define LINUX_SSB_EXTIFCORE_H_
-
-/* external interface address space */
-#define        SSB_EXTIF_PCMCIA_MEMBASE(x)     (x)
-#define        SSB_EXTIF_PCMCIA_IOBASE(x)      ((x) + 0x100000)
-#define        SSB_EXTIF_PCMCIA_CFGBASE(x)     ((x) + 0x200000)
-#define        SSB_EXTIF_CFGIF_BASE(x)         ((x) + 0x800000)
-#define        SSB_EXTIF_FLASH_BASE(x)         ((x) + 0xc00000)
-
-#define SSB_EXTIF_NR_GPIOOUT           5
-/* GPIO NOTE:
- * The multiple instances of output and output enable registers
- * are present to allow driver software for multiple cores to control
- * gpio outputs without needing to share a single register pair.
- * Use the following helper macro to get a register offset value.
- */
-#define SSB_EXTIF_GPIO_OUT(index)      ({              \
-       BUILD_BUG_ON(index >= SSB_EXTIF_NR_GPIOOUT);    \
-       SSB_EXTIF_GPIO_OUT_BASE + ((index) * 8);        \
-                                       })
-#define SSB_EXTIF_GPIO_OUTEN(index)    ({              \
-       BUILD_BUG_ON(index >= SSB_EXTIF_NR_GPIOOUT);    \
-       SSB_EXTIF_GPIO_OUTEN_BASE + ((index) * 8);      \
-                                       })
-
-/** EXTIF core registers **/
-
-#define SSB_EXTIF_CTL                  0x0000
-#define  SSB_EXTIF_CTL_UARTEN          (1 << 0) /* UART enable */
-#define SSB_EXTIF_EXTSTAT              0x0004
-#define  SSB_EXTIF_EXTSTAT_EMODE       (1 << 0) /* Endian mode (ro) */
-#define  SSB_EXTIF_EXTSTAT_EIRQPIN     (1 << 1) /* External interrupt pin (ro) */
-#define  SSB_EXTIF_EXTSTAT_GPIOIRQPIN  (1 << 2) /* GPIO interrupt pin (ro) */
-#define SSB_EXTIF_PCMCIA_CFG           0x0010
-#define SSB_EXTIF_PCMCIA_MEMWAIT       0x0014
-#define SSB_EXTIF_PCMCIA_ATTRWAIT      0x0018
-#define SSB_EXTIF_PCMCIA_IOWAIT                0x001C
-#define SSB_EXTIF_PROG_CFG             0x0020
-#define SSB_EXTIF_PROG_WAITCNT         0x0024
-#define SSB_EXTIF_FLASH_CFG            0x0028
-#define SSB_EXTIF_FLASH_WAITCNT                0x002C
-#define SSB_EXTIF_WATCHDOG             0x0040
-#define SSB_EXTIF_CLOCK_N              0x0044
-#define SSB_EXTIF_CLOCK_SB             0x0048
-#define SSB_EXTIF_CLOCK_PCI            0x004C
-#define SSB_EXTIF_CLOCK_MII            0x0050
-#define SSB_EXTIF_GPIO_IN              0x0060
-#define SSB_EXTIF_GPIO_OUT_BASE                0x0064
-#define SSB_EXTIF_GPIO_OUTEN_BASE      0x0068
-#define SSB_EXTIF_EJTAG_OUTEN          0x0090
-#define SSB_EXTIF_GPIO_INTPOL          0x0094
-#define SSB_EXTIF_GPIO_INTMASK         0x0098
-#define SSB_EXTIF_UART_DATA            0x0300
-#define SSB_EXTIF_UART_TIMER           0x0310
-#define SSB_EXTIF_UART_FCR             0x0320
-#define SSB_EXTIF_UART_LCR             0x0330
-#define SSB_EXTIF_UART_MCR             0x0340
-#define SSB_EXTIF_UART_LSR             0x0350
-#define SSB_EXTIF_UART_MSR             0x0360
-#define SSB_EXTIF_UART_SCRATCH         0x0370
-
-
-
-
-/* pcmcia/prog/flash_config */
-#define        SSB_EXTCFG_EN                   (1 << 0)        /* enable */
-#define        SSB_EXTCFG_MODE                 0xE             /* mode */
-#define        SSB_EXTCFG_MODE_SHIFT           1
-#define         SSB_EXTCFG_MODE_FLASH          0x0             /* flash/asynchronous mode */
-#define         SSB_EXTCFG_MODE_SYNC           0x2             /* synchronous mode */
-#define         SSB_EXTCFG_MODE_PCMCIA         0x4             /* pcmcia mode */
-#define        SSB_EXTCFG_DS16                 (1 << 4)        /* destsize:  0=8bit, 1=16bit */
-#define        SSB_EXTCFG_BSWAP                (1 << 5)        /* byteswap */
-#define        SSB_EXTCFG_CLKDIV               0xC0            /* clock divider */
-#define        SSB_EXTCFG_CLKDIV_SHIFT         6
-#define         SSB_EXTCFG_CLKDIV_2            0x0             /* backplane/2 */
-#define         SSB_EXTCFG_CLKDIV_3            0x40            /* backplane/3 */
-#define         SSB_EXTCFG_CLKDIV_4            0x80            /* backplane/4 */
-#define        SSB_EXTCFG_CLKEN                (1 << 8)        /* clock enable */
-#define        SSB_EXTCFG_STROBE               (1 << 9)        /* size/bytestrobe (synch only) */
-
-/* pcmcia_memwait */
-#define        SSB_PCMCIA_MEMW_0               0x0000003F      /* waitcount0 */
-#define        SSB_PCMCIA_MEMW_1               0x00001F00      /* waitcount1 */
-#define        SSB_PCMCIA_MEMW_1_SHIFT         8
-#define        SSB_PCMCIA_MEMW_2               0x001F0000      /* waitcount2 */
-#define        SSB_PCMCIA_MEMW_2_SHIFT         16
-#define        SSB_PCMCIA_MEMW_3               0x1F000000      /* waitcount3 */
-#define        SSB_PCMCIA_MEMW_3_SHIFT         24
-
-/* pcmcia_attrwait */
-#define        SSB_PCMCIA_ATTW_0               0x0000003F      /* waitcount0 */
-#define        SSB_PCMCIA_ATTW_1               0x00001F00      /* waitcount1 */
-#define        SSB_PCMCIA_ATTW_1_SHIFT         8
-#define        SSB_PCMCIA_ATTW_2               0x001F0000      /* waitcount2 */
-#define        SSB_PCMCIA_ATTW_2_SHIFT         16
-#define        SSB_PCMCIA_ATTW_3               0x1F000000      /* waitcount3 */
-#define        SSB_PCMCIA_ATTW_3_SHIFT         24
-
-/* pcmcia_iowait */
-#define        SSB_PCMCIA_IOW_0                0x0000003F      /* waitcount0 */
-#define        SSB_PCMCIA_IOW_1                0x00001F00      /* waitcount1 */
-#define        SSB_PCMCIA_IOW_1_SHIFT          8
-#define        SSB_PCMCIA_IOW_2                0x001F0000      /* waitcount2 */
-#define        SSB_PCMCIA_IOW_2_SHIFT          16
-#define        SSB_PCMCIA_IOW_3                0x1F000000      /* waitcount3 */
-#define        SSB_PCMCIA_IOW_3_SHIFT          24
-
-/* prog_waitcount */
-#define        SSB_PROG_WCNT_0                 0x0000001F      /* waitcount0 */
-#define        SSB_PROG_WCNT_1                 0x00001F00      /* waitcount1 */
-#define        SSB_PROG_WCNT_1_SHIFT           8
-#define        SSB_PROG_WCNT_2                 0x001F0000      /* waitcount2 */
-#define        SSB_PROG_WCNT_2_SHIFT           16
-#define        SSB_PROG_WCNT_3                 0x1F000000      /* waitcount3 */
-#define        SSB_PROG_WCNT_3_SHIFT           24
-
-#define SSB_PROG_W0                    0x0000000C
-#define SSB_PROG_W1                    0x00000A00
-#define SSB_PROG_W2                    0x00020000
-#define SSB_PROG_W3                    0x01000000
-
-/* flash_waitcount */
-#define        SSB_FLASH_WCNT_0                0x0000001F      /* waitcount0 */
-#define        SSB_FLASH_WCNT_1                0x00001F00      /* waitcount1 */
-#define        SSB_FLASH_WCNT_1_SHIFT          8
-#define        SSB_FLASH_WCNT_2                0x001F0000      /* waitcount2 */
-#define        SSB_FLASH_WCNT_2_SHIFT          16
-#define        SSB_FLASH_WCNT_3                0x1F000000      /* waitcount3 */
-#define        SSB_FLASH_WCNT_3_SHIFT          24
-
-/* watchdog */
-#define SSB_EXTIF_WATCHDOG_CLK         48000000        /* Hz */
-
-
-
-#ifdef CONFIG_SSB_DRIVER_EXTIF
-
-struct ssb_extif {
-       struct ssb_device *dev;
-};
-
-static inline bool ssb_extif_available(struct ssb_extif *extif)
-{
-       return (extif->dev != NULL);
-}
-
-extern void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
-                                      u32 *plltype, u32 *n, u32 *m);
-
-extern void ssb_extif_timing_init(struct ssb_extif *extif,
-                                 unsigned long ns);
-
-u32 ssb_extif_gpio_in(struct ssb_extif *extif, u32 mask);
-
-void ssb_extif_gpio_out(struct ssb_extif *extif, u32 mask, u32 value);
-
-void ssb_extif_gpio_outen(struct ssb_extif *extif, u32 mask, u32 value);
-
-#ifdef CONFIG_SSB_SERIAL
-extern int ssb_extif_serial_init(struct ssb_extif *extif,
-                                struct ssb_serial_port *ports);
-#endif /* CONFIG_SSB_SERIAL */
-
-
-#else /* CONFIG_SSB_DRIVER_EXTIF */
-/* extif disabled */
-
-struct ssb_extif {
-};
-
-static inline bool ssb_extif_available(struct ssb_extif *extif)
-{
-       return 0;
-}
-
-static inline
-void ssb_extif_get_clockcontrol(struct ssb_extif *extif,
-                               u32 *plltype, u32 *n, u32 *m)
-{
-}
-
-#endif /* CONFIG_SSB_DRIVER_EXTIF */
-#endif /* LINUX_SSB_EXTIFCORE_H_ */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_mips.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_mips.h
deleted file mode 100644 (file)
index 5f44e97..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef LINUX_SSB_MIPSCORE_H_
-#define LINUX_SSB_MIPSCORE_H_
-
-#ifdef CONFIG_SSB_DRIVER_MIPS
-
-struct ssb_device;
-
-struct ssb_serial_port {
-       void *regs;
-       unsigned long clockspeed;
-       unsigned int irq;
-       unsigned int baud_base;
-       unsigned int reg_shift;
-};
-
-
-struct ssb_mipscore {
-       struct ssb_device *dev;
-
-       int nr_serial_ports;
-       struct ssb_serial_port serial_ports[4];
-
-       u8 flash_buswidth;
-       u32 flash_window;
-       u32 flash_window_size;
-};
-
-extern void ssb_mipscore_init(struct ssb_mipscore *mcore);
-extern u32 ssb_cpu_clock(struct ssb_mipscore *mcore);
-
-extern unsigned int ssb_mips_irq(struct ssb_device *dev);
-
-
-#else /* CONFIG_SSB_DRIVER_MIPS */
-
-struct ssb_mipscore {
-};
-
-static inline
-void ssb_mipscore_init(struct ssb_mipscore *mcore)
-{
-}
-
-#endif /* CONFIG_SSB_DRIVER_MIPS */
-
-#endif /* LINUX_SSB_MIPSCORE_H_ */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_pci.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb_driver_pci.h
deleted file mode 100644 (file)
index 9cfffb7..0000000
+++ /dev/null
@@ -1,106 +0,0 @@
-#ifndef LINUX_SSB_PCICORE_H_
-#define LINUX_SSB_PCICORE_H_
-
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-
-/* PCI core registers. */
-#define SSB_PCICORE_CTL                        0x0000  /* PCI Control */
-#define  SSB_PCICORE_CTL_RST_OE                0x00000001 /* PCI_RESET Output Enable */
-#define  SSB_PCICORE_CTL_RST           0x00000002 /* PCI_RESET driven out to pin */
-#define  SSB_PCICORE_CTL_CLK_OE                0x00000004 /* Clock gate Output Enable */
-#define  SSB_PCICORE_CTL_CLK           0x00000008 /* Gate for clock driven out to pin */
-#define SSB_PCICORE_ARBCTL             0x0010  /* PCI Arbiter Control */
-#define  SSB_PCICORE_ARBCTL_INTERN     0x00000001 /* Use internal arbiter */
-#define  SSB_PCICORE_ARBCTL_EXTERN     0x00000002 /* Use external arbiter */
-#define  SSB_PCICORE_ARBCTL_PARKID     0x00000006 /* Mask, selects which agent is parked on an idle bus */
-#define   SSB_PCICORE_ARBCTL_PARKID_LAST       0x00000000 /* Last requestor */
-#define   SSB_PCICORE_ARBCTL_PARKID_4710       0x00000002 /* 4710 */
-#define   SSB_PCICORE_ARBCTL_PARKID_EXT0       0x00000004 /* External requestor 0 */
-#define   SSB_PCICORE_ARBCTL_PARKID_EXT1       0x00000006 /* External requestor 1 */
-#define SSB_PCICORE_ISTAT              0x0020  /* Interrupt status */
-#define  SSB_PCICORE_ISTAT_INTA                0x00000001 /* PCI INTA# */
-#define  SSB_PCICORE_ISTAT_INTB                0x00000002 /* PCI INTB# */
-#define  SSB_PCICORE_ISTAT_SERR                0x00000004 /* PCI SERR# (write to clear) */
-#define  SSB_PCICORE_ISTAT_PERR                0x00000008 /* PCI PERR# (write to clear) */
-#define  SSB_PCICORE_ISTAT_PME         0x00000010 /* PCI PME# */
-#define SSB_PCICORE_IMASK              0x0024  /* Interrupt mask */
-#define  SSB_PCICORE_IMASK_INTA                0x00000001 /* PCI INTA# */
-#define  SSB_PCICORE_IMASK_INTB                0x00000002 /* PCI INTB# */
-#define  SSB_PCICORE_IMASK_SERR                0x00000004 /* PCI SERR# */
-#define  SSB_PCICORE_IMASK_PERR                0x00000008 /* PCI PERR# */
-#define  SSB_PCICORE_IMASK_PME         0x00000010 /* PCI PME# */
-#define SSB_PCICORE_MBOX               0x0028  /* Backplane to PCI Mailbox */
-#define  SSB_PCICORE_MBOX_F0_0         0x00000100 /* PCI function 0, INT 0 */
-#define  SSB_PCICORE_MBOX_F0_1         0x00000200 /* PCI function 0, INT 1 */
-#define  SSB_PCICORE_MBOX_F1_0         0x00000400 /* PCI function 1, INT 0 */
-#define  SSB_PCICORE_MBOX_F1_1         0x00000800 /* PCI function 1, INT 1 */
-#define  SSB_PCICORE_MBOX_F2_0         0x00001000 /* PCI function 2, INT 0 */
-#define  SSB_PCICORE_MBOX_F2_1         0x00002000 /* PCI function 2, INT 1 */
-#define  SSB_PCICORE_MBOX_F3_0         0x00004000 /* PCI function 3, INT 0 */
-#define  SSB_PCICORE_MBOX_F3_1         0x00008000 /* PCI function 3, INT 1 */
-#define SSB_PCICORE_BCAST_ADDR         0x0050  /* Backplane Broadcast Address */
-#define  SSB_PCICORE_BCAST_ADDR_MASK   0x000000FF
-#define SSB_PCICORE_BCAST_DATA         0x0054  /* Backplane Broadcast Data */
-#define SSB_PCICORE_GPIO_IN            0x0060  /* rev >= 2 only */
-#define SSB_PCICORE_GPIO_OUT           0x0064  /* rev >= 2 only */
-#define SSB_PCICORE_GPIO_ENABLE                0x0068  /* rev >= 2 only */
-#define SSB_PCICORE_GPIO_CTL           0x006C  /* rev >= 2 only */
-#define SSB_PCICORE_SBTOPCI0           0x0100  /* Backplane to PCI translation 0 (sbtopci0) */
-#define  SSB_PCICORE_SBTOPCI0_MASK     0xFC000000
-#define SSB_PCICORE_SBTOPCI1           0x0104  /* Backplane to PCI translation 1 (sbtopci1) */
-#define  SSB_PCICORE_SBTOPCI1_MASK     0xFC000000
-#define SSB_PCICORE_SBTOPCI2           0x0108  /* Backplane to PCI translation 2 (sbtopci2) */
-#define  SSB_PCICORE_SBTOPCI2_MASK     0xC0000000
-
-/* SBtoPCIx */
-#define SSB_PCICORE_SBTOPCI_MEM                0x00000000
-#define SSB_PCICORE_SBTOPCI_IO         0x00000001
-#define SSB_PCICORE_SBTOPCI_CFG0       0x00000002
-#define SSB_PCICORE_SBTOPCI_CFG1       0x00000003
-#define SSB_PCICORE_SBTOPCI_PREF       0x00000004 /* Prefetch enable */
-#define SSB_PCICORE_SBTOPCI_BURST      0x00000008 /* Burst enable */
-#define SSB_PCICORE_SBTOPCI_MRM                0x00000020 /* Memory Read Multiple */
-#define SSB_PCICORE_SBTOPCI_RC         0x00000030 /* Read Command mask (rev >= 11) */
-#define  SSB_PCICORE_SBTOPCI_RC_READ   0x00000000 /* Memory read */
-#define  SSB_PCICORE_SBTOPCI_RC_READL  0x00000010 /* Memory read line */
-#define  SSB_PCICORE_SBTOPCI_RC_READM  0x00000020 /* Memory read multiple */
-
-
-/* PCIcore specific boardflags */
-#define SSB_PCICORE_BFL_NOPCI          0x00000400 /* Board leaves PCI floating */
-
-
-struct ssb_pcicore {
-       struct ssb_device *dev;
-       u8 setup_done:1;
-       u8 hostmode:1;
-       u8 cardbusmode:1;
-};
-
-extern void ssb_pcicore_init(struct ssb_pcicore *pc);
-
-/* Enable IRQ routing for a specific device */
-extern int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
-                                         struct ssb_device *dev);
-
-
-#else /* CONFIG_SSB_DRIVER_PCICORE */
-
-
-struct ssb_pcicore {
-};
-
-static inline
-void ssb_pcicore_init(struct ssb_pcicore *pc)
-{
-}
-
-static inline
-int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
-                                  struct ssb_device *dev)
-{
-       return 0;
-}
-
-#endif /* CONFIG_SSB_DRIVER_PCICORE */
-#endif /* LINUX_SSB_PCICORE_H_ */
diff --git a/target/linux/generic-2.6/files/include/linux/ssb/ssb_regs.h b/target/linux/generic-2.6/files/include/linux/ssb/ssb_regs.h
deleted file mode 100644 (file)
index ebad0ba..0000000
+++ /dev/null
@@ -1,357 +0,0 @@
-#ifndef LINUX_SSB_REGS_H_
-#define LINUX_SSB_REGS_H_
-
-
-/* SiliconBackplane Address Map.
- * All regions may not exist on all chips.
- */
-#define SSB_SDRAM_BASE         0x00000000U     /* Physical SDRAM */
-#define SSB_PCI_MEM            0x08000000U     /* Host Mode sb2pcitranslation0 (64 MB) */
-#define SSB_PCI_CFG            0x0c000000U     /* Host Mode sb2pcitranslation1 (64 MB) */
-#define        SSB_SDRAM_SWAPPED       0x10000000U     /* Byteswapped Physical SDRAM */
-#define SSB_ENUM_BASE          0x18000000U     /* Enumeration space base */
-#define        SSB_ENUM_LIMIT          0x18010000U     /* Enumeration space limit */
-
-#define        SSB_FLASH2              0x1c000000U     /* Flash Region 2 (region 1 shadowed here) */
-#define        SSB_FLASH2_SZ           0x02000000U     /* Size of Flash Region 2 */
-
-#define        SSB_EXTIF_BASE          0x1f000000U     /* External Interface region base address */
-#define        SSB_FLASH1              0x1fc00000U     /* Flash Region 1 */
-#define        SSB_FLASH1_SZ           0x00400000U     /* Size of Flash Region 1 */
-
-#define SSB_PCI_DMA            0x40000000U     /* Client Mode sb2pcitranslation2 (1 GB) */
-#define SSB_PCI_DMA_SZ         0x40000000U     /* Client Mode sb2pcitranslation2 size in bytes */
-#define SSB_PCIE_DMA_L32       0x00000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), low 32 bits */
-#define SSB_PCIE_DMA_H32       0x80000000U     /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), high 32 bits */
-#define        SSB_EUART               (SSB_EXTIF_BASE + 0x00800000)
-#define        SSB_LED                 (SSB_EXTIF_BASE + 0x00900000)
-
-
-/* Enumeration space constants */
-#define SSB_CORE_SIZE          0x1000  /* Size of a core MMIO area */
-#define SSB_MAX_NR_CORES       ((SSB_ENUM_LIMIT - SSB_ENUM_BASE) / SSB_CORE_SIZE)
-
-
-/* mips address */
-#define        SSB_EJTAG               0xff200000      /* MIPS EJTAG space (2M) */
-
-
-/* SSB PCI config space registers. */
-#define SSB_PMCSR              0x44
-#define  SSB_PE                        0x100
-#define        SSB_BAR0_WIN            0x80    /* Backplane address space 0 */
-#define        SSB_BAR1_WIN            0x84    /* Backplane address space 1 */
-#define        SSB_SPROMCTL            0x88    /* SPROM control */
-#define  SSB_SPROMCTL_WE       0x10    /* SPROM write enable */
-#define        SSB_BAR1_CONTROL        0x8c    /* Address space 1 burst control */
-#define SSB_PCI_IRQS           0x90    /* PCI interrupts */
-#define SSB_PCI_IRQMASK                0x94    /* PCI IRQ control and mask (pcirev >= 6 only) */
-#define SSB_BACKPLANE_IRQS     0x98    /* Backplane Interrupts */
-#define SSB_GPIO_IN            0xB0    /* GPIO Input (pcirev >= 3 only) */
-#define SSB_GPIO_OUT           0xB4    /* GPIO Output (pcirev >= 3 only) */
-#define SSB_GPIO_OUT_ENABLE    0xB8    /* GPIO Output Enable/Disable (pcirev >= 3 only) */
-#define  SSB_GPIO_SCS          0x10    /* PCI config space bit 4 for 4306c0 slow clock source */
-#define  SSB_GPIO_HWRAD                0x20    /* PCI config space GPIO 13 for hw radio disable */
-#define  SSB_GPIO_XTAL         0x40    /* PCI config space GPIO 14 for Xtal powerup */
-#define  SSB_GPIO_PLL          0x80    /* PCI config space GPIO 15 for PLL powerdown */
-
-
-#define SSB_BAR0_MAX_RETRIES   50
-
-/* Silicon backplane configuration register definitions */
-#define SSB_IPSFLAG            0x0F08
-#define         SSB_IPSFLAG_IRQ1       0x0000003F /* which sbflags get routed to mips interrupt 1 */
-#define         SSB_IPSFLAG_IRQ1_SHIFT 0
-#define         SSB_IPSFLAG_IRQ2       0x00003F00 /* which sbflags get routed to mips interrupt 2 */
-#define         SSB_IPSFLAG_IRQ2_SHIFT 8
-#define         SSB_IPSFLAG_IRQ3       0x003F0000 /* which sbflags get routed to mips interrupt 3 */
-#define         SSB_IPSFLAG_IRQ3_SHIFT 16
-#define         SSB_IPSFLAG_IRQ4       0x3F000000 /* which sbflags get routed to mips interrupt 4 */
-#define         SSB_IPSFLAG_IRQ4_SHIFT 24
-#define SSB_TPSFLAG            0x0F18
-#define  SSB_TPSFLAG_BPFLAG    0x0000003F /* Backplane flag # */
-#define  SSB_TPSFLAG_ALWAYSIRQ 0x00000040 /* IRQ is always sent on the Backplane */
-#define SSB_TMERRLOGA          0x0F48
-#define SSB_TMERRLOG           0x0F50
-#define SSB_ADMATCH3           0x0F60
-#define SSB_ADMATCH2           0x0F68
-#define SSB_ADMATCH1           0x0F70
-#define SSB_IMSTATE            0x0F90     /* SB Initiator Agent State */
-#define  SSB_IMSTATE_PC                0x0000000f /* Pipe Count */
-#define  SSB_IMSTATE_AP_MASK   0x00000030 /* Arbitration Priority */
-#define  SSB_IMSTATE_AP_BOTH   0x00000000 /* Use both timeslices and token */
-#define  SSB_IMSTATE_AP_TS     0x00000010 /* Use timeslices only */
-#define  SSB_IMSTATE_AP_TK     0x00000020 /* Use token only */
-#define  SSB_IMSTATE_AP_RSV    0x00000030 /* Reserved */
-#define  SSB_IMSTATE_IBE       0x00020000 /* In Band Error */
-#define  SSB_IMSTATE_TO                0x00040000 /* Timeout */
-#define SSB_INTVEC             0x0F94     /* SB Interrupt Mask */
-#define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */
-#define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */
-#define  SSB_INTVEC_ILINE20    0x00000004 /* Enable interrupts for iline20 */
-#define  SSB_INTVEC_CODEC      0x00000008 /* Enable interrupts for v90 codec */
-#define  SSB_INTVEC_USB                0x00000010 /* Enable interrupts for usb */
-#define  SSB_INTVEC_EXTIF      0x00000020 /* Enable interrupts for external i/f */
-#define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */
-#define SSB_TMSLOW             0x0F98     /* SB Target State Low */
-#define  SSB_TMSLOW_RESET      0x00000001 /* Reset */
-#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */
-#define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */
-#define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */
-#define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */
-#define  SSB_TMSLOW_PE         0x40000000 /* Power Management Enable */
-#define  SSB_TMSLOW_BE         0x80000000 /* BIST Enable */
-#define SSB_TMSHIGH            0x0F9C     /* SB Target State High */
-#define  SSB_TMSHIGH_SERR      0x00000001 /* S-error */
-#define  SSB_TMSHIGH_INT       0x00000002 /* Interrupt */
-#define  SSB_TMSHIGH_BUSY      0x00000004 /* Busy */
-#define  SSB_TMSHIGH_TO                0x00000020 /* Timeout. Backplane rev >= 2.3 only */
-#define  SSB_TMSHIGH_COREFL    0x1FFF0000 /* Core specific flags */
-#define  SSB_TMSHIGH_COREFL_SHIFT      16
-#define  SSB_TMSHIGH_DMA64     0x10000000 /* 64bit DMA supported */
-#define  SSB_TMSHIGH_GCR       0x20000000 /* Gated Clock Request */
-#define  SSB_TMSHIGH_BISTF     0x40000000 /* BIST Failed */
-#define  SSB_TMSHIGH_BISTD     0x80000000 /* BIST Done */
-#define SSB_BWA0               0x0FA0
-#define SSB_IMCFGLO            0x0FA8
-#define  SSB_IMCFGLO_SERTO     0x00000007 /* Service timeout */
-#define  SSB_IMCFGLO_REQTO     0x00000070 /* Request timeout */
-#define  SSB_IMCFGLO_REQTO_SHIFT       4
-#define  SSB_IMCFGLO_CONNID    0x00FF0000 /* Connection ID */
-#define  SSB_IMCFGLO_CONNID_SHIFT      16
-#define SSB_IMCFGHI            0x0FAC
-#define SSB_ADMATCH0           0x0FB0
-#define SSB_TMCFGLO            0x0FB8
-#define SSB_TMCFGHI            0x0FBC
-#define SSB_BCONFIG            0x0FC0
-#define SSB_BSTATE             0x0FC8
-#define SSB_ACTCFG             0x0FD8
-#define SSB_FLAGST             0x0FE8
-#define SSB_IDLOW              0x0FF8
-#define  SSB_IDLOW_CFGSP       0x00000003 /* Config Space */
-#define  SSB_IDLOW_ADDRNGE     0x00000038 /* Address Ranges supported */
-#define  SSB_IDLOW_ADDRNGE_SHIFT       3
-#define  SSB_IDLOW_SYNC                0x00000040
-#define  SSB_IDLOW_INITIATOR   0x00000080
-#define  SSB_IDLOW_MIBL                0x00000F00 /* Minimum Backplane latency */
-#define  SSB_IDLOW_MIBL_SHIFT  8
-#define  SSB_IDLOW_MABL                0x0000F000 /* Maximum Backplane latency */
-#define  SSB_IDLOW_MABL_SHIFT  12
-#define  SSB_IDLOW_TIF         0x00010000 /* This Initiator is first */
-#define  SSB_IDLOW_CCW         0x000C0000 /* Cycle counter width */
-#define  SSB_IDLOW_CCW_SHIFT   18
-#define  SSB_IDLOW_TPT         0x00F00000 /* Target ports */
-#define  SSB_IDLOW_TPT_SHIFT   20
-#define  SSB_IDLOW_INITP       0x0F000000 /* Initiator ports */
-#define  SSB_IDLOW_INITP_SHIFT 24
-#define  SSB_IDLOW_SSBREV      0xF0000000 /* Sonics Backplane Revision code */
-#define  SSB_IDLOW_SSBREV_22   0x00000000 /* <= 2.2 */
-#define  SSB_IDLOW_SSBREV_23   0x10000000 /* 2.3 */
-#define  SSB_IDLOW_SSBREV_24   0x40000000 /* ?? Found in BCM4328 */
-#define  SSB_IDLOW_SSBREV_25   0x50000000 /* ?? Not Found yet */
-#define  SSB_IDLOW_SSBREV_26   0x60000000 /* ?? Found in some BCM4311/2 */
-#define  SSB_IDLOW_SSBREV_27   0x70000000 /* ?? Found in some BCM4311/2 */
-#define SSB_IDHIGH             0x0FFC     /* SB Identification High */
-#define  SSB_IDHIGH_RCLO       0x0000000F /* Revision Code (low part) */
-#define  SSB_IDHIGH_CC         0x00008FF0 /* Core Code */
-#define  SSB_IDHIGH_CC_SHIFT   4
-#define  SSB_IDHIGH_RCHI       0x00007000 /* Revision Code (high part) */
-#define  SSB_IDHIGH_RCHI_SHIFT 8          /* yes, shift 8 is right */
-#define  SSB_IDHIGH_VC         0xFFFF0000 /* Vendor Code */
-#define  SSB_IDHIGH_VC_SHIFT   16
-
-/* SPROM shadow area. If not otherwise noted, fields are
- * two bytes wide. Note that the SPROM can _only_ be read
- * in two-byte quantinies.
- */
-#define SSB_SPROMSIZE_WORDS            64
-#define SSB_SPROMSIZE_BYTES            (SSB_SPROMSIZE_WORDS * sizeof(u16))
-#define SSB_SPROMSIZE_WORDS_R123       64
-#define SSB_SPROMSIZE_WORDS_R4         220
-#define SSB_SPROMSIZE_BYTES_R123       (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
-#define SSB_SPROMSIZE_BYTES_R4         (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
-#define SSB_SPROM_BASE                 0x1000
-#define SSB_SPROM_REVISION             0x107E
-#define  SSB_SPROM_REVISION_REV                0x00FF  /* SPROM Revision number */
-#define  SSB_SPROM_REVISION_CRC                0xFF00  /* SPROM CRC8 value */
-#define  SSB_SPROM_REVISION_CRC_SHIFT  8
-
-/* SPROM Revision 1 */
-#define SSB_SPROM1_SPID                        0x1004  /* Subsystem Product ID for PCI */
-#define SSB_SPROM1_SVID                        0x1006  /* Subsystem Vendor ID for PCI */
-#define SSB_SPROM1_PID                 0x1008  /* Product ID for PCI */
-#define SSB_SPROM1_IL0MAC              0x1048  /* 6 bytes MAC address for 802.11b/g */
-#define SSB_SPROM1_ET0MAC              0x104E  /* 6 bytes MAC address for Ethernet */
-#define SSB_SPROM1_ET1MAC              0x1054  /* 6 bytes MAC address for 802.11a */
-#define SSB_SPROM1_ETHPHY              0x105A  /* Ethernet PHY settings */
-#define  SSB_SPROM1_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */
-#define  SSB_SPROM1_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */
-#define  SSB_SPROM1_ETHPHY_ET1A_SHIFT  5
-#define  SSB_SPROM1_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */
-#define  SSB_SPROM1_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */
-#define SSB_SPROM1_BINF                        0x105C  /* Board info */
-#define  SSB_SPROM1_BINF_BREV          0x00FF  /* Board Revision */
-#define  SSB_SPROM1_BINF_CCODE         0x0F00  /* Country Code */
-#define  SSB_SPROM1_BINF_CCODE_SHIFT   8
-#define  SSB_SPROM1_BINF_ANTBG         0x3000  /* Available B-PHY and G-PHY antennas */
-#define  SSB_SPROM1_BINF_ANTBG_SHIFT   12
-#define  SSB_SPROM1_BINF_ANTA          0xC000  /* Available A-PHY antennas */
-#define  SSB_SPROM1_BINF_ANTA_SHIFT    14
-#define SSB_SPROM1_PA0B0               0x105E
-#define SSB_SPROM1_PA0B1               0x1060
-#define SSB_SPROM1_PA0B2               0x1062
-#define SSB_SPROM1_GPIOA               0x1064  /* General Purpose IO pins 0 and 1 */
-#define  SSB_SPROM1_GPIOA_P0           0x00FF  /* Pin 0 */
-#define  SSB_SPROM1_GPIOA_P1           0xFF00  /* Pin 1 */
-#define  SSB_SPROM1_GPIOA_P1_SHIFT     8
-#define SSB_SPROM1_GPIOB               0x1066  /* General Purpuse IO pins 2 and 3 */
-#define  SSB_SPROM1_GPIOB_P2           0x00FF  /* Pin 2 */
-#define  SSB_SPROM1_GPIOB_P3           0xFF00  /* Pin 3 */
-#define  SSB_SPROM1_GPIOB_P3_SHIFT     8
-#define SSB_SPROM1_MAXPWR              0x1068  /* Power Amplifier Max Power */
-#define  SSB_SPROM1_MAXPWR_BG          0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */
-#define  SSB_SPROM1_MAXPWR_A           0xFF00  /* A-PHY (in dBm Q5.2) */
-#define  SSB_SPROM1_MAXPWR_A_SHIFT     8
-#define SSB_SPROM1_PA1B0               0x106A
-#define SSB_SPROM1_PA1B1               0x106C
-#define SSB_SPROM1_PA1B2               0x106E
-#define SSB_SPROM1_ITSSI               0x1070  /* Idle TSSI Target */
-#define  SSB_SPROM1_ITSSI_BG           0x00FF  /* B-PHY and G-PHY*/
-#define  SSB_SPROM1_ITSSI_A            0xFF00  /* A-PHY */
-#define  SSB_SPROM1_ITSSI_A_SHIFT      8
-#define SSB_SPROM1_BFLLO               0x1072  /* Boardflags (low 16 bits) */
-#define SSB_SPROM1_AGAIN               0x1074  /* Antenna Gain (in dBm Q5.2) */
-#define  SSB_SPROM1_AGAIN_BG           0x00FF  /* B-PHY and G-PHY */
-#define  SSB_SPROM1_AGAIN_BG_SHIFT     0
-#define  SSB_SPROM1_AGAIN_A            0xFF00  /* A-PHY */
-#define  SSB_SPROM1_AGAIN_A_SHIFT      8
-
-/* SPROM Revision 2 (inherits from rev 1) */
-#define SSB_SPROM2_BFLHI               0x1038  /* Boardflags (high 16 bits) */
-#define SSB_SPROM2_MAXP_A              0x103A  /* A-PHY Max Power */
-#define  SSB_SPROM2_MAXP_A_HI          0x00FF  /* Max Power High */
-#define  SSB_SPROM2_MAXP_A_LO          0xFF00  /* Max Power Low */
-#define  SSB_SPROM2_MAXP_A_LO_SHIFT    8
-#define SSB_SPROM2_PA1LOB0             0x103C  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1LOB1             0x103E  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1LOB2             0x1040  /* A-PHY PowerAmplifier Low Settings */
-#define SSB_SPROM2_PA1HIB0             0x1042  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_PA1HIB1             0x1044  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_PA1HIB2             0x1046  /* A-PHY PowerAmplifier High Settings */
-#define SSB_SPROM2_OPO                 0x1078  /* OFDM Power Offset from CCK Level */
-#define  SSB_SPROM2_OPO_VALUE          0x00FF
-#define  SSB_SPROM2_OPO_UNUSED         0xFF00
-#define SSB_SPROM2_CCODE               0x107C  /* Two char Country Code */
-
-/* SPROM Revision 3 (inherits most data from rev 2) */
-#define SSB_SPROM3_IL0MAC              0x104A  /* 6 bytes MAC address for 802.11b/g */
-#define SSB_SPROM3_ET0MAC              0x1050  /* 6 bytes MAC address for Ethernet ?? */
-#define SSB_SPROM3_ET1MAC              0x1050  /* 6 bytes MAC address for 802.11a ?? */
-#define SSB_SPROM3_OFDMAPO             0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_OFDMALPO            0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_OFDMAHPO            0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */
-#define SSB_SPROM3_GPIOLDC             0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */
-#define  SSB_SPROM3_GPIOLDC_OFF                0x0000FF00      /* Off Count */
-#define  SSB_SPROM3_GPIOLDC_OFF_SHIFT  8
-#define  SSB_SPROM3_GPIOLDC_ON         0x00FF0000      /* On Count */
-#define  SSB_SPROM3_GPIOLDC_ON_SHIFT   16
-#define SSB_SPROM3_CCKPO               0x1078  /* CCK Power Offset */
-#define  SSB_SPROM3_CCKPO_1M           0x000F  /* 1M Rate PO */
-#define  SSB_SPROM3_CCKPO_2M           0x00F0  /* 2M Rate PO */
-#define  SSB_SPROM3_CCKPO_2M_SHIFT     4
-#define  SSB_SPROM3_CCKPO_55M          0x0F00  /* 5.5M Rate PO */
-#define  SSB_SPROM3_CCKPO_55M_SHIFT    8
-#define  SSB_SPROM3_CCKPO_11M          0xF000  /* 11M Rate PO */
-#define  SSB_SPROM3_CCKPO_11M_SHIFT    12
-#define  SSB_SPROM3_OFDMGPO            0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */
-
-/* SPROM Revision 4 */
-#define SSB_SPROM4_IL0MAC              0x104C  /* 6 byte MAC address for a/b/g/n */
-#define SSB_SPROM4_ET0MAC              0x1018  /* 6 bytes MAC address for Ethernet ?? */
-#define SSB_SPROM4_ET1MAC              0x1018  /* 6 bytes MAC address for 802.11a ?? */
-#define SSB_SPROM4_ETHPHY              0x105A  /* Ethernet PHY settings ?? */
-#define  SSB_SPROM4_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */
-#define  SSB_SPROM4_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */
-#define  SSB_SPROM4_ETHPHY_ET1A_SHIFT  5
-#define  SSB_SPROM4_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */
-#define  SSB_SPROM4_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */
-#define SSB_SPROM4_CCODE               0x1052  /* Country Code (2 bytes) */
-#define SSB_SPROM4_ANTAVAIL            0x105D  /* Antenna available bitfields */
-#define SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */
-#define SSB_SPROM4_ANTAVAIL_A_SHIFT    0
-#define SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */
-#define SSB_SPROM4_ANTAVAIL_BG_SHIFT   8
-#define SSB_SPROM4_BFLLO               0x1044  /* Boardflags (low 16 bits) */
-#define SSB_SPROM4_AGAIN01             0x105E  /* Antenna Gain (in dBm Q5.2) */
-#define  SSB_SPROM4_AGAIN0             0x00FF  /* Antenna 0 */
-#define  SSB_SPROM4_AGAIN0_SHIFT       0
-#define  SSB_SPROM4_AGAIN1             0xFF00  /* Antenna 1 */
-#define  SSB_SPROM4_AGAIN1_SHIFT       8
-#define SSB_SPROM4_AGAIN23             0x1060
-#define  SSB_SPROM4_AGAIN2             0x00FF  /* Antenna 2 */
-#define  SSB_SPROM4_AGAIN2_SHIFT       0
-#define  SSB_SPROM4_AGAIN3             0xFF00  /* Antenna 3 */
-#define  SSB_SPROM4_AGAIN3_SHIFT       8
-#define SSB_SPROM4_BFLHI               0x1046  /* Board Flags Hi */
-#define SSB_SPROM4_MAXP_BG             0x1080  /* Max Power BG in path 1 */
-#define  SSB_SPROM4_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */
-#define  SSB_SPROM4_ITSSI_BG           0xFF00  /* Mask for path 1 itssi_bg */
-#define  SSB_SPROM4_ITSSI_BG_SHIFT     8
-#define SSB_SPROM4_MAXP_A              0x108A  /* Max Power A in path 1 */
-#define  SSB_SPROM4_MAXP_A_MASK                0x00FF  /* Mask for Max Power A */
-#define  SSB_SPROM4_ITSSI_A            0xFF00  /* Mask for path 1 itssi_a */
-#define  SSB_SPROM4_ITSSI_A_SHIFT      8
-#define SSB_SPROM4_GPIOA               0x1056  /* Gen. Purpose IO # 0 and 1 */
-#define  SSB_SPROM4_GPIOA_P0           0x00FF  /* Pin 0 */
-#define  SSB_SPROM4_GPIOA_P1           0xFF00  /* Pin 1 */
-#define  SSB_SPROM4_GPIOA_P1_SHIFT     8
-#define SSB_SPROM4_GPIOB               0x1058  /* Gen. Purpose IO # 2 and 3 */
-#define  SSB_SPROM4_GPIOB_P2           0x00FF  /* Pin 2 */
-#define  SSB_SPROM4_GPIOB_P3           0xFF00  /* Pin 3 */
-#define  SSB_SPROM4_GPIOB_P3_SHIFT     8
-#define SSB_SPROM4_PA0B0               0x1082  /* The paXbY locations are */
-#define SSB_SPROM4_PA0B1               0x1084  /*   only guesses */
-#define SSB_SPROM4_PA0B2               0x1086
-#define SSB_SPROM4_PA1B0               0x108E
-#define SSB_SPROM4_PA1B1               0x1090
-#define SSB_SPROM4_PA1B2               0x1092
-
-/* Values for SSB_SPROM1_BINF_CCODE */
-enum {
-       SSB_SPROM1CCODE_WORLD = 0,
-       SSB_SPROM1CCODE_THAILAND,
-       SSB_SPROM1CCODE_ISRAEL,
-       SSB_SPROM1CCODE_JORDAN,
-       SSB_SPROM1CCODE_CHINA,
-       SSB_SPROM1CCODE_JAPAN,
-       SSB_SPROM1CCODE_USA_CANADA_ANZ,
-       SSB_SPROM1CCODE_EUROPE,
-       SSB_SPROM1CCODE_USA_LOW,
-       SSB_SPROM1CCODE_JAPAN_HIGH,
-       SSB_SPROM1CCODE_ALL,
-       SSB_SPROM1CCODE_NONE,
-};
-
-/* Address-Match values and masks (SSB_ADMATCHxxx) */
-#define SSB_ADM_TYPE                   0x00000003      /* Address type */
-#define  SSB_ADM_TYPE0                 0
-#define  SSB_ADM_TYPE1                 1
-#define  SSB_ADM_TYPE2                 2
-#define SSB_ADM_AD64                   0x00000004
-#define SSB_ADM_SZ0                    0x000000F8      /* Type0 size */
-#define SSB_ADM_SZ0_SHIFT              3
-#define SSB_ADM_SZ1                    0x000001F8      /* Type1 size */
-#define SSB_ADM_SZ1_SHIFT              3
-#define SSB_ADM_SZ2                    0x000001F8      /* Type2 size */
-#define SSB_ADM_SZ2_SHIFT              3
-#define SSB_ADM_EN                     0x00000400      /* Enable */
-#define SSB_ADM_NEG                    0x00000800      /* Negative decode */
-#define SSB_ADM_BASE0                  0xFFFFFF00      /* Type0 base address */
-#define SSB_ADM_BASE0_SHIFT            8
-#define SSB_ADM_BASE1                  0xFFFFF000      /* Type1 base address for the core */
-#define SSB_ADM_BASE1_SHIFT            12
-#define SSB_ADM_BASE2                  0xFFFF0000      /* Type2 base address for the core */
-#define SSB_ADM_BASE2_SHIFT            16
-
-
-#endif /* LINUX_SSB_REGS_H_ */