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