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