UBI: Add basic UBI support to U-Boot (Part 1/8)
authorKyungmin Park <kyungmin.park@samsung.com>
Wed, 19 Nov 2008 15:23:06 +0000 (16:23 +0100)
committerStefan Roese <sr@denx.de>
Wed, 19 Nov 2008 19:34:39 +0000 (20:34 +0100)
This patch adds basic UBI (Unsorted Block Image) support to U-Boot.
It's based on the Linux UBI version and basically has a "OS"
translation wrapper that defines most Linux specific calls
(spin_lock() etc.) into no-ops. Some source code parts have been
uncommented by "#ifdef UBI_LINUX". This makes it easier to compare
this version with the Linux version and simplifies future UBI
ports/bug-fixes from the Linux version.

Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
Signed-off-by: Stefan Roese <sr@denx.de>
drivers/mtd/ubi/Makefile [new file with mode: 0644]
drivers/mtd/ubi/build.c [new file with mode: 0644]
drivers/mtd/ubi/crc32.c [new file with mode: 0644]

diff --git a/drivers/mtd/ubi/Makefile b/drivers/mtd/ubi/Makefile
new file mode 100644 (file)
index 0000000..8bd82c3
--- /dev/null
@@ -0,0 +1,51 @@
+#
+# (C) Copyright 2006
+# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+#
+# See file CREDITS for list of people who contributed to this
+# project.
+#
+# 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,
+# MA 02111-1307 USA
+#
+
+include $(TOPDIR)/config.mk
+
+LIB    := $(obj)libubi.a
+
+ifdef CONFIG_CMD_UBI
+COBJS-y += build.o vtbl.o vmt.o upd.o kapi.o eba.o io.o wl.o scan.o crc32.o
+
+COBJS-y += misc.o
+COBJS-y += debug.o
+endif
+
+COBJS  := $(COBJS-y)
+SRCS   := $(COBJS:.o=.c)
+OBJS   := $(addprefix $(obj),$(COBJS))
+
+all:   $(LIB)
+
+$(LIB):        $(obj).depend $(OBJS)
+       $(AR) $(ARFLAGS) $@ $(OBJS)
+
+#########################################################################
+
+# defines $(obj).depend target
+include $(SRCTREE)/rules.mk
+
+sinclude $(obj).depend
+
+#########################################################################
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
new file mode 100644 (file)
index 0000000..17cabb2
--- /dev/null
@@ -0,0 +1,1186 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ * Copyright (c) Nokia Corporation, 2007
+ *
+ * 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, MA 02111-1307 USA
+ *
+ * Author: Artem Bityutskiy (Битюцкий Артём),
+ *         Frank Haverkamp
+ */
+
+/*
+ * This file includes UBI initialization and building of UBI devices.
+ *
+ * When UBI is initialized, it attaches all the MTD devices specified as the
+ * module load parameters or the kernel boot parameters. If MTD devices were
+ * specified, UBI does not attach any MTD device, but it is possible to do
+ * later using the "UBI control device".
+ *
+ * At the moment we only attach UBI devices by scanning, which will become a
+ * bottleneck when flashes reach certain large size. Then one may improve UBI
+ * and add other methods, although it does not seem to be easy to do.
+ */
+
+#ifdef UBI_LINUX
+#include <linux/err.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/stringify.h>
+#include <linux/stat.h>
+#include <linux/miscdevice.h>
+#include <linux/log2.h>
+#include <linux/kthread.h>
+#endif
+#include <ubi_uboot.h>
+#include "ubi.h"
+
+/* Maximum length of the 'mtd=' parameter */
+#define MTD_PARAM_LEN_MAX 64
+
+/**
+ * struct mtd_dev_param - MTD device parameter description data structure.
+ * @name: MTD device name or number string
+ * @vid_hdr_offs: VID header offset
+ */
+struct mtd_dev_param
+{
+       char name[MTD_PARAM_LEN_MAX];
+       int vid_hdr_offs;
+};
+
+/* Numbers of elements set in the @mtd_dev_param array */
+static int mtd_devs = 0;
+
+/* MTD devices specification parameters */
+static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
+
+/* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
+struct class *ubi_class;
+
+#ifdef UBI_LINUX
+/* Slab cache for wear-leveling entries */
+struct kmem_cache *ubi_wl_entry_slab;
+
+/* UBI control character device */
+static struct miscdevice ubi_ctrl_cdev = {
+       .minor = MISC_DYNAMIC_MINOR,
+       .name = "ubi_ctrl",
+       .fops = &ubi_ctrl_cdev_operations,
+};
+#endif
+
+/* All UBI devices in system */
+struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
+
+#ifdef UBI_LINUX
+/* Serializes UBI devices creations and removals */
+DEFINE_MUTEX(ubi_devices_mutex);
+
+/* Protects @ubi_devices and @ubi->ref_count */
+static DEFINE_SPINLOCK(ubi_devices_lock);
+
+/* "Show" method for files in '/<sysfs>/class/ubi/' */
+static ssize_t ubi_version_show(struct class *class, char *buf)
+{
+       return sprintf(buf, "%d\n", UBI_VERSION);
+}
+
+/* UBI version attribute ('/<sysfs>/class/ubi/version') */
+static struct class_attribute ubi_version =
+       __ATTR(version, S_IRUGO, ubi_version_show, NULL);
+
+static ssize_t dev_attribute_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf);
+
+/* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
+static struct device_attribute dev_eraseblock_size =
+       __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_avail_eraseblocks =
+       __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_total_eraseblocks =
+       __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_volumes_count =
+       __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_max_ec =
+       __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_reserved_for_bad =
+       __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_bad_peb_count =
+       __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_max_vol_count =
+       __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_min_io_size =
+       __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_bgt_enabled =
+       __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
+static struct device_attribute dev_mtd_num =
+       __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL);
+#endif
+
+/**
+ * ubi_get_device - get UBI device.
+ * @ubi_num: UBI device number
+ *
+ * This function returns UBI device description object for UBI device number
+ * @ubi_num, or %NULL if the device does not exist. This function increases the
+ * device reference count to prevent removal of the device. In other words, the
+ * device cannot be removed if its reference count is not zero.
+ */
+struct ubi_device *ubi_get_device(int ubi_num)
+{
+       struct ubi_device *ubi;
+
+       spin_lock(&ubi_devices_lock);
+       ubi = ubi_devices[ubi_num];
+       if (ubi) {
+               ubi_assert(ubi->ref_count >= 0);
+               ubi->ref_count += 1;
+               get_device(&ubi->dev);
+       }
+       spin_unlock(&ubi_devices_lock);
+
+       return ubi;
+}
+
+/**
+ * ubi_put_device - drop an UBI device reference.
+ * @ubi: UBI device description object
+ */
+void ubi_put_device(struct ubi_device *ubi)
+{
+       spin_lock(&ubi_devices_lock);
+       ubi->ref_count -= 1;
+       put_device(&ubi->dev);
+       spin_unlock(&ubi_devices_lock);
+}
+
+/**
+ * ubi_get_by_major - get UBI device description object by character device
+ *                    major number.
+ * @major: major number
+ *
+ * This function is similar to 'ubi_get_device()', but it searches the device
+ * by its major number.
+ */
+struct ubi_device *ubi_get_by_major(int major)
+{
+       int i;
+       struct ubi_device *ubi;
+
+       spin_lock(&ubi_devices_lock);
+       for (i = 0; i < UBI_MAX_DEVICES; i++) {
+               ubi = ubi_devices[i];
+               if (ubi && MAJOR(ubi->cdev.dev) == major) {
+                       ubi_assert(ubi->ref_count >= 0);
+                       ubi->ref_count += 1;
+                       get_device(&ubi->dev);
+                       spin_unlock(&ubi_devices_lock);
+                       return ubi;
+               }
+       }
+       spin_unlock(&ubi_devices_lock);
+
+       return NULL;
+}
+
+/**
+ * ubi_major2num - get UBI device number by character device major number.
+ * @major: major number
+ *
+ * This function searches UBI device number object by its major number. If UBI
+ * device was not found, this function returns -ENODEV, otherwise the UBI device
+ * number is returned.
+ */
+int ubi_major2num(int major)
+{
+       int i, ubi_num = -ENODEV;
+
+       spin_lock(&ubi_devices_lock);
+       for (i = 0; i < UBI_MAX_DEVICES; i++) {
+               struct ubi_device *ubi = ubi_devices[i];
+
+               if (ubi && MAJOR(ubi->cdev.dev) == major) {
+                       ubi_num = ubi->ubi_num;
+                       break;
+               }
+       }
+       spin_unlock(&ubi_devices_lock);
+
+       return ubi_num;
+}
+
+#ifdef UBI_LINUX
+/* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
+static ssize_t dev_attribute_show(struct device *dev,
+                                 struct device_attribute *attr, char *buf)
+{
+       ssize_t ret;
+       struct ubi_device *ubi;
+
+       /*
+        * The below code looks weird, but it actually makes sense. We get the
+        * UBI device reference from the contained 'struct ubi_device'. But it
+        * is unclear if the device was removed or not yet. Indeed, if the
+        * device was removed before we increased its reference count,
+        * 'ubi_get_device()' will return -ENODEV and we fail.
+        *
+        * Remember, 'struct ubi_device' is freed in the release function, so
+        * we still can use 'ubi->ubi_num'.
+        */
+       ubi = container_of(dev, struct ubi_device, dev);
+       ubi = ubi_get_device(ubi->ubi_num);
+       if (!ubi)
+               return -ENODEV;
+
+       if (attr == &dev_eraseblock_size)
+               ret = sprintf(buf, "%d\n", ubi->leb_size);
+       else if (attr == &dev_avail_eraseblocks)
+               ret = sprintf(buf, "%d\n", ubi->avail_pebs);
+       else if (attr == &dev_total_eraseblocks)
+               ret = sprintf(buf, "%d\n", ubi->good_peb_count);
+       else if (attr == &dev_volumes_count)
+               ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
+       else if (attr == &dev_max_ec)
+               ret = sprintf(buf, "%d\n", ubi->max_ec);
+       else if (attr == &dev_reserved_for_bad)
+               ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
+       else if (attr == &dev_bad_peb_count)
+               ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
+       else if (attr == &dev_max_vol_count)
+               ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
+       else if (attr == &dev_min_io_size)
+               ret = sprintf(buf, "%d\n", ubi->min_io_size);
+       else if (attr == &dev_bgt_enabled)
+               ret = sprintf(buf, "%d\n", ubi->thread_enabled);
+       else if (attr == &dev_mtd_num)
+               ret = sprintf(buf, "%d\n", ubi->mtd->index);
+       else
+               ret = -EINVAL;
+
+       ubi_put_device(ubi);
+       return ret;
+}
+
+/* Fake "release" method for UBI devices */
+static void dev_release(struct device *dev) { }
+
+/**
+ * ubi_sysfs_init - initialize sysfs for an UBI device.
+ * @ubi: UBI device description object
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of failure.
+ */
+static int ubi_sysfs_init(struct ubi_device *ubi)
+{
+       int err;
+
+       ubi->dev.release = dev_release;
+       ubi->dev.devt = ubi->cdev.dev;
+       ubi->dev.class = ubi_class;
+       sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
+       err = device_register(&ubi->dev);
+       if (err)
+               return err;
+
+       err = device_create_file(&ubi->dev, &dev_eraseblock_size);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_volumes_count);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_max_ec);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_bad_peb_count);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_max_vol_count);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_min_io_size);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_bgt_enabled);
+       if (err)
+               return err;
+       err = device_create_file(&ubi->dev, &dev_mtd_num);
+       return err;
+}
+
+/**
+ * ubi_sysfs_close - close sysfs for an UBI device.
+ * @ubi: UBI device description object
+ */
+static void ubi_sysfs_close(struct ubi_device *ubi)
+{
+       device_remove_file(&ubi->dev, &dev_mtd_num);
+       device_remove_file(&ubi->dev, &dev_bgt_enabled);
+       device_remove_file(&ubi->dev, &dev_min_io_size);
+       device_remove_file(&ubi->dev, &dev_max_vol_count);
+       device_remove_file(&ubi->dev, &dev_bad_peb_count);
+       device_remove_file(&ubi->dev, &dev_reserved_for_bad);
+       device_remove_file(&ubi->dev, &dev_max_ec);
+       device_remove_file(&ubi->dev, &dev_volumes_count);
+       device_remove_file(&ubi->dev, &dev_total_eraseblocks);
+       device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
+       device_remove_file(&ubi->dev, &dev_eraseblock_size);
+       device_unregister(&ubi->dev);
+}
+#endif
+
+/**
+ * kill_volumes - destroy all volumes.
+ * @ubi: UBI device description object
+ */
+static void kill_volumes(struct ubi_device *ubi)
+{
+       int i;
+
+       for (i = 0; i < ubi->vtbl_slots; i++)
+               if (ubi->volumes[i])
+                       ubi_free_volume(ubi, ubi->volumes[i]);
+}
+
+/**
+ * uif_init - initialize user interfaces for an UBI device.
+ * @ubi: UBI device description object
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of failure.
+ */
+static int uif_init(struct ubi_device *ubi)
+{
+       int i, err;
+#ifdef UBI_LINUX
+       dev_t dev;
+#endif
+
+       sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
+
+       /*
+        * Major numbers for the UBI character devices are allocated
+        * dynamically. Major numbers of volume character devices are
+        * equivalent to ones of the corresponding UBI character device. Minor
+        * numbers of UBI character devices are 0, while minor numbers of
+        * volume character devices start from 1. Thus, we allocate one major
+        * number and ubi->vtbl_slots + 1 minor numbers.
+        */
+       err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
+       if (err) {
+               ubi_err("cannot register UBI character devices");
+               return err;
+       }
+
+       ubi_assert(MINOR(dev) == 0);
+       cdev_init(&ubi->cdev, &ubi_cdev_operations);
+       dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev));
+       ubi->cdev.owner = THIS_MODULE;
+
+       err = cdev_add(&ubi->cdev, dev, 1);
+       if (err) {
+               ubi_err("cannot add character device");
+               goto out_unreg;
+       }
+
+       err = ubi_sysfs_init(ubi);
+       if (err)
+               goto out_sysfs;
+
+       for (i = 0; i < ubi->vtbl_slots; i++)
+               if (ubi->volumes[i]) {
+                       err = ubi_add_volume(ubi, ubi->volumes[i]);
+                       if (err) {
+                               ubi_err("cannot add volume %d", i);
+                               goto out_volumes;
+                       }
+               }
+
+       return 0;
+
+out_volumes:
+       kill_volumes(ubi);
+out_sysfs:
+       ubi_sysfs_close(ubi);
+       cdev_del(&ubi->cdev);
+out_unreg:
+       unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
+       ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
+       return err;
+}
+
+/**
+ * uif_close - close user interfaces for an UBI device.
+ * @ubi: UBI device description object
+ */
+static void uif_close(struct ubi_device *ubi)
+{
+       kill_volumes(ubi);
+       ubi_sysfs_close(ubi);
+       cdev_del(&ubi->cdev);
+       unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
+}
+
+/**
+ * attach_by_scanning - attach an MTD device using scanning method.
+ * @ubi: UBI device descriptor
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of failure.
+ *
+ * Note, currently this is the only method to attach UBI devices. Hopefully in
+ * the future we'll have more scalable attaching methods and avoid full media
+ * scanning. But even in this case scanning will be needed as a fall-back
+ * attaching method if there are some on-flash table corruptions.
+ */
+static int attach_by_scanning(struct ubi_device *ubi)
+{
+       int err;
+       struct ubi_scan_info *si;
+
+       si = ubi_scan(ubi);
+       if (IS_ERR(si))
+               return PTR_ERR(si);
+
+       ubi->bad_peb_count = si->bad_peb_count;
+       ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
+       ubi->max_ec = si->max_ec;
+       ubi->mean_ec = si->mean_ec;
+
+       err = ubi_read_volume_table(ubi, si);
+       if (err)
+               goto out_si;
+
+       err = ubi_wl_init_scan(ubi, si);
+       if (err)
+               goto out_vtbl;
+
+       err = ubi_eba_init_scan(ubi, si);
+       if (err)
+               goto out_wl;
+
+       ubi_scan_destroy_si(si);
+       return 0;
+
+out_wl:
+       ubi_wl_close(ubi);
+out_vtbl:
+       vfree(ubi->vtbl);
+out_si:
+       ubi_scan_destroy_si(si);
+       return err;
+}
+
+/**
+ * io_init - initialize I/O unit for a given UBI device.
+ * @ubi: UBI device description object
+ *
+ * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
+ * assumed:
+ *   o EC header is always at offset zero - this cannot be changed;
+ *   o VID header starts just after the EC header at the closest address
+ *     aligned to @io->hdrs_min_io_size;
+ *   o data starts just after the VID header at the closest address aligned to
+ *     @io->min_io_size
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of failure.
+ */
+static int io_init(struct ubi_device *ubi)
+{
+       if (ubi->mtd->numeraseregions != 0) {
+               /*
+                * Some flashes have several erase regions. Different regions
+                * may have different eraseblock size and other
+                * characteristics. It looks like mostly multi-region flashes
+                * have one "main" region and one or more small regions to
+                * store boot loader code or boot parameters or whatever. I
+                * guess we should just pick the largest region. But this is
+                * not implemented.
+                */
+               ubi_err("multiple regions, not implemented");
+               return -EINVAL;
+       }
+
+       if (ubi->vid_hdr_offset < 0)
+               return -EINVAL;
+
+       /*
+        * Note, in this implementation we support MTD devices with 0x7FFFFFFF
+        * physical eraseblocks maximum.
+        */
+
+       ubi->peb_size   = ubi->mtd->erasesize;
+       ubi->peb_count  = ubi->mtd->size / ubi->mtd->erasesize;
+       ubi->flash_size = ubi->mtd->size;
+
+       if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
+               ubi->bad_allowed = 1;
+
+       ubi->min_io_size = ubi->mtd->writesize;
+       ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
+
+       /*
+        * Make sure minimal I/O unit is power of 2. Note, there is no
+        * fundamental reason for this assumption. It is just an optimization
+        * which allows us to avoid costly division operations.
+        */
+       if (!is_power_of_2(ubi->min_io_size)) {
+               ubi_err("min. I/O unit (%d) is not power of 2",
+                       ubi->min_io_size);
+               return -EINVAL;
+       }
+
+       ubi_assert(ubi->hdrs_min_io_size > 0);
+       ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
+       ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
+
+       /* Calculate default aligned sizes of EC and VID headers */
+       ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
+       ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
+
+       dbg_msg("min_io_size      %d", ubi->min_io_size);
+       dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
+       dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
+       dbg_msg("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
+
+       if (ubi->vid_hdr_offset == 0)
+               /* Default offset */
+               ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
+                                     ubi->ec_hdr_alsize;
+       else {
+               ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
+                                               ~(ubi->hdrs_min_io_size - 1);
+               ubi->vid_hdr_shift = ubi->vid_hdr_offset -
+                                               ubi->vid_hdr_aloffset;
+       }
+
+       /* Similar for the data offset */
+       ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE;
+       ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
+
+       dbg_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
+       dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
+       dbg_msg("vid_hdr_shift    %d", ubi->vid_hdr_shift);
+       dbg_msg("leb_start        %d", ubi->leb_start);
+
+       /* The shift must be aligned to 32-bit boundary */
+       if (ubi->vid_hdr_shift % 4) {
+               ubi_err("unaligned VID header shift %d",
+                       ubi->vid_hdr_shift);
+               return -EINVAL;
+       }
+
+       /* Check sanity */
+       if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
+           ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
+           ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
+           ubi->leb_start & (ubi->min_io_size - 1)) {
+               ubi_err("bad VID header (%d) or data offsets (%d)",
+                       ubi->vid_hdr_offset, ubi->leb_start);
+               return -EINVAL;
+       }
+
+       /*
+        * It may happen that EC and VID headers are situated in one minimal
+        * I/O unit. In this case we can only accept this UBI image in
+        * read-only mode.
+        */
+       if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
+               ubi_warn("EC and VID headers are in the same minimal I/O unit, "
+                        "switch to read-only mode");
+               ubi->ro_mode = 1;
+       }
+
+       ubi->leb_size = ubi->peb_size - ubi->leb_start;
+
+       if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
+               ubi_msg("MTD device %d is write-protected, attach in "
+                       "read-only mode", ubi->mtd->index);
+               ubi->ro_mode = 1;
+       }
+
+       ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
+               ubi->peb_size, ubi->peb_size >> 10);
+       ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
+       ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
+       if (ubi->hdrs_min_io_size != ubi->min_io_size)
+               ubi_msg("sub-page size:              %d",
+                       ubi->hdrs_min_io_size);
+       ubi_msg("VID header offset:          %d (aligned %d)",
+               ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
+       ubi_msg("data offset:                %d", ubi->leb_start);
+
+       /*
+        * Note, ideally, we have to initialize ubi->bad_peb_count here. But
+        * unfortunately, MTD does not provide this information. We should loop
+        * over all physical eraseblocks and invoke mtd->block_is_bad() for
+        * each physical eraseblock. So, we skip ubi->bad_peb_count
+        * uninitialized and initialize it after scanning.
+        */
+
+       return 0;
+}
+
+/**
+ * autoresize - re-size the volume which has the "auto-resize" flag set.
+ * @ubi: UBI device description object
+ * @vol_id: ID of the volume to re-size
+ *
+ * This function re-sizes the volume marked by the @UBI_VTBL_AUTORESIZE_FLG in
+ * the volume table to the largest possible size. See comments in ubi-header.h
+ * for more description of the flag. Returns zero in case of success and a
+ * negative error code in case of failure.
+ */
+static int autoresize(struct ubi_device *ubi, int vol_id)
+{
+       struct ubi_volume_desc desc;
+       struct ubi_volume *vol = ubi->volumes[vol_id];
+       int err, old_reserved_pebs = vol->reserved_pebs;
+
+       /*
+        * Clear the auto-resize flag in the volume in-memory copy of the
+        * volume table, and 'ubi_resize_volume()' will propogate this change
+        * to the flash.
+        */
+       ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
+
+       if (ubi->avail_pebs == 0) {
+               struct ubi_vtbl_record vtbl_rec;
+
+               /*
+                * No avalilable PEBs to re-size the volume, clear the flag on
+                * flash and exit.
+                */
+               memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
+                      sizeof(struct ubi_vtbl_record));
+               err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
+               if (err)
+                       ubi_err("cannot clean auto-resize flag for volume %d",
+                               vol_id);
+       } else {
+               desc.vol = vol;
+               err = ubi_resize_volume(&desc,
+                                       old_reserved_pebs + ubi->avail_pebs);
+               if (err)
+                       ubi_err("cannot auto-resize volume %d", vol_id);
+       }
+
+       if (err)
+               return err;
+
+       ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id,
+               vol->name, old_reserved_pebs, vol->reserved_pebs);
+       return 0;
+}
+
+/**
+ * ubi_attach_mtd_dev - attach an MTD device.
+ * @mtd_dev: MTD device description object
+ * @ubi_num: number to assign to the new UBI device
+ * @vid_hdr_offset: VID header offset
+ *
+ * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number
+ * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in
+ * which case this function finds a vacant device nubert and assings it
+ * automatically. Returns the new UBI device number in case of success and a
+ * negative error code in case of failure.
+ *
+ * Note, the invocations of this function has to be serialized by the
+ * @ubi_devices_mutex.
+ */
+int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset)
+{
+       struct ubi_device *ubi;
+       int i, err;
+
+       /*
+        * Check if we already have the same MTD device attached.
+        *
+        * Note, this function assumes that UBI devices creations and deletions
+        * are serialized, so it does not take the &ubi_devices_lock.
+        */
+       for (i = 0; i < UBI_MAX_DEVICES; i++) {
+               ubi = ubi_devices[i];
+               if (ubi && mtd->index == ubi->mtd->index) {
+                       dbg_err("mtd%d is already attached to ubi%d",
+                               mtd->index, i);
+                       return -EEXIST;
+               }
+       }
+
+       /*
+        * Make sure this MTD device is not emulated on top of an UBI volume
+        * already. Well, generally this recursion works fine, but there are
+        * different problems like the UBI module takes a reference to itself
+        * by attaching (and thus, opening) the emulated MTD device. This
+        * results in inability to unload the module. And in general it makes
+        * no sense to attach emulated MTD devices, so we prohibit this.
+        */
+       if (mtd->type == MTD_UBIVOLUME) {
+               ubi_err("refuse attaching mtd%d - it is already emulated on "
+                       "top of UBI", mtd->index);
+               return -EINVAL;
+       }
+
+       if (ubi_num == UBI_DEV_NUM_AUTO) {
+               /* Search for an empty slot in the @ubi_devices array */
+               for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++)
+                       if (!ubi_devices[ubi_num])
+                               break;
+               if (ubi_num == UBI_MAX_DEVICES) {
+                       dbg_err("only %d UBI devices may be created", UBI_MAX_DEVICES);
+                       return -ENFILE;
+               }
+       } else {
+               if (ubi_num >= UBI_MAX_DEVICES)
+                       return -EINVAL;
+
+               /* Make sure ubi_num is not busy */
+               if (ubi_devices[ubi_num]) {
+                       dbg_err("ubi%d already exists", ubi_num);
+                       return -EEXIST;
+               }
+       }
+
+       ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
+       if (!ubi)
+               return -ENOMEM;
+
+       ubi->mtd = mtd;
+       ubi->ubi_num = ubi_num;
+       ubi->vid_hdr_offset = vid_hdr_offset;
+       ubi->autoresize_vol_id = -1;
+
+       mutex_init(&ubi->buf_mutex);
+       mutex_init(&ubi->ckvol_mutex);
+       mutex_init(&ubi->volumes_mutex);
+       spin_lock_init(&ubi->volumes_lock);
+
+       ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
+
+       err = io_init(ubi);
+       if (err)
+               goto out_free;
+
+       ubi->peb_buf1 = vmalloc(ubi->peb_size);
+       if (!ubi->peb_buf1)
+               goto out_free;
+
+       ubi->peb_buf2 = vmalloc(ubi->peb_size);
+       if (!ubi->peb_buf2)
+                goto out_free;
+
+#ifdef CONFIG_MTD_UBI_DEBUG
+       mutex_init(&ubi->dbg_buf_mutex);
+       ubi->dbg_peb_buf = vmalloc(ubi->peb_size);
+       if (!ubi->dbg_peb_buf)
+                goto out_free;
+#endif
+
+       err = attach_by_scanning(ubi);
+       if (err) {
+               dbg_err("failed to attach by scanning, error %d", err);
+               goto out_free;
+       }
+
+       if (ubi->autoresize_vol_id != -1) {
+               err = autoresize(ubi, ubi->autoresize_vol_id);
+               if (err)
+                       goto out_detach;
+       }
+
+       err = uif_init(ubi);
+       if (err)
+               goto out_detach;
+
+       ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
+       if (IS_ERR(ubi->bgt_thread)) {
+               err = PTR_ERR(ubi->bgt_thread);
+               ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,
+                       err);
+               goto out_uif;
+       }
+
+       ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num);
+       ubi_msg("MTD device name:            \"%s\"", mtd->name);
+       ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
+       ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
+       ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
+       ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
+       ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
+       ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
+       ubi_msg("number of user volumes:     %d",
+               ubi->vol_count - UBI_INT_VOL_COUNT);
+       ubi_msg("available PEBs:             %d", ubi->avail_pebs);
+       ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
+       ubi_msg("number of PEBs reserved for bad PEB handling: %d",
+               ubi->beb_rsvd_pebs);
+       ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
+
+       /* Enable the background thread */
+       if (!DBG_DISABLE_BGT) {
+               ubi->thread_enabled = 1;
+               wake_up_process(ubi->bgt_thread);
+       }
+
+       ubi_devices[ubi_num] = ubi;
+       return ubi_num;
+
+out_uif:
+       uif_close(ubi);
+out_detach:
+       ubi_eba_close(ubi);
+       ubi_wl_close(ubi);
+       vfree(ubi->vtbl);
+out_free:
+       vfree(ubi->peb_buf1);
+       vfree(ubi->peb_buf2);
+#ifdef CONFIG_MTD_UBI_DEBUG
+       vfree(ubi->dbg_peb_buf);
+#endif
+       kfree(ubi);
+       return err;
+}
+
+/**
+ * ubi_detach_mtd_dev - detach an MTD device.
+ * @ubi_num: UBI device number to detach from
+ * @anyway: detach MTD even if device reference count is not zero
+ *
+ * This function destroys an UBI device number @ubi_num and detaches the
+ * underlying MTD device. Returns zero in case of success and %-EBUSY if the
+ * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not
+ * exist.
+ *
+ * Note, the invocations of this function has to be serialized by the
+ * @ubi_devices_mutex.
+ */
+int ubi_detach_mtd_dev(int ubi_num, int anyway)
+{
+       struct ubi_device *ubi;
+
+       if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
+               return -EINVAL;
+
+       spin_lock(&ubi_devices_lock);
+       ubi = ubi_devices[ubi_num];
+       if (!ubi) {
+               spin_unlock(&ubi_devices_lock);
+               return -EINVAL;
+       }
+
+       if (ubi->ref_count) {
+               if (!anyway) {
+                       spin_unlock(&ubi_devices_lock);
+                       return -EBUSY;
+               }
+               /* This may only happen if there is a bug */
+               ubi_err("%s reference count %d, destroy anyway",
+                       ubi->ubi_name, ubi->ref_count);
+       }
+       ubi_devices[ubi_num] = NULL;
+       spin_unlock(&ubi_devices_lock);
+
+       ubi_assert(ubi_num == ubi->ubi_num);
+       dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
+
+       /*
+        * Before freeing anything, we have to stop the background thread to
+        * prevent it from doing anything on this device while we are freeing.
+        */
+       if (ubi->bgt_thread)
+               kthread_stop(ubi->bgt_thread);
+
+       uif_close(ubi);
+       ubi_eba_close(ubi);
+       ubi_wl_close(ubi);
+       vfree(ubi->vtbl);
+       put_mtd_device(ubi->mtd);
+       vfree(ubi->peb_buf1);
+       vfree(ubi->peb_buf2);
+#ifdef CONFIG_MTD_UBI_DEBUG
+       vfree(ubi->dbg_peb_buf);
+#endif
+       ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
+       kfree(ubi);
+       return 0;
+}
+
+/**
+ * find_mtd_device - open an MTD device by its name or number.
+ * @mtd_dev: name or number of the device
+ *
+ * This function tries to open and MTD device described by @mtd_dev string,
+ * which is first treated as an ASCII number, and if it is not true, it is
+ * treated as MTD device name. Returns MTD device description object in case of
+ * success and a negative error code in case of failure.
+ */
+static struct mtd_info * __init open_mtd_device(const char *mtd_dev)
+{
+       struct mtd_info *mtd;
+       int mtd_num;
+       char *endp;
+
+       mtd_num = simple_strtoul(mtd_dev, &endp, 0);
+       if (*endp != '\0' || mtd_dev == endp) {
+               /*
+                * This does not look like an ASCII integer, probably this is
+                * MTD device name.
+                */
+               mtd = get_mtd_device_nm(mtd_dev);
+       } else
+               mtd = get_mtd_device(NULL, mtd_num);
+
+       return mtd;
+}
+
+int __init ubi_init(void)
+{
+       int err, i, k;
+
+       /* Ensure that EC and VID headers have correct size */
+       BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
+       BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
+
+       if (mtd_devs > UBI_MAX_DEVICES) {
+               ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES);
+               return -EINVAL;
+       }
+
+       /* Create base sysfs directory and sysfs files */
+       ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
+       if (IS_ERR(ubi_class)) {
+               err = PTR_ERR(ubi_class);
+               ubi_err("cannot create UBI class");
+               goto out;
+       }
+
+       err = class_create_file(ubi_class, &ubi_version);
+       if (err) {
+               ubi_err("cannot create sysfs file");
+               goto out_class;
+       }
+
+       err = misc_register(&ubi_ctrl_cdev);
+       if (err) {
+               ubi_err("cannot register device");
+               goto out_version;
+       }
+
+#ifdef UBI_LINUX
+       ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab",
+                                             sizeof(struct ubi_wl_entry),
+                                             0, 0, NULL);
+       if (!ubi_wl_entry_slab)
+               goto out_dev_unreg;
+#endif
+
+       /* Attach MTD devices */
+       for (i = 0; i < mtd_devs; i++) {
+               struct mtd_dev_param *p = &mtd_dev_param[i];
+               struct mtd_info *mtd;
+
+               cond_resched();
+
+               mtd = open_mtd_device(p->name);
+               if (IS_ERR(mtd)) {
+                       err = PTR_ERR(mtd);
+                       goto out_detach;
+               }
+
+               mutex_lock(&ubi_devices_mutex);
+               err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO,
+                                        p->vid_hdr_offs);
+               mutex_unlock(&ubi_devices_mutex);
+               if (err < 0) {
+                       put_mtd_device(mtd);
+                       ubi_err("cannot attach mtd%d", mtd->index);
+                       goto out_detach;
+               }
+       }
+
+       return 0;
+
+out_detach:
+       for (k = 0; k < i; k++)
+               if (ubi_devices[k]) {
+                       mutex_lock(&ubi_devices_mutex);
+                       ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1);
+                       mutex_unlock(&ubi_devices_mutex);
+               }
+#ifdef UBI_LINUX
+       kmem_cache_destroy(ubi_wl_entry_slab);
+out_dev_unreg:
+#endif
+       misc_deregister(&ubi_ctrl_cdev);
+out_version:
+       class_remove_file(ubi_class, &ubi_version);
+out_class:
+       class_destroy(ubi_class);
+out:
+       ubi_err("UBI error: cannot initialize UBI, error %d", err);
+       return err;
+}
+module_init(ubi_init);
+
+void __exit ubi_exit(void)
+{
+       int i;
+
+       for (i = 0; i < UBI_MAX_DEVICES; i++)
+               if (ubi_devices[i]) {
+                       mutex_lock(&ubi_devices_mutex);
+                       ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1);
+                       mutex_unlock(&ubi_devices_mutex);
+               }
+       kmem_cache_destroy(ubi_wl_entry_slab);
+       misc_deregister(&ubi_ctrl_cdev);
+       class_remove_file(ubi_class, &ubi_version);
+       class_destroy(ubi_class);
+}
+module_exit(ubi_exit);
+
+/**
+ * bytes_str_to_int - convert a string representing number of bytes to an
+ * integer.
+ * @str: the string to convert
+ *
+ * This function returns positive resulting integer in case of success and a
+ * negative error code in case of failure.
+ */
+static int __init bytes_str_to_int(const char *str)
+{
+       char *endp;
+       unsigned long result;
+
+       result = simple_strtoul(str, &endp, 0);
+       if (str == endp || result < 0) {
+               printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
+                      str);
+               return -EINVAL;
+       }
+
+       switch (*endp) {
+       case 'G':
+               result *= 1024;
+       case 'M':
+               result *= 1024;
+       case 'K':
+               result *= 1024;
+               if (endp[1] == 'i' && endp[2] == 'B')
+                       endp += 2;
+       case '\0':
+               break;
+       default:
+               printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n",
+                      str);
+               return -EINVAL;
+       }
+
+       return result;
+}
+
+/**
+ * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
+ * @val: the parameter value to parse
+ * @kp: not used
+ *
+ * This function returns zero in case of success and a negative error code in
+ * case of error.
+ */
+int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
+{
+       int i, len;
+       struct mtd_dev_param *p;
+       char buf[MTD_PARAM_LEN_MAX];
+       char *pbuf = &buf[0];
+       char *tokens[2] = {NULL, NULL};
+
+       if (!val)
+               return -EINVAL;
+
+       if (mtd_devs == UBI_MAX_DEVICES) {
+               printk(KERN_ERR "UBI error: too many parameters, max. is %d\n",
+                      UBI_MAX_DEVICES);
+               return -EINVAL;
+       }
+
+       len = strnlen(val, MTD_PARAM_LEN_MAX);
+       if (len == MTD_PARAM_LEN_MAX) {
+               printk(KERN_ERR "UBI error: parameter \"%s\" is too long, "
+                      "max. is %d\n", val, MTD_PARAM_LEN_MAX);
+               return -EINVAL;
+       }
+
+       if (len == 0) {
+               printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - "
+                      "ignored\n");
+               return 0;
+       }
+
+       strcpy(buf, val);
+
+       /* Get rid of the final newline */
+       if (buf[len - 1] == '\n')
+               buf[len - 1] = '\0';
+
+       for (i = 0; i < 2; i++)
+               tokens[i] = strsep(&pbuf, ",");
+
+       if (pbuf) {
+               printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n",
+                      val);
+               return -EINVAL;
+       }
+
+       p = &mtd_dev_param[mtd_devs];
+       strcpy(&p->name[0], tokens[0]);
+
+       if (tokens[1])
+               p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
+
+       if (p->vid_hdr_offs < 0)
+               return p->vid_hdr_offs;
+
+       mtd_devs += 1;
+       return 0;
+}
+
+module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
+MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
+                     "mtd=<name|num>[,<vid_hdr_offs>].\n"
+                     "Multiple \"mtd\" parameters may be specified.\n"
+                     "MTD devices may be specified by their number or name.\n"
+                     "Optional \"vid_hdr_offs\" parameter specifies UBI VID "
+                     "header position and data starting position to be used "
+                     "by UBI.\n"
+                     "Example: mtd=content,1984 mtd=4 - attach MTD device"
+                     "with name \"content\" using VID header offset 1984, and "
+                     "MTD device number 4 with default VID header offset.");
+
+MODULE_VERSION(__stringify(UBI_VERSION));
+MODULE_DESCRIPTION("UBI - Unsorted Block Images");
+MODULE_AUTHOR("Artem Bityutskiy");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mtd/ubi/crc32.c b/drivers/mtd/ubi/crc32.c
new file mode 100644 (file)
index 0000000..5273ca3
--- /dev/null
@@ -0,0 +1,518 @@
+/*
+ * Oct 15, 2000 Matt Domsch <Matt_Domsch@dell.com>
+ * Nicer crc32 functions/docs submitted by linux@horizon.com.  Thanks!
+ * Code was from the public domain, copyright abandoned.  Code was
+ * subsequently included in the kernel, thus was re-licensed under the
+ * GNU GPL v2.
+ *
+ * Oct 12, 2000 Matt Domsch <Matt_Domsch@dell.com>
+ * Same crc32 function was used in 5 other places in the kernel.
+ * I made one version, and deleted the others.
+ * There are various incantations of crc32().  Some use a seed of 0 or ~0.
+ * Some xor at the end with ~0.  The generic crc32() function takes
+ * seed as an argument, and doesn't xor at the end.  Then individual
+ * users can do whatever they need.
+ *   drivers/net/smc9194.c uses seed ~0, doesn't xor with ~0.
+ *   fs/jffs2 uses seed 0, doesn't xor with ~0.
+ *   fs/partitions/efi.c uses seed ~0, xor's with ~0.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+
+#ifdef UBI_LINUX
+#include <linux/crc32.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/compiler.h>
+#endif
+#include <linux/types.h>
+
+#include <asm/byteorder.h>
+
+#ifdef UBI_LINUX
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <asm/atomic.h>
+#endif
+#include "crc32defs.h"
+#define CRC_LE_BITS 8
+
+# define __force
+#ifndef __constant_cpu_to_le32
+#define __constant_cpu_to_le32(x) ((__force __le32)(__u32)(x))
+#endif
+#ifndef __constant_le32_to_cpu
+#define __constant_le32_to_cpu(x) ((__force __u32)(__le32)(x))
+#endif
+
+#if CRC_LE_BITS == 8
+#define tole(x) __constant_cpu_to_le32(x)
+#define tobe(x) __constant_cpu_to_be32(x)
+#else
+#define tole(x) (x)
+#define tobe(x) (x)
+#endif
+#include "crc32table.h"
+#ifdef UBI_LINUX
+MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");
+MODULE_DESCRIPTION("Ethernet CRC32 calculations");
+MODULE_LICENSE("GPL");
+#endif
+/**
+ * crc32_le() - Calculate bitwise little-endian Ethernet AUTODIN II CRC32
+ * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for
+ *     other uses, or the previous crc32 value if computing incrementally.
+ * @p: pointer to buffer over which CRC is run
+ * @len: length of buffer @p
+ */
+u32  crc32_le(u32 crc, unsigned char const *p, size_t len);
+
+#if CRC_LE_BITS == 1
+/*
+ * In fact, the table-based code will work in this case, but it can be
+ * simplified by inlining the table in ?: form.
+ */
+
+u32 crc32_le(u32 crc, unsigned char const *p, size_t len)
+{
+       int i;
+       while (len--) {
+               crc ^= *p++;
+               for (i = 0; i < 8; i++)
+                       crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
+       }
+       return crc;
+}
+#else                          /* Table-based approach */
+
+u32 crc32_le(u32 crc, unsigned char const *p, size_t len)
+{
+# if CRC_LE_BITS == 8
+       const u32      *b =(u32 *)p;
+       const u32      *tab = crc32table_le;
+
+# ifdef __LITTLE_ENDIAN
+#  define DO_CRC(x) crc = tab[ (crc ^ (x)) & 255 ] ^ (crc>>8)
+# else
+#  define DO_CRC(x) crc = tab[ ((crc >> 24) ^ (x)) & 255] ^ (crc<<8)
+# endif
+    //printf("Crc32_le crc=%x\n",crc);
+       crc = __cpu_to_le32(crc);
+       /* Align it */
+       if((((long)b)&3 && len)){
+               do {
+                       u8 *p = (u8 *)b;
+                       DO_CRC(*p++);
+                       b = (void *)p;
+               } while ((--len) && ((long)b)&3 );
+       }
+       if((len >= 4)){
+               /* load data 32 bits wide, xor data 32 bits wide. */
+               size_t save_len = len & 3;
+               len = len >> 2;
+               --b; /* use pre increment below(*++b) for speed */
+               do {
+                       crc ^= *++b;
+                       DO_CRC(0);
+                       DO_CRC(0);
+                       DO_CRC(0);
+                       DO_CRC(0);
+               } while (--len);
+               b++; /* point to next byte(s) */
+               len = save_len;
+       }
+       /* And the last few bytes */
+       if(len){
+               do {
+                       u8 *p = (u8 *)b;
+                       DO_CRC(*p++);
+                       b = (void *)p;
+               } while (--len);
+       }
+
+       return __le32_to_cpu(crc);
+#undef ENDIAN_SHIFT
+#undef DO_CRC
+
+# elif CRC_LE_BITS == 4
+       while (len--) {
+               crc ^= *p++;
+               crc = (crc >> 4) ^ crc32table_le[crc & 15];
+               crc = (crc >> 4) ^ crc32table_le[crc & 15];
+       }
+       return crc;
+# elif CRC_LE_BITS == 2
+       while (len--) {
+               crc ^= *p++;
+               crc = (crc >> 2) ^ crc32table_le[crc & 3];
+               crc = (crc >> 2) ^ crc32table_le[crc & 3];
+               crc = (crc >> 2) ^ crc32table_le[crc & 3];
+               crc = (crc >> 2) ^ crc32table_le[crc & 3];
+       }
+       return crc;
+# endif
+}
+#endif
+#ifdef UBI_LINUX
+/**
+ * crc32_be() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
+ * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for
+ *     other uses, or the previous crc32 value if computing incrementally.
+ * @p: pointer to buffer over which CRC is run
+ * @len: length of buffer @p
+ */
+u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len);
+
+#if CRC_BE_BITS == 1
+/*
+ * In fact, the table-based code will work in this case, but it can be
+ * simplified by inlining the table in ?: form.
+ */
+
+u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
+{
+       int i;
+       while (len--) {
+               crc ^= *p++ << 24;
+               for (i = 0; i < 8; i++)
+                       crc =
+                           (crc << 1) ^ ((crc & 0x80000000) ? CRCPOLY_BE :
+                                         0);
+       }
+       return crc;
+}
+
+#else                          /* Table-based approach */
+u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
+{
+# if CRC_BE_BITS == 8
+       const u32      *b =(u32 *)p;
+       const u32      *tab = crc32table_be;
+
+# ifdef __LITTLE_ENDIAN
+#  define DO_CRC(x) crc = tab[ (crc ^ (x)) & 255 ] ^ (crc>>8)
+# else
+#  define DO_CRC(x) crc = tab[ ((crc >> 24) ^ (x)) & 255] ^ (crc<<8)
+# endif
+
+       crc = __cpu_to_be32(crc);
+       /* Align it */
+       if(unlikely(((long)b)&3 && len)){
+               do {
+                       u8 *p = (u8 *)b;
+                       DO_CRC(*p++);
+                       b = (u32 *)p;
+               } while ((--len) && ((long)b)&3 );
+       }
+       if(likely(len >= 4)){
+               /* load data 32 bits wide, xor data 32 bits wide. */
+               size_t save_len = len & 3;
+               len = len >> 2;
+               --b; /* use pre increment below(*++b) for speed */
+               do {
+                       crc ^= *++b;
+                       DO_CRC(0);
+                       DO_CRC(0);
+                       DO_CRC(0);
+                       DO_CRC(0);
+               } while (--len);
+               b++; /* point to next byte(s) */
+               len = save_len;
+       }
+       /* And the last few bytes */
+       if(len){
+               do {
+                       u8 *p = (u8 *)b;
+                       DO_CRC(*p++);
+                       b = (void *)p;
+               } while (--len);
+       }
+       return __be32_to_cpu(crc);
+#undef ENDIAN_SHIFT
+#undef DO_CRC
+
+# elif CRC_BE_BITS == 4
+       while (len--) {
+               crc ^= *p++ << 24;
+               crc = (crc << 4) ^ crc32table_be[crc >> 28];
+               crc = (crc << 4) ^ crc32table_be[crc >> 28];
+       }
+       return crc;
+# elif CRC_BE_BITS == 2
+       while (len--) {
+               crc ^= *p++ << 24;
+               crc = (crc << 2) ^ crc32table_be[crc >> 30];
+               crc = (crc << 2) ^ crc32table_be[crc >> 30];
+               crc = (crc << 2) ^ crc32table_be[crc >> 30];
+               crc = (crc << 2) ^ crc32table_be[crc >> 30];
+       }
+       return crc;
+# endif
+}
+#endif
+
+EXPORT_SYMBOL(crc32_le);
+EXPORT_SYMBOL(crc32_be);
+#endif
+/*
+ * A brief CRC tutorial.
+ *
+ * A CRC is a long-division remainder.  You add the CRC to the message,
+ * and the whole thing (message+CRC) is a multiple of the given
+ * CRC polynomial.  To check the CRC, you can either check that the
+ * CRC matches the recomputed value, *or* you can check that the
+ * remainder computed on the message+CRC is 0.  This latter approach
+ * is used by a lot of hardware implementations, and is why so many
+ * protocols put the end-of-frame flag after the CRC.
+ *
+ * It's actually the same long division you learned in school, except that
+ * - We're working in binary, so the digits are only 0 and 1, and
+ * - When dividing polynomials, there are no carries.  Rather than add and
+ *   subtract, we just xor.  Thus, we tend to get a bit sloppy about
+ *   the difference between adding and subtracting.
+ *
+ * A 32-bit CRC polynomial is actually 33 bits long.  But since it's
+ * 33 bits long, bit 32 is always going to be set, so usually the CRC
+ * is written in hex with the most significant bit omitted.  (If you're
+ * familiar with the IEEE 754 floating-point format, it's the same idea.)
+ *
+ * Note that a CRC is computed over a string of *bits*, so you have
+ * to decide on the endianness of the bits within each byte.  To get
+ * the best error-detecting properties, this should correspond to the
+ * order they're actually sent.  For example, standard RS-232 serial is
+ * little-endian; the most significant bit (sometimes used for parity)
+ * is sent last.  And when appending a CRC word to a message, you should
+ * do it in the right order, matching the endianness.
+ *
+ * Just like with ordinary division, the remainder is always smaller than
+ * the divisor (the CRC polynomial) you're dividing by.  Each step of the
+ * division, you take one more digit (bit) of the dividend and append it
+ * to the current remainder.  Then you figure out the appropriate multiple
+ * of the divisor to subtract to being the remainder back into range.
+ * In binary, it's easy - it has to be either 0 or 1, and to make the
+ * XOR cancel, it's just a copy of bit 32 of the remainder.
+ *
+ * When computing a CRC, we don't care about the quotient, so we can
+ * throw the quotient bit away, but subtract the appropriate multiple of
+ * the polynomial from the remainder and we're back to where we started,
+ * ready to process the next bit.
+ *
+ * A big-endian CRC written this way would be coded like:
+ * for (i = 0; i < input_bits; i++) {
+ *     multiple = remainder & 0x80000000 ? CRCPOLY : 0;
+ *     remainder = (remainder << 1 | next_input_bit()) ^ multiple;
+ * }
+ * Notice how, to get at bit 32 of the shifted remainder, we look
+ * at bit 31 of the remainder *before* shifting it.
+ *
+ * But also notice how the next_input_bit() bits we're shifting into
+ * the remainder don't actually affect any decision-making until
+ * 32 bits later.  Thus, the first 32 cycles of this are pretty boring.
+ * Also, to add the CRC to a message, we need a 32-bit-long hole for it at
+ * the end, so we have to add 32 extra cycles shifting in zeros at the
+ * end of every message,
+ *
+ * So the standard trick is to rearrage merging in the next_input_bit()
+ * until the moment it's needed.  Then the first 32 cycles can be precomputed,
+ * and merging in the final 32 zero bits to make room for the CRC can be
+ * skipped entirely.
+ * This changes the code to:
+ * for (i = 0; i < input_bits; i++) {
+ *      remainder ^= next_input_bit() << 31;
+ *     multiple = (remainder & 0x80000000) ? CRCPOLY : 0;
+ *     remainder = (remainder << 1) ^ multiple;
+ * }
+ * With this optimization, the little-endian code is simpler:
+ * for (i = 0; i < input_bits; i++) {
+ *      remainder ^= next_input_bit();
+ *     multiple = (remainder & 1) ? CRCPOLY : 0;
+ *     remainder = (remainder >> 1) ^ multiple;
+ * }
+ *
+ * Note that the other details of endianness have been hidden in CRCPOLY
+ * (which must be bit-reversed) and next_input_bit().
+ *
+ * However, as long as next_input_bit is returning the bits in a sensible
+ * order, we can actually do the merging 8 or more bits at a time rather
+ * than one bit at a time:
+ * for (i = 0; i < input_bytes; i++) {
+ *     remainder ^= next_input_byte() << 24;
+ *     for (j = 0; j < 8; j++) {
+ *             multiple = (remainder & 0x80000000) ? CRCPOLY : 0;
+ *             remainder = (remainder << 1) ^ multiple;
+ *     }
+ * }
+ * Or in little-endian:
+ * for (i = 0; i < input_bytes; i++) {
+ *     remainder ^= next_input_byte();
+ *     for (j = 0; j < 8; j++) {
+ *             multiple = (remainder & 1) ? CRCPOLY : 0;
+ *             remainder = (remainder << 1) ^ multiple;
+ *     }
+ * }
+ * If the input is a multiple of 32 bits, you can even XOR in a 32-bit
+ * word at a time and increase the inner loop count to 32.
+ *
+ * You can also mix and match the two loop styles, for example doing the
+ * bulk of a message byte-at-a-time and adding bit-at-a-time processing
+ * for any fractional bytes at the end.
+ *
+ * The only remaining optimization is to the byte-at-a-time table method.
+ * Here, rather than just shifting one bit of the remainder to decide
+ * in the correct multiple to subtract, we can shift a byte at a time.
+ * This produces a 40-bit (rather than a 33-bit) intermediate remainder,
+ * but again the multiple of the polynomial to subtract depends only on
+ * the high bits, the high 8 bits in this case.
+ *
+ * The multile we need in that case is the low 32 bits of a 40-bit
+ * value whose high 8 bits are given, and which is a multiple of the
+ * generator polynomial.  This is simply the CRC-32 of the given
+ * one-byte message.
+ *
+ * Two more details: normally, appending zero bits to a message which
+ * is already a multiple of a polynomial produces a larger multiple of that
+ * polynomial.  To enable a CRC to detect this condition, it's common to
+ * invert the CRC before appending it.  This makes the remainder of the
+ * message+crc come out not as zero, but some fixed non-zero value.
+ *
+ * The same problem applies to zero bits prepended to the message, and
+ * a similar solution is used.  Instead of starting with a remainder of
+ * 0, an initial remainder of all ones is used.  As long as you start
+ * the same way on decoding, it doesn't make a difference.
+ */
+
+#ifdef UNITTEST
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef UBI_LINUX                               /*Not used at present */
+static void
+buf_dump(char const *prefix, unsigned char const *buf, size_t len)
+{
+       fputs(prefix, stdout);
+       while (len--)
+               printf(" %02x", *buf++);
+       putchar('\n');
+
+}
+#endif
+
+static void bytereverse(unsigned char *buf, size_t len)
+{
+       while (len--) {
+               unsigned char x = bitrev8(*buf);
+               *buf++ = x;
+       }
+}
+
+static void random_garbage(unsigned char *buf, size_t len)
+{
+       while (len--)
+               *buf++ = (unsigned char) random();
+}
+
+#ifdef UBI_LINUX                               /* Not used at present */
+static void store_le(u32 x, unsigned char *buf)
+{
+       buf[0] = (unsigned char) x;
+       buf[1] = (unsigned char) (x >> 8);
+       buf[2] = (unsigned char) (x >> 16);
+       buf[3] = (unsigned char) (x >> 24);
+}
+#endif
+
+static void store_be(u32 x, unsigned char *buf)
+{
+       buf[0] = (unsigned char) (x >> 24);
+       buf[1] = (unsigned char) (x >> 16);
+       buf[2] = (unsigned char) (x >> 8);
+       buf[3] = (unsigned char) x;
+}
+
+/*
+ * This checks that CRC(buf + CRC(buf)) = 0, and that
+ * CRC commutes with bit-reversal.  This has the side effect
+ * of bytewise bit-reversing the input buffer, and returns
+ * the CRC of the reversed buffer.
+ */
+static u32 test_step(u32 init, unsigned char *buf, size_t len)
+{
+       u32 crc1, crc2;
+       size_t i;
+
+       crc1 = crc32_be(init, buf, len);
+       store_be(crc1, buf + len);
+       crc2 = crc32_be(init, buf, len + 4);
+       if (crc2)
+               printf("\nCRC cancellation fail: 0x%08x should be 0\n",
+                      crc2);
+
+       for (i = 0; i <= len + 4; i++) {
+               crc2 = crc32_be(init, buf, i);
+               crc2 = crc32_be(crc2, buf + i, len + 4 - i);
+               if (crc2)
+                       printf("\nCRC split fail: 0x%08x\n", crc2);
+       }
+
+       /* Now swap it around for the other test */
+
+       bytereverse(buf, len + 4);
+       init = bitrev32(init);
+       crc2 = bitrev32(crc1);
+       if (crc1 != bitrev32(crc2))
+               printf("\nBit reversal fail: 0x%08x -> 0x%08x -> 0x%08x\n",
+                      crc1, crc2, bitrev32(crc2));
+       crc1 = crc32_le(init, buf, len);
+       if (crc1 != crc2)
+               printf("\nCRC endianness fail: 0x%08x != 0x%08x\n", crc1,
+                      crc2);
+       crc2 = crc32_le(init, buf, len + 4);
+       if (crc2)
+               printf("\nCRC cancellation fail: 0x%08x should be 0\n",
+                      crc2);
+
+       for (i = 0; i <= len + 4; i++) {
+               crc2 = crc32_le(init, buf, i);
+               crc2 = crc32_le(crc2, buf + i, len + 4 - i);
+               if (crc2)
+                       printf("\nCRC split fail: 0x%08x\n", crc2);
+       }
+
+       return crc1;
+}
+
+#define SIZE 64
+#define INIT1 0
+#define INIT2 0
+
+int main(void)
+{
+       unsigned char buf1[SIZE + 4];
+       unsigned char buf2[SIZE + 4];
+       unsigned char buf3[SIZE + 4];
+       int i, j;
+       u32 crc1, crc2, crc3;
+
+       for (i = 0; i <= SIZE; i++) {
+               printf("\rTesting length %d...", i);
+               fflush(stdout);
+               random_garbage(buf1, i);
+               random_garbage(buf2, i);
+               for (j = 0; j < i; j++)
+                       buf3[j] = buf1[j] ^ buf2[j];
+
+               crc1 = test_step(INIT1, buf1, i);
+               crc2 = test_step(INIT2, buf2, i);
+               /* Now check that CRC(buf1 ^ buf2) = CRC(buf1) ^ CRC(buf2) */
+               crc3 = test_step(INIT1 ^ INIT2, buf3, i);
+               if (crc3 != (crc1 ^ crc2))
+                       printf("CRC XOR fail: 0x%08x != 0x%08x ^ 0x%08x\n",
+                              crc3, crc1, crc2);
+       }
+       printf("\nAll test complete.  No failures expected.\n");
+       return 0;
+}
+
+#endif                         /* UNITTEST */