1f399d4a2SKyungmin Park /* 2f399d4a2SKyungmin Park * Copyright (c) International Business Machines Corp., 2006 3f399d4a2SKyungmin Park * Copyright (c) Nokia Corporation, 2007 4f399d4a2SKyungmin Park * 5f399d4a2SKyungmin Park * This program is free software; you can redistribute it and/or modify 6f399d4a2SKyungmin Park * it under the terms of the GNU General Public License as published by 7f399d4a2SKyungmin Park * the Free Software Foundation; either version 2 of the License, or 8f399d4a2SKyungmin Park * (at your option) any later version. 9f399d4a2SKyungmin Park * 10f399d4a2SKyungmin Park * This program is distributed in the hope that it will be useful, 11f399d4a2SKyungmin Park * but WITHOUT ANY WARRANTY; without even the implied warranty of 12f399d4a2SKyungmin Park * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13f399d4a2SKyungmin Park * the GNU General Public License for more details. 14f399d4a2SKyungmin Park * 15f399d4a2SKyungmin Park * You should have received a copy of the GNU General Public License 16f399d4a2SKyungmin Park * along with this program; if not, write to the Free Software 17f399d4a2SKyungmin Park * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18f399d4a2SKyungmin Park * 19f399d4a2SKyungmin Park * Author: Artem Bityutskiy (Битюцкий Артём), 20f399d4a2SKyungmin Park * Frank Haverkamp 21f399d4a2SKyungmin Park */ 22f399d4a2SKyungmin Park 23f399d4a2SKyungmin Park /* 24f399d4a2SKyungmin Park * This file includes UBI initialization and building of UBI devices. 25f399d4a2SKyungmin Park * 26f399d4a2SKyungmin Park * When UBI is initialized, it attaches all the MTD devices specified as the 27f399d4a2SKyungmin Park * module load parameters or the kernel boot parameters. If MTD devices were 28f399d4a2SKyungmin Park * specified, UBI does not attach any MTD device, but it is possible to do 29f399d4a2SKyungmin Park * later using the "UBI control device". 30f399d4a2SKyungmin Park * 31f399d4a2SKyungmin Park * At the moment we only attach UBI devices by scanning, which will become a 32f399d4a2SKyungmin Park * bottleneck when flashes reach certain large size. Then one may improve UBI 33f399d4a2SKyungmin Park * and add other methods, although it does not seem to be easy to do. 34f399d4a2SKyungmin Park */ 35f399d4a2SKyungmin Park 36f399d4a2SKyungmin Park #ifdef UBI_LINUX 37f399d4a2SKyungmin Park #include <linux/err.h> 38f399d4a2SKyungmin Park #include <linux/module.h> 39f399d4a2SKyungmin Park #include <linux/moduleparam.h> 40f399d4a2SKyungmin Park #include <linux/stringify.h> 41f399d4a2SKyungmin Park #include <linux/stat.h> 42f399d4a2SKyungmin Park #include <linux/miscdevice.h> 43f399d4a2SKyungmin Park #include <linux/log2.h> 44f399d4a2SKyungmin Park #include <linux/kthread.h> 45f399d4a2SKyungmin Park #endif 46f399d4a2SKyungmin Park #include <ubi_uboot.h> 47f399d4a2SKyungmin Park #include "ubi.h" 48f399d4a2SKyungmin Park 4960cfe87bSStefan Roese #if (CONFIG_SYS_MALLOC_LEN < (512 << 10)) 5060cfe87bSStefan Roese #error Malloc area too small for UBI, increase CONFIG_SYS_MALLOC_LEN to >= 512k 5160cfe87bSStefan Roese #endif 5260cfe87bSStefan Roese 53f399d4a2SKyungmin Park /* Maximum length of the 'mtd=' parameter */ 54f399d4a2SKyungmin Park #define MTD_PARAM_LEN_MAX 64 55f399d4a2SKyungmin Park 56f399d4a2SKyungmin Park /** 57f399d4a2SKyungmin Park * struct mtd_dev_param - MTD device parameter description data structure. 58f399d4a2SKyungmin Park * @name: MTD device name or number string 59f399d4a2SKyungmin Park * @vid_hdr_offs: VID header offset 60f399d4a2SKyungmin Park */ 61f399d4a2SKyungmin Park struct mtd_dev_param 62f399d4a2SKyungmin Park { 63f399d4a2SKyungmin Park char name[MTD_PARAM_LEN_MAX]; 64f399d4a2SKyungmin Park int vid_hdr_offs; 65f399d4a2SKyungmin Park }; 66f399d4a2SKyungmin Park 67f399d4a2SKyungmin Park /* Numbers of elements set in the @mtd_dev_param array */ 68f399d4a2SKyungmin Park static int mtd_devs = 0; 69f399d4a2SKyungmin Park 70f399d4a2SKyungmin Park /* MTD devices specification parameters */ 71f399d4a2SKyungmin Park static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES]; 72f399d4a2SKyungmin Park 73f399d4a2SKyungmin Park /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */ 74f399d4a2SKyungmin Park struct class *ubi_class; 75f399d4a2SKyungmin Park 76f399d4a2SKyungmin Park #ifdef UBI_LINUX 77f399d4a2SKyungmin Park /* Slab cache for wear-leveling entries */ 78f399d4a2SKyungmin Park struct kmem_cache *ubi_wl_entry_slab; 79f399d4a2SKyungmin Park 80f399d4a2SKyungmin Park /* UBI control character device */ 81f399d4a2SKyungmin Park static struct miscdevice ubi_ctrl_cdev = { 82f399d4a2SKyungmin Park .minor = MISC_DYNAMIC_MINOR, 83f399d4a2SKyungmin Park .name = "ubi_ctrl", 84f399d4a2SKyungmin Park .fops = &ubi_ctrl_cdev_operations, 85f399d4a2SKyungmin Park }; 86f399d4a2SKyungmin Park #endif 87f399d4a2SKyungmin Park 88f399d4a2SKyungmin Park /* All UBI devices in system */ 89f399d4a2SKyungmin Park struct ubi_device *ubi_devices[UBI_MAX_DEVICES]; 90f399d4a2SKyungmin Park 91f399d4a2SKyungmin Park #ifdef UBI_LINUX 92f399d4a2SKyungmin Park /* Serializes UBI devices creations and removals */ 93f399d4a2SKyungmin Park DEFINE_MUTEX(ubi_devices_mutex); 94f399d4a2SKyungmin Park 95f399d4a2SKyungmin Park /* Protects @ubi_devices and @ubi->ref_count */ 96f399d4a2SKyungmin Park static DEFINE_SPINLOCK(ubi_devices_lock); 97f399d4a2SKyungmin Park 98f399d4a2SKyungmin Park /* "Show" method for files in '/<sysfs>/class/ubi/' */ 99f399d4a2SKyungmin Park static ssize_t ubi_version_show(struct class *class, char *buf) 100f399d4a2SKyungmin Park { 101f399d4a2SKyungmin Park return sprintf(buf, "%d\n", UBI_VERSION); 102f399d4a2SKyungmin Park } 103f399d4a2SKyungmin Park 104f399d4a2SKyungmin Park /* UBI version attribute ('/<sysfs>/class/ubi/version') */ 105f399d4a2SKyungmin Park static struct class_attribute ubi_version = 106f399d4a2SKyungmin Park __ATTR(version, S_IRUGO, ubi_version_show, NULL); 107f399d4a2SKyungmin Park 108f399d4a2SKyungmin Park static ssize_t dev_attribute_show(struct device *dev, 109f399d4a2SKyungmin Park struct device_attribute *attr, char *buf); 110f399d4a2SKyungmin Park 111f399d4a2SKyungmin Park /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */ 112f399d4a2SKyungmin Park static struct device_attribute dev_eraseblock_size = 113f399d4a2SKyungmin Park __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL); 114f399d4a2SKyungmin Park static struct device_attribute dev_avail_eraseblocks = 115f399d4a2SKyungmin Park __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 116f399d4a2SKyungmin Park static struct device_attribute dev_total_eraseblocks = 117f399d4a2SKyungmin Park __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 118f399d4a2SKyungmin Park static struct device_attribute dev_volumes_count = 119f399d4a2SKyungmin Park __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL); 120f399d4a2SKyungmin Park static struct device_attribute dev_max_ec = 121f399d4a2SKyungmin Park __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL); 122f399d4a2SKyungmin Park static struct device_attribute dev_reserved_for_bad = 123f399d4a2SKyungmin Park __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL); 124f399d4a2SKyungmin Park static struct device_attribute dev_bad_peb_count = 125f399d4a2SKyungmin Park __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL); 126f399d4a2SKyungmin Park static struct device_attribute dev_max_vol_count = 127f399d4a2SKyungmin Park __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL); 128f399d4a2SKyungmin Park static struct device_attribute dev_min_io_size = 129f399d4a2SKyungmin Park __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL); 130f399d4a2SKyungmin Park static struct device_attribute dev_bgt_enabled = 131f399d4a2SKyungmin Park __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL); 132f399d4a2SKyungmin Park static struct device_attribute dev_mtd_num = 133f399d4a2SKyungmin Park __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL); 134f399d4a2SKyungmin Park #endif 135f399d4a2SKyungmin Park 136f399d4a2SKyungmin Park /** 137f399d4a2SKyungmin Park * ubi_get_device - get UBI device. 138f399d4a2SKyungmin Park * @ubi_num: UBI device number 139f399d4a2SKyungmin Park * 140f399d4a2SKyungmin Park * This function returns UBI device description object for UBI device number 141f399d4a2SKyungmin Park * @ubi_num, or %NULL if the device does not exist. This function increases the 142f399d4a2SKyungmin Park * device reference count to prevent removal of the device. In other words, the 143f399d4a2SKyungmin Park * device cannot be removed if its reference count is not zero. 144f399d4a2SKyungmin Park */ 145f399d4a2SKyungmin Park struct ubi_device *ubi_get_device(int ubi_num) 146f399d4a2SKyungmin Park { 147f399d4a2SKyungmin Park struct ubi_device *ubi; 148f399d4a2SKyungmin Park 149f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 150f399d4a2SKyungmin Park ubi = ubi_devices[ubi_num]; 151f399d4a2SKyungmin Park if (ubi) { 152f399d4a2SKyungmin Park ubi_assert(ubi->ref_count >= 0); 153f399d4a2SKyungmin Park ubi->ref_count += 1; 154f399d4a2SKyungmin Park get_device(&ubi->dev); 155f399d4a2SKyungmin Park } 156f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 157f399d4a2SKyungmin Park 158f399d4a2SKyungmin Park return ubi; 159f399d4a2SKyungmin Park } 160f399d4a2SKyungmin Park 161f399d4a2SKyungmin Park /** 162f399d4a2SKyungmin Park * ubi_put_device - drop an UBI device reference. 163f399d4a2SKyungmin Park * @ubi: UBI device description object 164f399d4a2SKyungmin Park */ 165f399d4a2SKyungmin Park void ubi_put_device(struct ubi_device *ubi) 166f399d4a2SKyungmin Park { 167f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 168f399d4a2SKyungmin Park ubi->ref_count -= 1; 169f399d4a2SKyungmin Park put_device(&ubi->dev); 170f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 171f399d4a2SKyungmin Park } 172f399d4a2SKyungmin Park 173f399d4a2SKyungmin Park /** 174f399d4a2SKyungmin Park * ubi_get_by_major - get UBI device description object by character device 175f399d4a2SKyungmin Park * major number. 176f399d4a2SKyungmin Park * @major: major number 177f399d4a2SKyungmin Park * 178f399d4a2SKyungmin Park * This function is similar to 'ubi_get_device()', but it searches the device 179f399d4a2SKyungmin Park * by its major number. 180f399d4a2SKyungmin Park */ 181f399d4a2SKyungmin Park struct ubi_device *ubi_get_by_major(int major) 182f399d4a2SKyungmin Park { 183f399d4a2SKyungmin Park int i; 184f399d4a2SKyungmin Park struct ubi_device *ubi; 185f399d4a2SKyungmin Park 186f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 187f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 188f399d4a2SKyungmin Park ubi = ubi_devices[i]; 189f399d4a2SKyungmin Park if (ubi && MAJOR(ubi->cdev.dev) == major) { 190f399d4a2SKyungmin Park ubi_assert(ubi->ref_count >= 0); 191f399d4a2SKyungmin Park ubi->ref_count += 1; 192f399d4a2SKyungmin Park get_device(&ubi->dev); 193f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 194f399d4a2SKyungmin Park return ubi; 195f399d4a2SKyungmin Park } 196f399d4a2SKyungmin Park } 197f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 198f399d4a2SKyungmin Park 199f399d4a2SKyungmin Park return NULL; 200f399d4a2SKyungmin Park } 201f399d4a2SKyungmin Park 202f399d4a2SKyungmin Park /** 203f399d4a2SKyungmin Park * ubi_major2num - get UBI device number by character device major number. 204f399d4a2SKyungmin Park * @major: major number 205f399d4a2SKyungmin Park * 206f399d4a2SKyungmin Park * This function searches UBI device number object by its major number. If UBI 207f399d4a2SKyungmin Park * device was not found, this function returns -ENODEV, otherwise the UBI device 208f399d4a2SKyungmin Park * number is returned. 209f399d4a2SKyungmin Park */ 210f399d4a2SKyungmin Park int ubi_major2num(int major) 211f399d4a2SKyungmin Park { 212f399d4a2SKyungmin Park int i, ubi_num = -ENODEV; 213f399d4a2SKyungmin Park 214f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 215f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 216f399d4a2SKyungmin Park struct ubi_device *ubi = ubi_devices[i]; 217f399d4a2SKyungmin Park 218f399d4a2SKyungmin Park if (ubi && MAJOR(ubi->cdev.dev) == major) { 219f399d4a2SKyungmin Park ubi_num = ubi->ubi_num; 220f399d4a2SKyungmin Park break; 221f399d4a2SKyungmin Park } 222f399d4a2SKyungmin Park } 223f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 224f399d4a2SKyungmin Park 225f399d4a2SKyungmin Park return ubi_num; 226f399d4a2SKyungmin Park } 227f399d4a2SKyungmin Park 228f399d4a2SKyungmin Park #ifdef UBI_LINUX 229f399d4a2SKyungmin Park /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */ 230f399d4a2SKyungmin Park static ssize_t dev_attribute_show(struct device *dev, 231f399d4a2SKyungmin Park struct device_attribute *attr, char *buf) 232f399d4a2SKyungmin Park { 233f399d4a2SKyungmin Park ssize_t ret; 234f399d4a2SKyungmin Park struct ubi_device *ubi; 235f399d4a2SKyungmin Park 236f399d4a2SKyungmin Park /* 237f399d4a2SKyungmin Park * The below code looks weird, but it actually makes sense. We get the 238f399d4a2SKyungmin Park * UBI device reference from the contained 'struct ubi_device'. But it 239f399d4a2SKyungmin Park * is unclear if the device was removed or not yet. Indeed, if the 240f399d4a2SKyungmin Park * device was removed before we increased its reference count, 241f399d4a2SKyungmin Park * 'ubi_get_device()' will return -ENODEV and we fail. 242f399d4a2SKyungmin Park * 243f399d4a2SKyungmin Park * Remember, 'struct ubi_device' is freed in the release function, so 244f399d4a2SKyungmin Park * we still can use 'ubi->ubi_num'. 245f399d4a2SKyungmin Park */ 246f399d4a2SKyungmin Park ubi = container_of(dev, struct ubi_device, dev); 247f399d4a2SKyungmin Park ubi = ubi_get_device(ubi->ubi_num); 248f399d4a2SKyungmin Park if (!ubi) 249f399d4a2SKyungmin Park return -ENODEV; 250f399d4a2SKyungmin Park 251f399d4a2SKyungmin Park if (attr == &dev_eraseblock_size) 252f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->leb_size); 253f399d4a2SKyungmin Park else if (attr == &dev_avail_eraseblocks) 254f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->avail_pebs); 255f399d4a2SKyungmin Park else if (attr == &dev_total_eraseblocks) 256f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->good_peb_count); 257f399d4a2SKyungmin Park else if (attr == &dev_volumes_count) 258f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT); 259f399d4a2SKyungmin Park else if (attr == &dev_max_ec) 260f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->max_ec); 261f399d4a2SKyungmin Park else if (attr == &dev_reserved_for_bad) 262f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs); 263f399d4a2SKyungmin Park else if (attr == &dev_bad_peb_count) 264f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->bad_peb_count); 265f399d4a2SKyungmin Park else if (attr == &dev_max_vol_count) 266f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->vtbl_slots); 267f399d4a2SKyungmin Park else if (attr == &dev_min_io_size) 268f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->min_io_size); 269f399d4a2SKyungmin Park else if (attr == &dev_bgt_enabled) 270f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->thread_enabled); 271f399d4a2SKyungmin Park else if (attr == &dev_mtd_num) 272f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->mtd->index); 273f399d4a2SKyungmin Park else 274f399d4a2SKyungmin Park ret = -EINVAL; 275f399d4a2SKyungmin Park 276f399d4a2SKyungmin Park ubi_put_device(ubi); 277f399d4a2SKyungmin Park return ret; 278f399d4a2SKyungmin Park } 279f399d4a2SKyungmin Park 280f399d4a2SKyungmin Park /* Fake "release" method for UBI devices */ 281f399d4a2SKyungmin Park static void dev_release(struct device *dev) { } 282f399d4a2SKyungmin Park 283f399d4a2SKyungmin Park /** 284f399d4a2SKyungmin Park * ubi_sysfs_init - initialize sysfs for an UBI device. 285f399d4a2SKyungmin Park * @ubi: UBI device description object 286f399d4a2SKyungmin Park * 287f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 288f399d4a2SKyungmin Park * case of failure. 289f399d4a2SKyungmin Park */ 290f399d4a2SKyungmin Park static int ubi_sysfs_init(struct ubi_device *ubi) 291f399d4a2SKyungmin Park { 292f399d4a2SKyungmin Park int err; 293f399d4a2SKyungmin Park 294f399d4a2SKyungmin Park ubi->dev.release = dev_release; 295f399d4a2SKyungmin Park ubi->dev.devt = ubi->cdev.dev; 296f399d4a2SKyungmin Park ubi->dev.class = ubi_class; 297f399d4a2SKyungmin Park sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num); 298f399d4a2SKyungmin Park err = device_register(&ubi->dev); 299f399d4a2SKyungmin Park if (err) 300f399d4a2SKyungmin Park return err; 301f399d4a2SKyungmin Park 302f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_eraseblock_size); 303f399d4a2SKyungmin Park if (err) 304f399d4a2SKyungmin Park return err; 305f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_avail_eraseblocks); 306f399d4a2SKyungmin Park if (err) 307f399d4a2SKyungmin Park return err; 308f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_total_eraseblocks); 309f399d4a2SKyungmin Park if (err) 310f399d4a2SKyungmin Park return err; 311f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_volumes_count); 312f399d4a2SKyungmin Park if (err) 313f399d4a2SKyungmin Park return err; 314f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_max_ec); 315f399d4a2SKyungmin Park if (err) 316f399d4a2SKyungmin Park return err; 317f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_reserved_for_bad); 318f399d4a2SKyungmin Park if (err) 319f399d4a2SKyungmin Park return err; 320f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_bad_peb_count); 321f399d4a2SKyungmin Park if (err) 322f399d4a2SKyungmin Park return err; 323f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_max_vol_count); 324f399d4a2SKyungmin Park if (err) 325f399d4a2SKyungmin Park return err; 326f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_min_io_size); 327f399d4a2SKyungmin Park if (err) 328f399d4a2SKyungmin Park return err; 329f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_bgt_enabled); 330f399d4a2SKyungmin Park if (err) 331f399d4a2SKyungmin Park return err; 332f399d4a2SKyungmin Park err = device_create_file(&ubi->dev, &dev_mtd_num); 333f399d4a2SKyungmin Park return err; 334f399d4a2SKyungmin Park } 335f399d4a2SKyungmin Park 336f399d4a2SKyungmin Park /** 337f399d4a2SKyungmin Park * ubi_sysfs_close - close sysfs for an UBI device. 338f399d4a2SKyungmin Park * @ubi: UBI device description object 339f399d4a2SKyungmin Park */ 340f399d4a2SKyungmin Park static void ubi_sysfs_close(struct ubi_device *ubi) 341f399d4a2SKyungmin Park { 342f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_mtd_num); 343f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_bgt_enabled); 344f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_min_io_size); 345f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_max_vol_count); 346f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_bad_peb_count); 347f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_reserved_for_bad); 348f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_max_ec); 349f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_volumes_count); 350f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_total_eraseblocks); 351f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_avail_eraseblocks); 352f399d4a2SKyungmin Park device_remove_file(&ubi->dev, &dev_eraseblock_size); 353f399d4a2SKyungmin Park device_unregister(&ubi->dev); 354f399d4a2SKyungmin Park } 355f399d4a2SKyungmin Park #endif 356f399d4a2SKyungmin Park 357f399d4a2SKyungmin Park /** 358f399d4a2SKyungmin Park * kill_volumes - destroy all volumes. 359f399d4a2SKyungmin Park * @ubi: UBI device description object 360f399d4a2SKyungmin Park */ 361f399d4a2SKyungmin Park static void kill_volumes(struct ubi_device *ubi) 362f399d4a2SKyungmin Park { 363f399d4a2SKyungmin Park int i; 364f399d4a2SKyungmin Park 365f399d4a2SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) 366f399d4a2SKyungmin Park if (ubi->volumes[i]) 367f399d4a2SKyungmin Park ubi_free_volume(ubi, ubi->volumes[i]); 368f399d4a2SKyungmin Park } 369f399d4a2SKyungmin Park 370f399d4a2SKyungmin Park /** 371f399d4a2SKyungmin Park * uif_init - initialize user interfaces for an UBI device. 372f399d4a2SKyungmin Park * @ubi: UBI device description object 373f399d4a2SKyungmin Park * 374f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 375f399d4a2SKyungmin Park * case of failure. 376f399d4a2SKyungmin Park */ 377f399d4a2SKyungmin Park static int uif_init(struct ubi_device *ubi) 378f399d4a2SKyungmin Park { 379f399d4a2SKyungmin Park int i, err; 380f399d4a2SKyungmin Park #ifdef UBI_LINUX 381f399d4a2SKyungmin Park dev_t dev; 382f399d4a2SKyungmin Park #endif 383f399d4a2SKyungmin Park 384f399d4a2SKyungmin Park sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num); 385f399d4a2SKyungmin Park 386f399d4a2SKyungmin Park /* 387f399d4a2SKyungmin Park * Major numbers for the UBI character devices are allocated 388f399d4a2SKyungmin Park * dynamically. Major numbers of volume character devices are 389f399d4a2SKyungmin Park * equivalent to ones of the corresponding UBI character device. Minor 390f399d4a2SKyungmin Park * numbers of UBI character devices are 0, while minor numbers of 391f399d4a2SKyungmin Park * volume character devices start from 1. Thus, we allocate one major 392f399d4a2SKyungmin Park * number and ubi->vtbl_slots + 1 minor numbers. 393f399d4a2SKyungmin Park */ 394f399d4a2SKyungmin Park err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name); 395f399d4a2SKyungmin Park if (err) { 396f399d4a2SKyungmin Park ubi_err("cannot register UBI character devices"); 397f399d4a2SKyungmin Park return err; 398f399d4a2SKyungmin Park } 399f399d4a2SKyungmin Park 400f399d4a2SKyungmin Park ubi_assert(MINOR(dev) == 0); 401f399d4a2SKyungmin Park cdev_init(&ubi->cdev, &ubi_cdev_operations); 402f399d4a2SKyungmin Park dbg_msg("%s major is %u", ubi->ubi_name, MAJOR(dev)); 403f399d4a2SKyungmin Park ubi->cdev.owner = THIS_MODULE; 404f399d4a2SKyungmin Park 405f399d4a2SKyungmin Park err = cdev_add(&ubi->cdev, dev, 1); 406f399d4a2SKyungmin Park if (err) { 407f399d4a2SKyungmin Park ubi_err("cannot add character device"); 408f399d4a2SKyungmin Park goto out_unreg; 409f399d4a2SKyungmin Park } 410f399d4a2SKyungmin Park 411f399d4a2SKyungmin Park err = ubi_sysfs_init(ubi); 412f399d4a2SKyungmin Park if (err) 413f399d4a2SKyungmin Park goto out_sysfs; 414f399d4a2SKyungmin Park 415f399d4a2SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) 416f399d4a2SKyungmin Park if (ubi->volumes[i]) { 417f399d4a2SKyungmin Park err = ubi_add_volume(ubi, ubi->volumes[i]); 418f399d4a2SKyungmin Park if (err) { 419f399d4a2SKyungmin Park ubi_err("cannot add volume %d", i); 420f399d4a2SKyungmin Park goto out_volumes; 421f399d4a2SKyungmin Park } 422f399d4a2SKyungmin Park } 423f399d4a2SKyungmin Park 424f399d4a2SKyungmin Park return 0; 425f399d4a2SKyungmin Park 426f399d4a2SKyungmin Park out_volumes: 427f399d4a2SKyungmin Park kill_volumes(ubi); 428f399d4a2SKyungmin Park out_sysfs: 429f399d4a2SKyungmin Park ubi_sysfs_close(ubi); 430f399d4a2SKyungmin Park cdev_del(&ubi->cdev); 431f399d4a2SKyungmin Park out_unreg: 432f399d4a2SKyungmin Park unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 433f399d4a2SKyungmin Park ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err); 434f399d4a2SKyungmin Park return err; 435f399d4a2SKyungmin Park } 436f399d4a2SKyungmin Park 437f399d4a2SKyungmin Park /** 438f399d4a2SKyungmin Park * uif_close - close user interfaces for an UBI device. 439f399d4a2SKyungmin Park * @ubi: UBI device description object 440f399d4a2SKyungmin Park */ 441f399d4a2SKyungmin Park static void uif_close(struct ubi_device *ubi) 442f399d4a2SKyungmin Park { 443f399d4a2SKyungmin Park kill_volumes(ubi); 444f399d4a2SKyungmin Park ubi_sysfs_close(ubi); 445f399d4a2SKyungmin Park cdev_del(&ubi->cdev); 446f399d4a2SKyungmin Park unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 447f399d4a2SKyungmin Park } 448f399d4a2SKyungmin Park 449f399d4a2SKyungmin Park /** 450f399d4a2SKyungmin Park * attach_by_scanning - attach an MTD device using scanning method. 451f399d4a2SKyungmin Park * @ubi: UBI device descriptor 452f399d4a2SKyungmin Park * 453f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 454f399d4a2SKyungmin Park * case of failure. 455f399d4a2SKyungmin Park * 456f399d4a2SKyungmin Park * Note, currently this is the only method to attach UBI devices. Hopefully in 457f399d4a2SKyungmin Park * the future we'll have more scalable attaching methods and avoid full media 458f399d4a2SKyungmin Park * scanning. But even in this case scanning will be needed as a fall-back 459f399d4a2SKyungmin Park * attaching method if there are some on-flash table corruptions. 460f399d4a2SKyungmin Park */ 461f399d4a2SKyungmin Park static int attach_by_scanning(struct ubi_device *ubi) 462f399d4a2SKyungmin Park { 463f399d4a2SKyungmin Park int err; 464f399d4a2SKyungmin Park struct ubi_scan_info *si; 465f399d4a2SKyungmin Park 466f399d4a2SKyungmin Park si = ubi_scan(ubi); 467f399d4a2SKyungmin Park if (IS_ERR(si)) 468f399d4a2SKyungmin Park return PTR_ERR(si); 469f399d4a2SKyungmin Park 470f399d4a2SKyungmin Park ubi->bad_peb_count = si->bad_peb_count; 471f399d4a2SKyungmin Park ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count; 472f399d4a2SKyungmin Park ubi->max_ec = si->max_ec; 473f399d4a2SKyungmin Park ubi->mean_ec = si->mean_ec; 474f399d4a2SKyungmin Park 475f399d4a2SKyungmin Park err = ubi_read_volume_table(ubi, si); 476f399d4a2SKyungmin Park if (err) 477f399d4a2SKyungmin Park goto out_si; 478f399d4a2SKyungmin Park 479f399d4a2SKyungmin Park err = ubi_eba_init_scan(ubi, si); 480f399d4a2SKyungmin Park if (err) 481f399d4a2SKyungmin Park goto out_wl; 482f399d4a2SKyungmin Park 483*d6389465SHolger Brunck err = ubi_wl_init_scan(ubi, si); 484*d6389465SHolger Brunck if (err) 485*d6389465SHolger Brunck goto out_vtbl; 486*d6389465SHolger Brunck 487f399d4a2SKyungmin Park ubi_scan_destroy_si(si); 488f399d4a2SKyungmin Park return 0; 489f399d4a2SKyungmin Park 490f399d4a2SKyungmin Park out_vtbl: 491f399d4a2SKyungmin Park vfree(ubi->vtbl); 492*d6389465SHolger Brunck out_wl: 493*d6389465SHolger Brunck ubi_wl_close(ubi); 494f399d4a2SKyungmin Park out_si: 495f399d4a2SKyungmin Park ubi_scan_destroy_si(si); 496f399d4a2SKyungmin Park return err; 497f399d4a2SKyungmin Park } 498f399d4a2SKyungmin Park 499f399d4a2SKyungmin Park /** 500f399d4a2SKyungmin Park * io_init - initialize I/O unit for a given UBI device. 501f399d4a2SKyungmin Park * @ubi: UBI device description object 502f399d4a2SKyungmin Park * 503f399d4a2SKyungmin Park * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are 504f399d4a2SKyungmin Park * assumed: 505f399d4a2SKyungmin Park * o EC header is always at offset zero - this cannot be changed; 506f399d4a2SKyungmin Park * o VID header starts just after the EC header at the closest address 507f399d4a2SKyungmin Park * aligned to @io->hdrs_min_io_size; 508f399d4a2SKyungmin Park * o data starts just after the VID header at the closest address aligned to 509f399d4a2SKyungmin Park * @io->min_io_size 510f399d4a2SKyungmin Park * 511f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 512f399d4a2SKyungmin Park * case of failure. 513f399d4a2SKyungmin Park */ 514f399d4a2SKyungmin Park static int io_init(struct ubi_device *ubi) 515f399d4a2SKyungmin Park { 516f399d4a2SKyungmin Park if (ubi->mtd->numeraseregions != 0) { 517f399d4a2SKyungmin Park /* 518f399d4a2SKyungmin Park * Some flashes have several erase regions. Different regions 519f399d4a2SKyungmin Park * may have different eraseblock size and other 520f399d4a2SKyungmin Park * characteristics. It looks like mostly multi-region flashes 521f399d4a2SKyungmin Park * have one "main" region and one or more small regions to 522f399d4a2SKyungmin Park * store boot loader code or boot parameters or whatever. I 523f399d4a2SKyungmin Park * guess we should just pick the largest region. But this is 524f399d4a2SKyungmin Park * not implemented. 525f399d4a2SKyungmin Park */ 526f399d4a2SKyungmin Park ubi_err("multiple regions, not implemented"); 527f399d4a2SKyungmin Park return -EINVAL; 528f399d4a2SKyungmin Park } 529f399d4a2SKyungmin Park 530f399d4a2SKyungmin Park if (ubi->vid_hdr_offset < 0) 531f399d4a2SKyungmin Park return -EINVAL; 532f399d4a2SKyungmin Park 533f399d4a2SKyungmin Park /* 534f399d4a2SKyungmin Park * Note, in this implementation we support MTD devices with 0x7FFFFFFF 535f399d4a2SKyungmin Park * physical eraseblocks maximum. 536f399d4a2SKyungmin Park */ 537f399d4a2SKyungmin Park 538f399d4a2SKyungmin Park ubi->peb_size = ubi->mtd->erasesize; 539d318d0c4SStefan Roese ubi->peb_count = mtd_div_by_eb(ubi->mtd->size, ubi->mtd); 540f399d4a2SKyungmin Park ubi->flash_size = ubi->mtd->size; 541f399d4a2SKyungmin Park 542f399d4a2SKyungmin Park if (ubi->mtd->block_isbad && ubi->mtd->block_markbad) 543f399d4a2SKyungmin Park ubi->bad_allowed = 1; 544f399d4a2SKyungmin Park 545f399d4a2SKyungmin Park ubi->min_io_size = ubi->mtd->writesize; 546f399d4a2SKyungmin Park ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft; 547f399d4a2SKyungmin Park 548f399d4a2SKyungmin Park /* 549f399d4a2SKyungmin Park * Make sure minimal I/O unit is power of 2. Note, there is no 550f399d4a2SKyungmin Park * fundamental reason for this assumption. It is just an optimization 551f399d4a2SKyungmin Park * which allows us to avoid costly division operations. 552f399d4a2SKyungmin Park */ 553f399d4a2SKyungmin Park if (!is_power_of_2(ubi->min_io_size)) { 554f399d4a2SKyungmin Park ubi_err("min. I/O unit (%d) is not power of 2", 555f399d4a2SKyungmin Park ubi->min_io_size); 556f399d4a2SKyungmin Park return -EINVAL; 557f399d4a2SKyungmin Park } 558f399d4a2SKyungmin Park 559f399d4a2SKyungmin Park ubi_assert(ubi->hdrs_min_io_size > 0); 560f399d4a2SKyungmin Park ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size); 561f399d4a2SKyungmin Park ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0); 562f399d4a2SKyungmin Park 563f399d4a2SKyungmin Park /* Calculate default aligned sizes of EC and VID headers */ 564f399d4a2SKyungmin Park ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size); 565f399d4a2SKyungmin Park ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size); 566f399d4a2SKyungmin Park 567f399d4a2SKyungmin Park dbg_msg("min_io_size %d", ubi->min_io_size); 568f399d4a2SKyungmin Park dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size); 569f399d4a2SKyungmin Park dbg_msg("ec_hdr_alsize %d", ubi->ec_hdr_alsize); 570f399d4a2SKyungmin Park dbg_msg("vid_hdr_alsize %d", ubi->vid_hdr_alsize); 571f399d4a2SKyungmin Park 572f399d4a2SKyungmin Park if (ubi->vid_hdr_offset == 0) 573f399d4a2SKyungmin Park /* Default offset */ 574f399d4a2SKyungmin Park ubi->vid_hdr_offset = ubi->vid_hdr_aloffset = 575f399d4a2SKyungmin Park ubi->ec_hdr_alsize; 576f399d4a2SKyungmin Park else { 577f399d4a2SKyungmin Park ubi->vid_hdr_aloffset = ubi->vid_hdr_offset & 578f399d4a2SKyungmin Park ~(ubi->hdrs_min_io_size - 1); 579f399d4a2SKyungmin Park ubi->vid_hdr_shift = ubi->vid_hdr_offset - 580f399d4a2SKyungmin Park ubi->vid_hdr_aloffset; 581f399d4a2SKyungmin Park } 582f399d4a2SKyungmin Park 583f399d4a2SKyungmin Park /* Similar for the data offset */ 584f399d4a2SKyungmin Park ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE; 585f399d4a2SKyungmin Park ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size); 586f399d4a2SKyungmin Park 587f399d4a2SKyungmin Park dbg_msg("vid_hdr_offset %d", ubi->vid_hdr_offset); 588f399d4a2SKyungmin Park dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset); 589f399d4a2SKyungmin Park dbg_msg("vid_hdr_shift %d", ubi->vid_hdr_shift); 590f399d4a2SKyungmin Park dbg_msg("leb_start %d", ubi->leb_start); 591f399d4a2SKyungmin Park 592f399d4a2SKyungmin Park /* The shift must be aligned to 32-bit boundary */ 593f399d4a2SKyungmin Park if (ubi->vid_hdr_shift % 4) { 594f399d4a2SKyungmin Park ubi_err("unaligned VID header shift %d", 595f399d4a2SKyungmin Park ubi->vid_hdr_shift); 596f399d4a2SKyungmin Park return -EINVAL; 597f399d4a2SKyungmin Park } 598f399d4a2SKyungmin Park 599f399d4a2SKyungmin Park /* Check sanity */ 600f399d4a2SKyungmin Park if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE || 601f399d4a2SKyungmin Park ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE || 602f399d4a2SKyungmin Park ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE || 603f399d4a2SKyungmin Park ubi->leb_start & (ubi->min_io_size - 1)) { 604f399d4a2SKyungmin Park ubi_err("bad VID header (%d) or data offsets (%d)", 605f399d4a2SKyungmin Park ubi->vid_hdr_offset, ubi->leb_start); 606f399d4a2SKyungmin Park return -EINVAL; 607f399d4a2SKyungmin Park } 608f399d4a2SKyungmin Park 609f399d4a2SKyungmin Park /* 610f399d4a2SKyungmin Park * It may happen that EC and VID headers are situated in one minimal 611f399d4a2SKyungmin Park * I/O unit. In this case we can only accept this UBI image in 612f399d4a2SKyungmin Park * read-only mode. 613f399d4a2SKyungmin Park */ 614f399d4a2SKyungmin Park if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) { 615f399d4a2SKyungmin Park ubi_warn("EC and VID headers are in the same minimal I/O unit, " 616f399d4a2SKyungmin Park "switch to read-only mode"); 617f399d4a2SKyungmin Park ubi->ro_mode = 1; 618f399d4a2SKyungmin Park } 619f399d4a2SKyungmin Park 620f399d4a2SKyungmin Park ubi->leb_size = ubi->peb_size - ubi->leb_start; 621f399d4a2SKyungmin Park 622f399d4a2SKyungmin Park if (!(ubi->mtd->flags & MTD_WRITEABLE)) { 623f399d4a2SKyungmin Park ubi_msg("MTD device %d is write-protected, attach in " 624f399d4a2SKyungmin Park "read-only mode", ubi->mtd->index); 625f399d4a2SKyungmin Park ubi->ro_mode = 1; 626f399d4a2SKyungmin Park } 627f399d4a2SKyungmin Park 628f399d4a2SKyungmin Park ubi_msg("physical eraseblock size: %d bytes (%d KiB)", 629f399d4a2SKyungmin Park ubi->peb_size, ubi->peb_size >> 10); 630f399d4a2SKyungmin Park ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size); 631f399d4a2SKyungmin Park ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size); 632f399d4a2SKyungmin Park if (ubi->hdrs_min_io_size != ubi->min_io_size) 633f399d4a2SKyungmin Park ubi_msg("sub-page size: %d", 634f399d4a2SKyungmin Park ubi->hdrs_min_io_size); 635f399d4a2SKyungmin Park ubi_msg("VID header offset: %d (aligned %d)", 636f399d4a2SKyungmin Park ubi->vid_hdr_offset, ubi->vid_hdr_aloffset); 637f399d4a2SKyungmin Park ubi_msg("data offset: %d", ubi->leb_start); 638f399d4a2SKyungmin Park 639f399d4a2SKyungmin Park /* 640f399d4a2SKyungmin Park * Note, ideally, we have to initialize ubi->bad_peb_count here. But 641f399d4a2SKyungmin Park * unfortunately, MTD does not provide this information. We should loop 642f399d4a2SKyungmin Park * over all physical eraseblocks and invoke mtd->block_is_bad() for 643f399d4a2SKyungmin Park * each physical eraseblock. So, we skip ubi->bad_peb_count 644f399d4a2SKyungmin Park * uninitialized and initialize it after scanning. 645f399d4a2SKyungmin Park */ 646f399d4a2SKyungmin Park 647f399d4a2SKyungmin Park return 0; 648f399d4a2SKyungmin Park } 649f399d4a2SKyungmin Park 650f399d4a2SKyungmin Park /** 651f399d4a2SKyungmin Park * autoresize - re-size the volume which has the "auto-resize" flag set. 652f399d4a2SKyungmin Park * @ubi: UBI device description object 653f399d4a2SKyungmin Park * @vol_id: ID of the volume to re-size 654f399d4a2SKyungmin Park * 655f399d4a2SKyungmin Park * This function re-sizes the volume marked by the @UBI_VTBL_AUTORESIZE_FLG in 656f399d4a2SKyungmin Park * the volume table to the largest possible size. See comments in ubi-header.h 657f399d4a2SKyungmin Park * for more description of the flag. Returns zero in case of success and a 658f399d4a2SKyungmin Park * negative error code in case of failure. 659f399d4a2SKyungmin Park */ 660f399d4a2SKyungmin Park static int autoresize(struct ubi_device *ubi, int vol_id) 661f399d4a2SKyungmin Park { 662f399d4a2SKyungmin Park struct ubi_volume_desc desc; 663f399d4a2SKyungmin Park struct ubi_volume *vol = ubi->volumes[vol_id]; 664f399d4a2SKyungmin Park int err, old_reserved_pebs = vol->reserved_pebs; 665f399d4a2SKyungmin Park 666f399d4a2SKyungmin Park /* 667f399d4a2SKyungmin Park * Clear the auto-resize flag in the volume in-memory copy of the 668f399d4a2SKyungmin Park * volume table, and 'ubi_resize_volume()' will propogate this change 669f399d4a2SKyungmin Park * to the flash. 670f399d4a2SKyungmin Park */ 671f399d4a2SKyungmin Park ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG; 672f399d4a2SKyungmin Park 673f399d4a2SKyungmin Park if (ubi->avail_pebs == 0) { 674f399d4a2SKyungmin Park struct ubi_vtbl_record vtbl_rec; 675f399d4a2SKyungmin Park 676f399d4a2SKyungmin Park /* 677f399d4a2SKyungmin Park * No avalilable PEBs to re-size the volume, clear the flag on 678f399d4a2SKyungmin Park * flash and exit. 679f399d4a2SKyungmin Park */ 680f399d4a2SKyungmin Park memcpy(&vtbl_rec, &ubi->vtbl[vol_id], 681f399d4a2SKyungmin Park sizeof(struct ubi_vtbl_record)); 682f399d4a2SKyungmin Park err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 683f399d4a2SKyungmin Park if (err) 684f399d4a2SKyungmin Park ubi_err("cannot clean auto-resize flag for volume %d", 685f399d4a2SKyungmin Park vol_id); 686f399d4a2SKyungmin Park } else { 687f399d4a2SKyungmin Park desc.vol = vol; 688f399d4a2SKyungmin Park err = ubi_resize_volume(&desc, 689f399d4a2SKyungmin Park old_reserved_pebs + ubi->avail_pebs); 690f399d4a2SKyungmin Park if (err) 691f399d4a2SKyungmin Park ubi_err("cannot auto-resize volume %d", vol_id); 692f399d4a2SKyungmin Park } 693f399d4a2SKyungmin Park 694f399d4a2SKyungmin Park if (err) 695f399d4a2SKyungmin Park return err; 696f399d4a2SKyungmin Park 697f399d4a2SKyungmin Park ubi_msg("volume %d (\"%s\") re-sized from %d to %d LEBs", vol_id, 698f399d4a2SKyungmin Park vol->name, old_reserved_pebs, vol->reserved_pebs); 699f399d4a2SKyungmin Park return 0; 700f399d4a2SKyungmin Park } 701f399d4a2SKyungmin Park 702f399d4a2SKyungmin Park /** 703f399d4a2SKyungmin Park * ubi_attach_mtd_dev - attach an MTD device. 704f399d4a2SKyungmin Park * @mtd_dev: MTD device description object 705f399d4a2SKyungmin Park * @ubi_num: number to assign to the new UBI device 706f399d4a2SKyungmin Park * @vid_hdr_offset: VID header offset 707f399d4a2SKyungmin Park * 708f399d4a2SKyungmin Park * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number 709f399d4a2SKyungmin Park * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in 710f399d4a2SKyungmin Park * which case this function finds a vacant device nubert and assings it 711f399d4a2SKyungmin Park * automatically. Returns the new UBI device number in case of success and a 712f399d4a2SKyungmin Park * negative error code in case of failure. 713f399d4a2SKyungmin Park * 714f399d4a2SKyungmin Park * Note, the invocations of this function has to be serialized by the 715f399d4a2SKyungmin Park * @ubi_devices_mutex. 716f399d4a2SKyungmin Park */ 717f399d4a2SKyungmin Park int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset) 718f399d4a2SKyungmin Park { 719f399d4a2SKyungmin Park struct ubi_device *ubi; 720f399d4a2SKyungmin Park int i, err; 721f399d4a2SKyungmin Park 722f399d4a2SKyungmin Park /* 723f399d4a2SKyungmin Park * Check if we already have the same MTD device attached. 724f399d4a2SKyungmin Park * 725f399d4a2SKyungmin Park * Note, this function assumes that UBI devices creations and deletions 726f399d4a2SKyungmin Park * are serialized, so it does not take the &ubi_devices_lock. 727f399d4a2SKyungmin Park */ 728f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 729f399d4a2SKyungmin Park ubi = ubi_devices[i]; 730f399d4a2SKyungmin Park if (ubi && mtd->index == ubi->mtd->index) { 731f399d4a2SKyungmin Park dbg_err("mtd%d is already attached to ubi%d", 732f399d4a2SKyungmin Park mtd->index, i); 733f399d4a2SKyungmin Park return -EEXIST; 734f399d4a2SKyungmin Park } 735f399d4a2SKyungmin Park } 736f399d4a2SKyungmin Park 737f399d4a2SKyungmin Park /* 738f399d4a2SKyungmin Park * Make sure this MTD device is not emulated on top of an UBI volume 739f399d4a2SKyungmin Park * already. Well, generally this recursion works fine, but there are 740f399d4a2SKyungmin Park * different problems like the UBI module takes a reference to itself 741f399d4a2SKyungmin Park * by attaching (and thus, opening) the emulated MTD device. This 742f399d4a2SKyungmin Park * results in inability to unload the module. And in general it makes 743f399d4a2SKyungmin Park * no sense to attach emulated MTD devices, so we prohibit this. 744f399d4a2SKyungmin Park */ 745f399d4a2SKyungmin Park if (mtd->type == MTD_UBIVOLUME) { 746f399d4a2SKyungmin Park ubi_err("refuse attaching mtd%d - it is already emulated on " 747f399d4a2SKyungmin Park "top of UBI", mtd->index); 748f399d4a2SKyungmin Park return -EINVAL; 749f399d4a2SKyungmin Park } 750f399d4a2SKyungmin Park 751f399d4a2SKyungmin Park if (ubi_num == UBI_DEV_NUM_AUTO) { 752f399d4a2SKyungmin Park /* Search for an empty slot in the @ubi_devices array */ 753f399d4a2SKyungmin Park for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++) 754f399d4a2SKyungmin Park if (!ubi_devices[ubi_num]) 755f399d4a2SKyungmin Park break; 756f399d4a2SKyungmin Park if (ubi_num == UBI_MAX_DEVICES) { 757f399d4a2SKyungmin Park dbg_err("only %d UBI devices may be created", UBI_MAX_DEVICES); 758f399d4a2SKyungmin Park return -ENFILE; 759f399d4a2SKyungmin Park } 760f399d4a2SKyungmin Park } else { 761f399d4a2SKyungmin Park if (ubi_num >= UBI_MAX_DEVICES) 762f399d4a2SKyungmin Park return -EINVAL; 763f399d4a2SKyungmin Park 764f399d4a2SKyungmin Park /* Make sure ubi_num is not busy */ 765f399d4a2SKyungmin Park if (ubi_devices[ubi_num]) { 766f399d4a2SKyungmin Park dbg_err("ubi%d already exists", ubi_num); 767f399d4a2SKyungmin Park return -EEXIST; 768f399d4a2SKyungmin Park } 769f399d4a2SKyungmin Park } 770f399d4a2SKyungmin Park 771f399d4a2SKyungmin Park ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL); 772f399d4a2SKyungmin Park if (!ubi) 773f399d4a2SKyungmin Park return -ENOMEM; 774f399d4a2SKyungmin Park 775f399d4a2SKyungmin Park ubi->mtd = mtd; 776f399d4a2SKyungmin Park ubi->ubi_num = ubi_num; 777f399d4a2SKyungmin Park ubi->vid_hdr_offset = vid_hdr_offset; 778f399d4a2SKyungmin Park ubi->autoresize_vol_id = -1; 779f399d4a2SKyungmin Park 780f399d4a2SKyungmin Park mutex_init(&ubi->buf_mutex); 781f399d4a2SKyungmin Park mutex_init(&ubi->ckvol_mutex); 782f399d4a2SKyungmin Park mutex_init(&ubi->volumes_mutex); 783f399d4a2SKyungmin Park spin_lock_init(&ubi->volumes_lock); 784f399d4a2SKyungmin Park 785f399d4a2SKyungmin Park ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num); 786f399d4a2SKyungmin Park 787f399d4a2SKyungmin Park err = io_init(ubi); 788f399d4a2SKyungmin Park if (err) 789f399d4a2SKyungmin Park goto out_free; 790f399d4a2SKyungmin Park 79181732935SStefan Roese err = -ENOMEM; 792f399d4a2SKyungmin Park ubi->peb_buf1 = vmalloc(ubi->peb_size); 793f399d4a2SKyungmin Park if (!ubi->peb_buf1) 794f399d4a2SKyungmin Park goto out_free; 795f399d4a2SKyungmin Park 796f399d4a2SKyungmin Park ubi->peb_buf2 = vmalloc(ubi->peb_size); 797f399d4a2SKyungmin Park if (!ubi->peb_buf2) 798f399d4a2SKyungmin Park goto out_free; 799f399d4a2SKyungmin Park 800f399d4a2SKyungmin Park #ifdef CONFIG_MTD_UBI_DEBUG 801f399d4a2SKyungmin Park mutex_init(&ubi->dbg_buf_mutex); 802f399d4a2SKyungmin Park ubi->dbg_peb_buf = vmalloc(ubi->peb_size); 803f399d4a2SKyungmin Park if (!ubi->dbg_peb_buf) 804f399d4a2SKyungmin Park goto out_free; 805f399d4a2SKyungmin Park #endif 806f399d4a2SKyungmin Park 807f399d4a2SKyungmin Park err = attach_by_scanning(ubi); 808f399d4a2SKyungmin Park if (err) { 809f399d4a2SKyungmin Park dbg_err("failed to attach by scanning, error %d", err); 810f399d4a2SKyungmin Park goto out_free; 811f399d4a2SKyungmin Park } 812f399d4a2SKyungmin Park 813f399d4a2SKyungmin Park if (ubi->autoresize_vol_id != -1) { 814f399d4a2SKyungmin Park err = autoresize(ubi, ubi->autoresize_vol_id); 815f399d4a2SKyungmin Park if (err) 816f399d4a2SKyungmin Park goto out_detach; 817f399d4a2SKyungmin Park } 818f399d4a2SKyungmin Park 819f399d4a2SKyungmin Park err = uif_init(ubi); 820f399d4a2SKyungmin Park if (err) 821f399d4a2SKyungmin Park goto out_detach; 822f399d4a2SKyungmin Park 823f399d4a2SKyungmin Park ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name); 824f399d4a2SKyungmin Park if (IS_ERR(ubi->bgt_thread)) { 825f399d4a2SKyungmin Park err = PTR_ERR(ubi->bgt_thread); 826f399d4a2SKyungmin Park ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name, 827f399d4a2SKyungmin Park err); 828f399d4a2SKyungmin Park goto out_uif; 829f399d4a2SKyungmin Park } 830f399d4a2SKyungmin Park 831f399d4a2SKyungmin Park ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num); 832f399d4a2SKyungmin Park ubi_msg("MTD device name: \"%s\"", mtd->name); 833f399d4a2SKyungmin Park ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20); 834f399d4a2SKyungmin Park ubi_msg("number of good PEBs: %d", ubi->good_peb_count); 835f399d4a2SKyungmin Park ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count); 836f399d4a2SKyungmin Park ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots); 837f399d4a2SKyungmin Park ubi_msg("wear-leveling threshold: %d", CONFIG_MTD_UBI_WL_THRESHOLD); 838f399d4a2SKyungmin Park ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT); 839f399d4a2SKyungmin Park ubi_msg("number of user volumes: %d", 840f399d4a2SKyungmin Park ubi->vol_count - UBI_INT_VOL_COUNT); 841f399d4a2SKyungmin Park ubi_msg("available PEBs: %d", ubi->avail_pebs); 842f399d4a2SKyungmin Park ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs); 843f399d4a2SKyungmin Park ubi_msg("number of PEBs reserved for bad PEB handling: %d", 844f399d4a2SKyungmin Park ubi->beb_rsvd_pebs); 845f399d4a2SKyungmin Park ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec); 846f399d4a2SKyungmin Park 847f399d4a2SKyungmin Park /* Enable the background thread */ 848f399d4a2SKyungmin Park if (!DBG_DISABLE_BGT) { 849f399d4a2SKyungmin Park ubi->thread_enabled = 1; 850f399d4a2SKyungmin Park wake_up_process(ubi->bgt_thread); 851f399d4a2SKyungmin Park } 852f399d4a2SKyungmin Park 853f399d4a2SKyungmin Park ubi_devices[ubi_num] = ubi; 854f399d4a2SKyungmin Park return ubi_num; 855f399d4a2SKyungmin Park 856f399d4a2SKyungmin Park out_uif: 857f399d4a2SKyungmin Park uif_close(ubi); 858f399d4a2SKyungmin Park out_detach: 859f399d4a2SKyungmin Park ubi_eba_close(ubi); 860f399d4a2SKyungmin Park ubi_wl_close(ubi); 861f399d4a2SKyungmin Park vfree(ubi->vtbl); 862f399d4a2SKyungmin Park out_free: 863f399d4a2SKyungmin Park vfree(ubi->peb_buf1); 864f399d4a2SKyungmin Park vfree(ubi->peb_buf2); 865f399d4a2SKyungmin Park #ifdef CONFIG_MTD_UBI_DEBUG 866f399d4a2SKyungmin Park vfree(ubi->dbg_peb_buf); 867f399d4a2SKyungmin Park #endif 868f399d4a2SKyungmin Park kfree(ubi); 869f399d4a2SKyungmin Park return err; 870f399d4a2SKyungmin Park } 871f399d4a2SKyungmin Park 872f399d4a2SKyungmin Park /** 873f399d4a2SKyungmin Park * ubi_detach_mtd_dev - detach an MTD device. 874f399d4a2SKyungmin Park * @ubi_num: UBI device number to detach from 875f399d4a2SKyungmin Park * @anyway: detach MTD even if device reference count is not zero 876f399d4a2SKyungmin Park * 877f399d4a2SKyungmin Park * This function destroys an UBI device number @ubi_num and detaches the 878f399d4a2SKyungmin Park * underlying MTD device. Returns zero in case of success and %-EBUSY if the 879f399d4a2SKyungmin Park * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not 880f399d4a2SKyungmin Park * exist. 881f399d4a2SKyungmin Park * 882f399d4a2SKyungmin Park * Note, the invocations of this function has to be serialized by the 883f399d4a2SKyungmin Park * @ubi_devices_mutex. 884f399d4a2SKyungmin Park */ 885f399d4a2SKyungmin Park int ubi_detach_mtd_dev(int ubi_num, int anyway) 886f399d4a2SKyungmin Park { 887f399d4a2SKyungmin Park struct ubi_device *ubi; 888f399d4a2SKyungmin Park 889f399d4a2SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 890f399d4a2SKyungmin Park return -EINVAL; 891f399d4a2SKyungmin Park 892f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 893f399d4a2SKyungmin Park ubi = ubi_devices[ubi_num]; 894f399d4a2SKyungmin Park if (!ubi) { 895f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 896f399d4a2SKyungmin Park return -EINVAL; 897f399d4a2SKyungmin Park } 898f399d4a2SKyungmin Park 899f399d4a2SKyungmin Park if (ubi->ref_count) { 900f399d4a2SKyungmin Park if (!anyway) { 901f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 902f399d4a2SKyungmin Park return -EBUSY; 903f399d4a2SKyungmin Park } 904f399d4a2SKyungmin Park /* This may only happen if there is a bug */ 905f399d4a2SKyungmin Park ubi_err("%s reference count %d, destroy anyway", 906f399d4a2SKyungmin Park ubi->ubi_name, ubi->ref_count); 907f399d4a2SKyungmin Park } 908f399d4a2SKyungmin Park ubi_devices[ubi_num] = NULL; 909f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 910f399d4a2SKyungmin Park 911f399d4a2SKyungmin Park ubi_assert(ubi_num == ubi->ubi_num); 912f399d4a2SKyungmin Park dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num); 913f399d4a2SKyungmin Park 914f399d4a2SKyungmin Park /* 915f399d4a2SKyungmin Park * Before freeing anything, we have to stop the background thread to 916f399d4a2SKyungmin Park * prevent it from doing anything on this device while we are freeing. 917f399d4a2SKyungmin Park */ 918f399d4a2SKyungmin Park if (ubi->bgt_thread) 919f399d4a2SKyungmin Park kthread_stop(ubi->bgt_thread); 920f399d4a2SKyungmin Park 921f399d4a2SKyungmin Park uif_close(ubi); 922f399d4a2SKyungmin Park ubi_eba_close(ubi); 923f399d4a2SKyungmin Park ubi_wl_close(ubi); 924f399d4a2SKyungmin Park vfree(ubi->vtbl); 925f399d4a2SKyungmin Park put_mtd_device(ubi->mtd); 926f399d4a2SKyungmin Park vfree(ubi->peb_buf1); 927f399d4a2SKyungmin Park vfree(ubi->peb_buf2); 928f399d4a2SKyungmin Park #ifdef CONFIG_MTD_UBI_DEBUG 929f399d4a2SKyungmin Park vfree(ubi->dbg_peb_buf); 930f399d4a2SKyungmin Park #endif 931f399d4a2SKyungmin Park ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num); 932f399d4a2SKyungmin Park kfree(ubi); 933f399d4a2SKyungmin Park return 0; 934f399d4a2SKyungmin Park } 935f399d4a2SKyungmin Park 936f399d4a2SKyungmin Park /** 937f399d4a2SKyungmin Park * find_mtd_device - open an MTD device by its name or number. 938f399d4a2SKyungmin Park * @mtd_dev: name or number of the device 939f399d4a2SKyungmin Park * 940f399d4a2SKyungmin Park * This function tries to open and MTD device described by @mtd_dev string, 941f399d4a2SKyungmin Park * which is first treated as an ASCII number, and if it is not true, it is 942f399d4a2SKyungmin Park * treated as MTD device name. Returns MTD device description object in case of 943f399d4a2SKyungmin Park * success and a negative error code in case of failure. 944f399d4a2SKyungmin Park */ 945f399d4a2SKyungmin Park static struct mtd_info * __init open_mtd_device(const char *mtd_dev) 946f399d4a2SKyungmin Park { 947f399d4a2SKyungmin Park struct mtd_info *mtd; 948f399d4a2SKyungmin Park int mtd_num; 949f399d4a2SKyungmin Park char *endp; 950f399d4a2SKyungmin Park 951f399d4a2SKyungmin Park mtd_num = simple_strtoul(mtd_dev, &endp, 0); 952f399d4a2SKyungmin Park if (*endp != '\0' || mtd_dev == endp) { 953f399d4a2SKyungmin Park /* 954f399d4a2SKyungmin Park * This does not look like an ASCII integer, probably this is 955f399d4a2SKyungmin Park * MTD device name. 956f399d4a2SKyungmin Park */ 957f399d4a2SKyungmin Park mtd = get_mtd_device_nm(mtd_dev); 958f399d4a2SKyungmin Park } else 959f399d4a2SKyungmin Park mtd = get_mtd_device(NULL, mtd_num); 960f399d4a2SKyungmin Park 961f399d4a2SKyungmin Park return mtd; 962f399d4a2SKyungmin Park } 963f399d4a2SKyungmin Park 964f399d4a2SKyungmin Park int __init ubi_init(void) 965f399d4a2SKyungmin Park { 966f399d4a2SKyungmin Park int err, i, k; 967f399d4a2SKyungmin Park 968f399d4a2SKyungmin Park /* Ensure that EC and VID headers have correct size */ 969f399d4a2SKyungmin Park BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64); 970f399d4a2SKyungmin Park BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64); 971f399d4a2SKyungmin Park 972f399d4a2SKyungmin Park if (mtd_devs > UBI_MAX_DEVICES) { 973f399d4a2SKyungmin Park ubi_err("too many MTD devices, maximum is %d", UBI_MAX_DEVICES); 974f399d4a2SKyungmin Park return -EINVAL; 975f399d4a2SKyungmin Park } 976f399d4a2SKyungmin Park 977f399d4a2SKyungmin Park /* Create base sysfs directory and sysfs files */ 978f399d4a2SKyungmin Park ubi_class = class_create(THIS_MODULE, UBI_NAME_STR); 979f399d4a2SKyungmin Park if (IS_ERR(ubi_class)) { 980f399d4a2SKyungmin Park err = PTR_ERR(ubi_class); 981f399d4a2SKyungmin Park ubi_err("cannot create UBI class"); 982f399d4a2SKyungmin Park goto out; 983f399d4a2SKyungmin Park } 984f399d4a2SKyungmin Park 985f399d4a2SKyungmin Park err = class_create_file(ubi_class, &ubi_version); 986f399d4a2SKyungmin Park if (err) { 987f399d4a2SKyungmin Park ubi_err("cannot create sysfs file"); 988f399d4a2SKyungmin Park goto out_class; 989f399d4a2SKyungmin Park } 990f399d4a2SKyungmin Park 991f399d4a2SKyungmin Park err = misc_register(&ubi_ctrl_cdev); 992f399d4a2SKyungmin Park if (err) { 993f399d4a2SKyungmin Park ubi_err("cannot register device"); 994f399d4a2SKyungmin Park goto out_version; 995f399d4a2SKyungmin Park } 996f399d4a2SKyungmin Park 997f399d4a2SKyungmin Park #ifdef UBI_LINUX 998f399d4a2SKyungmin Park ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab", 999f399d4a2SKyungmin Park sizeof(struct ubi_wl_entry), 1000f399d4a2SKyungmin Park 0, 0, NULL); 1001f399d4a2SKyungmin Park if (!ubi_wl_entry_slab) 1002f399d4a2SKyungmin Park goto out_dev_unreg; 1003f399d4a2SKyungmin Park #endif 1004f399d4a2SKyungmin Park 1005f399d4a2SKyungmin Park /* Attach MTD devices */ 1006f399d4a2SKyungmin Park for (i = 0; i < mtd_devs; i++) { 1007f399d4a2SKyungmin Park struct mtd_dev_param *p = &mtd_dev_param[i]; 1008f399d4a2SKyungmin Park struct mtd_info *mtd; 1009f399d4a2SKyungmin Park 1010f399d4a2SKyungmin Park cond_resched(); 1011f399d4a2SKyungmin Park 1012f399d4a2SKyungmin Park mtd = open_mtd_device(p->name); 1013f399d4a2SKyungmin Park if (IS_ERR(mtd)) { 1014f399d4a2SKyungmin Park err = PTR_ERR(mtd); 1015f399d4a2SKyungmin Park goto out_detach; 1016f399d4a2SKyungmin Park } 1017f399d4a2SKyungmin Park 1018f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1019f399d4a2SKyungmin Park err = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 1020f399d4a2SKyungmin Park p->vid_hdr_offs); 1021f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1022f399d4a2SKyungmin Park if (err < 0) { 1023f399d4a2SKyungmin Park put_mtd_device(mtd); 1024f399d4a2SKyungmin Park ubi_err("cannot attach mtd%d", mtd->index); 1025f399d4a2SKyungmin Park goto out_detach; 1026f399d4a2SKyungmin Park } 1027f399d4a2SKyungmin Park } 1028f399d4a2SKyungmin Park 1029f399d4a2SKyungmin Park return 0; 1030f399d4a2SKyungmin Park 1031f399d4a2SKyungmin Park out_detach: 1032f399d4a2SKyungmin Park for (k = 0; k < i; k++) 1033f399d4a2SKyungmin Park if (ubi_devices[k]) { 1034f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1035f399d4a2SKyungmin Park ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1); 1036f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1037f399d4a2SKyungmin Park } 1038f399d4a2SKyungmin Park #ifdef UBI_LINUX 1039f399d4a2SKyungmin Park kmem_cache_destroy(ubi_wl_entry_slab); 1040f399d4a2SKyungmin Park out_dev_unreg: 1041f399d4a2SKyungmin Park #endif 1042f399d4a2SKyungmin Park misc_deregister(&ubi_ctrl_cdev); 1043f399d4a2SKyungmin Park out_version: 1044f399d4a2SKyungmin Park class_remove_file(ubi_class, &ubi_version); 1045f399d4a2SKyungmin Park out_class: 1046f399d4a2SKyungmin Park class_destroy(ubi_class); 1047f399d4a2SKyungmin Park out: 104886af10caSKarl Beldan mtd_devs = 0; 1049f399d4a2SKyungmin Park ubi_err("UBI error: cannot initialize UBI, error %d", err); 1050f399d4a2SKyungmin Park return err; 1051f399d4a2SKyungmin Park } 1052f399d4a2SKyungmin Park module_init(ubi_init); 1053f399d4a2SKyungmin Park 1054f399d4a2SKyungmin Park void __exit ubi_exit(void) 1055f399d4a2SKyungmin Park { 1056f399d4a2SKyungmin Park int i; 1057f399d4a2SKyungmin Park 1058f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) 1059f399d4a2SKyungmin Park if (ubi_devices[i]) { 1060f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1061f399d4a2SKyungmin Park ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1); 1062f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1063f399d4a2SKyungmin Park } 1064f399d4a2SKyungmin Park kmem_cache_destroy(ubi_wl_entry_slab); 1065f399d4a2SKyungmin Park misc_deregister(&ubi_ctrl_cdev); 1066f399d4a2SKyungmin Park class_remove_file(ubi_class, &ubi_version); 1067f399d4a2SKyungmin Park class_destroy(ubi_class); 10682ee951baSStefan Roese mtd_devs = 0; 1069f399d4a2SKyungmin Park } 1070f399d4a2SKyungmin Park module_exit(ubi_exit); 1071f399d4a2SKyungmin Park 1072f399d4a2SKyungmin Park /** 1073f399d4a2SKyungmin Park * bytes_str_to_int - convert a string representing number of bytes to an 1074f399d4a2SKyungmin Park * integer. 1075f399d4a2SKyungmin Park * @str: the string to convert 1076f399d4a2SKyungmin Park * 1077f399d4a2SKyungmin Park * This function returns positive resulting integer in case of success and a 1078f399d4a2SKyungmin Park * negative error code in case of failure. 1079f399d4a2SKyungmin Park */ 1080f399d4a2SKyungmin Park static int __init bytes_str_to_int(const char *str) 1081f399d4a2SKyungmin Park { 1082f399d4a2SKyungmin Park char *endp; 1083f399d4a2SKyungmin Park unsigned long result; 1084f399d4a2SKyungmin Park 1085f399d4a2SKyungmin Park result = simple_strtoul(str, &endp, 0); 1086f399d4a2SKyungmin Park if (str == endp || result < 0) { 1087f399d4a2SKyungmin Park printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1088f399d4a2SKyungmin Park str); 1089f399d4a2SKyungmin Park return -EINVAL; 1090f399d4a2SKyungmin Park } 1091f399d4a2SKyungmin Park 1092f399d4a2SKyungmin Park switch (*endp) { 1093f399d4a2SKyungmin Park case 'G': 1094f399d4a2SKyungmin Park result *= 1024; 1095f399d4a2SKyungmin Park case 'M': 1096f399d4a2SKyungmin Park result *= 1024; 1097f399d4a2SKyungmin Park case 'K': 1098f399d4a2SKyungmin Park result *= 1024; 1099f399d4a2SKyungmin Park if (endp[1] == 'i' && endp[2] == 'B') 1100f399d4a2SKyungmin Park endp += 2; 1101f399d4a2SKyungmin Park case '\0': 1102f399d4a2SKyungmin Park break; 1103f399d4a2SKyungmin Park default: 1104f399d4a2SKyungmin Park printk(KERN_ERR "UBI error: incorrect bytes count: \"%s\"\n", 1105f399d4a2SKyungmin Park str); 1106f399d4a2SKyungmin Park return -EINVAL; 1107f399d4a2SKyungmin Park } 1108f399d4a2SKyungmin Park 1109f399d4a2SKyungmin Park return result; 1110f399d4a2SKyungmin Park } 1111f399d4a2SKyungmin Park 1112f399d4a2SKyungmin Park /** 1113f399d4a2SKyungmin Park * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter. 1114f399d4a2SKyungmin Park * @val: the parameter value to parse 1115f399d4a2SKyungmin Park * @kp: not used 1116f399d4a2SKyungmin Park * 1117f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 1118f399d4a2SKyungmin Park * case of error. 1119f399d4a2SKyungmin Park */ 1120f399d4a2SKyungmin Park int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp) 1121f399d4a2SKyungmin Park { 1122f399d4a2SKyungmin Park int i, len; 1123f399d4a2SKyungmin Park struct mtd_dev_param *p; 1124f399d4a2SKyungmin Park char buf[MTD_PARAM_LEN_MAX]; 1125f399d4a2SKyungmin Park char *pbuf = &buf[0]; 1126f399d4a2SKyungmin Park char *tokens[2] = {NULL, NULL}; 1127f399d4a2SKyungmin Park 1128f399d4a2SKyungmin Park if (!val) 1129f399d4a2SKyungmin Park return -EINVAL; 1130f399d4a2SKyungmin Park 1131f399d4a2SKyungmin Park if (mtd_devs == UBI_MAX_DEVICES) { 1132f399d4a2SKyungmin Park printk(KERN_ERR "UBI error: too many parameters, max. is %d\n", 1133f399d4a2SKyungmin Park UBI_MAX_DEVICES); 1134f399d4a2SKyungmin Park return -EINVAL; 1135f399d4a2SKyungmin Park } 1136f399d4a2SKyungmin Park 1137f399d4a2SKyungmin Park len = strnlen(val, MTD_PARAM_LEN_MAX); 1138f399d4a2SKyungmin Park if (len == MTD_PARAM_LEN_MAX) { 1139f399d4a2SKyungmin Park printk(KERN_ERR "UBI error: parameter \"%s\" is too long, " 1140f399d4a2SKyungmin Park "max. is %d\n", val, MTD_PARAM_LEN_MAX); 1141f399d4a2SKyungmin Park return -EINVAL; 1142f399d4a2SKyungmin Park } 1143f399d4a2SKyungmin Park 1144f399d4a2SKyungmin Park if (len == 0) { 1145f399d4a2SKyungmin Park printk(KERN_WARNING "UBI warning: empty 'mtd=' parameter - " 1146f399d4a2SKyungmin Park "ignored\n"); 1147f399d4a2SKyungmin Park return 0; 1148f399d4a2SKyungmin Park } 1149f399d4a2SKyungmin Park 1150f399d4a2SKyungmin Park strcpy(buf, val); 1151f399d4a2SKyungmin Park 1152f399d4a2SKyungmin Park /* Get rid of the final newline */ 1153f399d4a2SKyungmin Park if (buf[len - 1] == '\n') 1154f399d4a2SKyungmin Park buf[len - 1] = '\0'; 1155f399d4a2SKyungmin Park 1156f399d4a2SKyungmin Park for (i = 0; i < 2; i++) 1157f399d4a2SKyungmin Park tokens[i] = strsep(&pbuf, ","); 1158f399d4a2SKyungmin Park 1159f399d4a2SKyungmin Park if (pbuf) { 1160f399d4a2SKyungmin Park printk(KERN_ERR "UBI error: too many arguments at \"%s\"\n", 1161f399d4a2SKyungmin Park val); 1162f399d4a2SKyungmin Park return -EINVAL; 1163f399d4a2SKyungmin Park } 1164f399d4a2SKyungmin Park 1165f399d4a2SKyungmin Park p = &mtd_dev_param[mtd_devs]; 1166f399d4a2SKyungmin Park strcpy(&p->name[0], tokens[0]); 1167f399d4a2SKyungmin Park 1168f399d4a2SKyungmin Park if (tokens[1]) 1169f399d4a2SKyungmin Park p->vid_hdr_offs = bytes_str_to_int(tokens[1]); 1170f399d4a2SKyungmin Park 1171f399d4a2SKyungmin Park if (p->vid_hdr_offs < 0) 1172f399d4a2SKyungmin Park return p->vid_hdr_offs; 1173f399d4a2SKyungmin Park 1174f399d4a2SKyungmin Park mtd_devs += 1; 1175f399d4a2SKyungmin Park return 0; 1176f399d4a2SKyungmin Park } 1177f399d4a2SKyungmin Park 1178f399d4a2SKyungmin Park module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000); 1179f399d4a2SKyungmin Park MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: " 1180f399d4a2SKyungmin Park "mtd=<name|num>[,<vid_hdr_offs>].\n" 1181f399d4a2SKyungmin Park "Multiple \"mtd\" parameters may be specified.\n" 1182f399d4a2SKyungmin Park "MTD devices may be specified by their number or name.\n" 1183f399d4a2SKyungmin Park "Optional \"vid_hdr_offs\" parameter specifies UBI VID " 1184f399d4a2SKyungmin Park "header position and data starting position to be used " 1185f399d4a2SKyungmin Park "by UBI.\n" 1186f399d4a2SKyungmin Park "Example: mtd=content,1984 mtd=4 - attach MTD device" 1187f399d4a2SKyungmin Park "with name \"content\" using VID header offset 1984, and " 1188f399d4a2SKyungmin Park "MTD device number 4 with default VID header offset."); 1189f399d4a2SKyungmin Park 1190f399d4a2SKyungmin Park MODULE_VERSION(__stringify(UBI_VERSION)); 1191f399d4a2SKyungmin Park MODULE_DESCRIPTION("UBI - Unsorted Block Images"); 1192f399d4a2SKyungmin Park MODULE_AUTHOR("Artem Bityutskiy"); 1193f399d4a2SKyungmin Park MODULE_LICENSE("GPL"); 1194