1f399d4a2SKyungmin Park /* 2f399d4a2SKyungmin Park * Copyright (c) International Business Machines Corp., 2006 3f399d4a2SKyungmin Park * Copyright (c) Nokia Corporation, 2007 4f399d4a2SKyungmin Park * 51a459660SWolfgang 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 20ff94bc40SHeiko Schocher #ifndef __UBOOT__ 21f399d4a2SKyungmin Park #include <linux/module.h> 22f399d4a2SKyungmin Park #include <linux/moduleparam.h> 23f399d4a2SKyungmin Park #include <linux/stringify.h> 24ff94bc40SHeiko Schocher #include <linux/namei.h> 25f399d4a2SKyungmin Park #include <linux/stat.h> 26f399d4a2SKyungmin Park #include <linux/miscdevice.h> 27f399d4a2SKyungmin Park #include <linux/log2.h> 28f399d4a2SKyungmin Park #include <linux/kthread.h> 29ff94bc40SHeiko Schocher #include <linux/kernel.h> 30ff94bc40SHeiko Schocher #include <linux/slab.h> 31ff94bc40SHeiko Schocher #include <linux/major.h> 32ff94bc40SHeiko Schocher #else 33*84b8bf6dSMasahiro Yamada #include <linux/bug.h> 34f8fdb81fSFabio Estevam #include <linux/log2.h> 35f399d4a2SKyungmin Park #endif 36ff94bc40SHeiko Schocher #include <linux/err.h> 37f399d4a2SKyungmin Park #include <ubi_uboot.h> 38ff94bc40SHeiko Schocher #include <linux/mtd/partitions.h> 39ff94bc40SHeiko Schocher 40f399d4a2SKyungmin Park #include "ubi.h" 41f399d4a2SKyungmin Park 42ff94bc40SHeiko Schocher /* Maximum length of the 'mtd=' parameter */ 43ff94bc40SHeiko Schocher #define MTD_PARAM_LEN_MAX 64 44ff94bc40SHeiko Schocher 45ff94bc40SHeiko Schocher /* Maximum number of comma-separated items in the 'mtd=' parameter */ 46ff94bc40SHeiko Schocher #define MTD_PARAM_MAX_COUNT 4 47ff94bc40SHeiko Schocher 48ff94bc40SHeiko Schocher /* Maximum value for the number of bad PEBs per 1024 PEBs */ 49ff94bc40SHeiko Schocher #define MAX_MTD_UBI_BEB_LIMIT 768 50ff94bc40SHeiko Schocher 51ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_MODULE 52ff94bc40SHeiko Schocher #define ubi_is_module() 1 53ff94bc40SHeiko Schocher #else 54ff94bc40SHeiko Schocher #define ubi_is_module() 0 55ff94bc40SHeiko Schocher #endif 56ff94bc40SHeiko Schocher 5760cfe87bSStefan Roese #if (CONFIG_SYS_MALLOC_LEN < (512 << 10)) 5860cfe87bSStefan Roese #error Malloc area too small for UBI, increase CONFIG_SYS_MALLOC_LEN to >= 512k 5960cfe87bSStefan Roese #endif 6060cfe87bSStefan Roese 61f399d4a2SKyungmin Park /** 62f399d4a2SKyungmin Park * struct mtd_dev_param - MTD device parameter description data structure. 63ff94bc40SHeiko Schocher * @name: MTD character device node path, MTD device name, or MTD device number 64ff94bc40SHeiko Schocher * string 65f399d4a2SKyungmin Park * @vid_hdr_offs: VID header offset 66ff94bc40SHeiko Schocher * @max_beb_per1024: maximum expected number of bad PEBs per 1024 PEBs 67f399d4a2SKyungmin Park */ 68ff94bc40SHeiko Schocher struct mtd_dev_param { 69f399d4a2SKyungmin Park char name[MTD_PARAM_LEN_MAX]; 70ff94bc40SHeiko Schocher int ubi_num; 71f399d4a2SKyungmin Park int vid_hdr_offs; 72ff94bc40SHeiko Schocher int max_beb_per1024; 73f399d4a2SKyungmin Park }; 74f399d4a2SKyungmin Park 75f399d4a2SKyungmin Park /* Numbers of elements set in the @mtd_dev_param array */ 76ff94bc40SHeiko Schocher static int __initdata mtd_devs; 77f399d4a2SKyungmin Park 78f399d4a2SKyungmin Park /* MTD devices specification parameters */ 79ff94bc40SHeiko Schocher static struct mtd_dev_param __initdata mtd_dev_param[UBI_MAX_DEVICES]; 80ff94bc40SHeiko Schocher #ifndef __UBOOT__ 81ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 82ff94bc40SHeiko Schocher /* UBI module parameter to enable fastmap automatically on non-fastmap images */ 83ff94bc40SHeiko Schocher static bool fm_autoconvert; 840195a7bbSHeiko Schocher static bool fm_debug; 85ff94bc40SHeiko Schocher #endif 86ff94bc40SHeiko Schocher #else 87ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 88ff94bc40SHeiko Schocher #if !defined(CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT) 89ff94bc40SHeiko Schocher #define CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT 0 90ff94bc40SHeiko Schocher #endif 91ff94bc40SHeiko Schocher static bool fm_autoconvert = CONFIG_MTD_UBI_FASTMAP_AUTOCONVERT; 920195a7bbSHeiko Schocher #if !defined(CONFIG_MTD_UBI_FM_DEBUG) 930195a7bbSHeiko Schocher #define CONFIG_MTD_UBI_FM_DEBUG 0 940195a7bbSHeiko Schocher #endif 950195a7bbSHeiko Schocher static bool fm_debug = CONFIG_MTD_UBI_FM_DEBUG; 96ff94bc40SHeiko Schocher #endif 97ff94bc40SHeiko Schocher #endif 98f399d4a2SKyungmin Park 99f399d4a2SKyungmin Park /* Slab cache for wear-leveling entries */ 100f399d4a2SKyungmin Park struct kmem_cache *ubi_wl_entry_slab; 101f399d4a2SKyungmin Park 102ff94bc40SHeiko Schocher #ifndef __UBOOT__ 103f399d4a2SKyungmin Park /* UBI control character device */ 104f399d4a2SKyungmin Park static struct miscdevice ubi_ctrl_cdev = { 105f399d4a2SKyungmin Park .minor = MISC_DYNAMIC_MINOR, 106f399d4a2SKyungmin Park .name = "ubi_ctrl", 107f399d4a2SKyungmin Park .fops = &ubi_ctrl_cdev_operations, 108f399d4a2SKyungmin Park }; 109f399d4a2SKyungmin Park #endif 110f399d4a2SKyungmin Park 111f399d4a2SKyungmin Park /* All UBI devices in system */ 112ff94bc40SHeiko Schocher #ifndef __UBOOT__ 113ff94bc40SHeiko Schocher static struct ubi_device *ubi_devices[UBI_MAX_DEVICES]; 114ff94bc40SHeiko Schocher #else 115f399d4a2SKyungmin Park struct ubi_device *ubi_devices[UBI_MAX_DEVICES]; 116ff94bc40SHeiko Schocher #endif 117f399d4a2SKyungmin Park 118ff94bc40SHeiko Schocher #ifndef __UBOOT__ 119f399d4a2SKyungmin Park /* Serializes UBI devices creations and removals */ 120f399d4a2SKyungmin Park DEFINE_MUTEX(ubi_devices_mutex); 121f399d4a2SKyungmin Park 122f399d4a2SKyungmin Park /* Protects @ubi_devices and @ubi->ref_count */ 123f399d4a2SKyungmin Park static DEFINE_SPINLOCK(ubi_devices_lock); 124f399d4a2SKyungmin Park 125f399d4a2SKyungmin Park /* "Show" method for files in '/<sysfs>/class/ubi/' */ 126ff94bc40SHeiko Schocher static ssize_t ubi_version_show(struct class *class, 127ff94bc40SHeiko Schocher struct class_attribute *attr, char *buf) 128f399d4a2SKyungmin Park { 129f399d4a2SKyungmin Park return sprintf(buf, "%d\n", UBI_VERSION); 130f399d4a2SKyungmin Park } 131f399d4a2SKyungmin Park 132f399d4a2SKyungmin Park /* UBI version attribute ('/<sysfs>/class/ubi/version') */ 1330195a7bbSHeiko Schocher static struct class_attribute ubi_class_attrs[] = { 1340195a7bbSHeiko Schocher __ATTR(version, S_IRUGO, ubi_version_show, NULL), 1350195a7bbSHeiko Schocher __ATTR_NULL 1360195a7bbSHeiko Schocher }; 1370195a7bbSHeiko Schocher 1380195a7bbSHeiko Schocher /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */ 1390195a7bbSHeiko Schocher struct class ubi_class = { 1400195a7bbSHeiko Schocher .name = UBI_NAME_STR, 1410195a7bbSHeiko Schocher .owner = THIS_MODULE, 1420195a7bbSHeiko Schocher .class_attrs = ubi_class_attrs, 1430195a7bbSHeiko Schocher }; 144f399d4a2SKyungmin Park 145f399d4a2SKyungmin Park static ssize_t dev_attribute_show(struct device *dev, 146f399d4a2SKyungmin Park struct device_attribute *attr, char *buf); 147f399d4a2SKyungmin Park 148f399d4a2SKyungmin Park /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */ 149f399d4a2SKyungmin Park static struct device_attribute dev_eraseblock_size = 150f399d4a2SKyungmin Park __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL); 151f399d4a2SKyungmin Park static struct device_attribute dev_avail_eraseblocks = 152f399d4a2SKyungmin Park __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 153f399d4a2SKyungmin Park static struct device_attribute dev_total_eraseblocks = 154f399d4a2SKyungmin Park __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL); 155f399d4a2SKyungmin Park static struct device_attribute dev_volumes_count = 156f399d4a2SKyungmin Park __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL); 157f399d4a2SKyungmin Park static struct device_attribute dev_max_ec = 158f399d4a2SKyungmin Park __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL); 159f399d4a2SKyungmin Park static struct device_attribute dev_reserved_for_bad = 160f399d4a2SKyungmin Park __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL); 161f399d4a2SKyungmin Park static struct device_attribute dev_bad_peb_count = 162f399d4a2SKyungmin Park __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL); 163f399d4a2SKyungmin Park static struct device_attribute dev_max_vol_count = 164f399d4a2SKyungmin Park __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL); 165f399d4a2SKyungmin Park static struct device_attribute dev_min_io_size = 166f399d4a2SKyungmin Park __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL); 167f399d4a2SKyungmin Park static struct device_attribute dev_bgt_enabled = 168f399d4a2SKyungmin Park __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL); 169f399d4a2SKyungmin Park static struct device_attribute dev_mtd_num = 170f399d4a2SKyungmin Park __ATTR(mtd_num, S_IRUGO, dev_attribute_show, NULL); 171f399d4a2SKyungmin Park #endif 172f399d4a2SKyungmin Park 173f399d4a2SKyungmin Park /** 174ff94bc40SHeiko Schocher * ubi_volume_notify - send a volume change notification. 175ff94bc40SHeiko Schocher * @ubi: UBI device description object 176ff94bc40SHeiko Schocher * @vol: volume description object of the changed volume 177ff94bc40SHeiko Schocher * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc) 178ff94bc40SHeiko Schocher * 179ff94bc40SHeiko Schocher * This is a helper function which notifies all subscribers about a volume 180ff94bc40SHeiko Schocher * change event (creation, removal, re-sizing, re-naming, updating). Returns 181ff94bc40SHeiko Schocher * zero in case of success and a negative error code in case of failure. 182ff94bc40SHeiko Schocher */ 183ff94bc40SHeiko Schocher int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype) 184ff94bc40SHeiko Schocher { 1850195a7bbSHeiko Schocher int ret; 186ff94bc40SHeiko Schocher struct ubi_notification nt; 187ff94bc40SHeiko Schocher 188ff94bc40SHeiko Schocher ubi_do_get_device_info(ubi, &nt.di); 189ff94bc40SHeiko Schocher ubi_do_get_volume_info(ubi, vol, &nt.vi); 190ff94bc40SHeiko Schocher 191ff94bc40SHeiko Schocher switch (ntype) { 192ff94bc40SHeiko Schocher case UBI_VOLUME_ADDED: 193ff94bc40SHeiko Schocher case UBI_VOLUME_REMOVED: 194ff94bc40SHeiko Schocher case UBI_VOLUME_RESIZED: 195ff94bc40SHeiko Schocher case UBI_VOLUME_RENAMED: 1960195a7bbSHeiko Schocher ret = ubi_update_fastmap(ubi); 1970195a7bbSHeiko Schocher if (ret) 1980195a7bbSHeiko Schocher ubi_msg(ubi, "Unable to write a new fastmap: %i", ret); 199ff94bc40SHeiko Schocher } 2000195a7bbSHeiko Schocher 201ff94bc40SHeiko Schocher return blocking_notifier_call_chain(&ubi_notifiers, ntype, &nt); 202ff94bc40SHeiko Schocher } 203ff94bc40SHeiko Schocher 204ff94bc40SHeiko Schocher /** 205ff94bc40SHeiko Schocher * ubi_notify_all - send a notification to all volumes. 206ff94bc40SHeiko Schocher * @ubi: UBI device description object 207ff94bc40SHeiko Schocher * @ntype: notification type to send (%UBI_VOLUME_ADDED, etc) 208ff94bc40SHeiko Schocher * @nb: the notifier to call 209ff94bc40SHeiko Schocher * 210ff94bc40SHeiko Schocher * This function walks all volumes of UBI device @ubi and sends the @ntype 211ff94bc40SHeiko Schocher * notification for each volume. If @nb is %NULL, then all registered notifiers 212ff94bc40SHeiko Schocher * are called, otherwise only the @nb notifier is called. Returns the number of 213ff94bc40SHeiko Schocher * sent notifications. 214ff94bc40SHeiko Schocher */ 215ff94bc40SHeiko Schocher int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb) 216ff94bc40SHeiko Schocher { 217ff94bc40SHeiko Schocher struct ubi_notification nt; 218ff94bc40SHeiko Schocher int i, count = 0; 219ff94bc40SHeiko Schocher #ifndef __UBOOT__ 220ff94bc40SHeiko Schocher int ret; 221ff94bc40SHeiko Schocher #endif 222ff94bc40SHeiko Schocher 223ff94bc40SHeiko Schocher ubi_do_get_device_info(ubi, &nt.di); 224ff94bc40SHeiko Schocher 225ff94bc40SHeiko Schocher mutex_lock(&ubi->device_mutex); 226ff94bc40SHeiko Schocher for (i = 0; i < ubi->vtbl_slots; i++) { 227ff94bc40SHeiko Schocher /* 228ff94bc40SHeiko Schocher * Since the @ubi->device is locked, and we are not going to 229ff94bc40SHeiko Schocher * change @ubi->volumes, we do not have to lock 230ff94bc40SHeiko Schocher * @ubi->volumes_lock. 231ff94bc40SHeiko Schocher */ 232ff94bc40SHeiko Schocher if (!ubi->volumes[i]) 233ff94bc40SHeiko Schocher continue; 234ff94bc40SHeiko Schocher 235ff94bc40SHeiko Schocher ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi); 236ff94bc40SHeiko Schocher #ifndef __UBOOT__ 237ff94bc40SHeiko Schocher if (nb) 238ff94bc40SHeiko Schocher nb->notifier_call(nb, ntype, &nt); 239ff94bc40SHeiko Schocher else 240ff94bc40SHeiko Schocher ret = blocking_notifier_call_chain(&ubi_notifiers, ntype, 241ff94bc40SHeiko Schocher &nt); 242ff94bc40SHeiko Schocher #endif 243ff94bc40SHeiko Schocher count += 1; 244ff94bc40SHeiko Schocher } 245ff94bc40SHeiko Schocher mutex_unlock(&ubi->device_mutex); 246ff94bc40SHeiko Schocher 247ff94bc40SHeiko Schocher return count; 248ff94bc40SHeiko Schocher } 249ff94bc40SHeiko Schocher 250ff94bc40SHeiko Schocher /** 251ff94bc40SHeiko Schocher * ubi_enumerate_volumes - send "add" notification for all existing volumes. 252ff94bc40SHeiko Schocher * @nb: the notifier to call 253ff94bc40SHeiko Schocher * 254ff94bc40SHeiko Schocher * This function walks all UBI devices and volumes and sends the 255ff94bc40SHeiko Schocher * %UBI_VOLUME_ADDED notification for each volume. If @nb is %NULL, then all 256ff94bc40SHeiko Schocher * registered notifiers are called, otherwise only the @nb notifier is called. 257ff94bc40SHeiko Schocher * Returns the number of sent notifications. 258ff94bc40SHeiko Schocher */ 259ff94bc40SHeiko Schocher int ubi_enumerate_volumes(struct notifier_block *nb) 260ff94bc40SHeiko Schocher { 261ff94bc40SHeiko Schocher int i, count = 0; 262ff94bc40SHeiko Schocher 263ff94bc40SHeiko Schocher /* 264ff94bc40SHeiko Schocher * Since the @ubi_devices_mutex is locked, and we are not going to 265ff94bc40SHeiko Schocher * change @ubi_devices, we do not have to lock @ubi_devices_lock. 266ff94bc40SHeiko Schocher */ 267ff94bc40SHeiko Schocher for (i = 0; i < UBI_MAX_DEVICES; i++) { 268ff94bc40SHeiko Schocher struct ubi_device *ubi = ubi_devices[i]; 269ff94bc40SHeiko Schocher 270ff94bc40SHeiko Schocher if (!ubi) 271ff94bc40SHeiko Schocher continue; 272ff94bc40SHeiko Schocher count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb); 273ff94bc40SHeiko Schocher } 274ff94bc40SHeiko Schocher 275ff94bc40SHeiko Schocher return count; 276ff94bc40SHeiko Schocher } 277ff94bc40SHeiko Schocher 278ff94bc40SHeiko Schocher /** 279f399d4a2SKyungmin Park * ubi_get_device - get UBI device. 280f399d4a2SKyungmin Park * @ubi_num: UBI device number 281f399d4a2SKyungmin Park * 282f399d4a2SKyungmin Park * This function returns UBI device description object for UBI device number 283f399d4a2SKyungmin Park * @ubi_num, or %NULL if the device does not exist. This function increases the 284f399d4a2SKyungmin Park * device reference count to prevent removal of the device. In other words, the 285f399d4a2SKyungmin Park * device cannot be removed if its reference count is not zero. 286f399d4a2SKyungmin Park */ 287f399d4a2SKyungmin Park struct ubi_device *ubi_get_device(int ubi_num) 288f399d4a2SKyungmin Park { 289f399d4a2SKyungmin Park struct ubi_device *ubi; 290f399d4a2SKyungmin Park 291f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 292f399d4a2SKyungmin Park ubi = ubi_devices[ubi_num]; 293f399d4a2SKyungmin Park if (ubi) { 294f399d4a2SKyungmin Park ubi_assert(ubi->ref_count >= 0); 295f399d4a2SKyungmin Park ubi->ref_count += 1; 296f399d4a2SKyungmin Park get_device(&ubi->dev); 297f399d4a2SKyungmin Park } 298f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 299f399d4a2SKyungmin Park 300f399d4a2SKyungmin Park return ubi; 301f399d4a2SKyungmin Park } 302f399d4a2SKyungmin Park 303f399d4a2SKyungmin Park /** 304f399d4a2SKyungmin Park * ubi_put_device - drop an UBI device reference. 305f399d4a2SKyungmin Park * @ubi: UBI device description object 306f399d4a2SKyungmin Park */ 307f399d4a2SKyungmin Park void ubi_put_device(struct ubi_device *ubi) 308f399d4a2SKyungmin Park { 309f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 310f399d4a2SKyungmin Park ubi->ref_count -= 1; 311f399d4a2SKyungmin Park put_device(&ubi->dev); 312f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 313f399d4a2SKyungmin Park } 314f399d4a2SKyungmin Park 315f399d4a2SKyungmin Park /** 316ff94bc40SHeiko Schocher * ubi_get_by_major - get UBI device by character device major number. 317f399d4a2SKyungmin Park * @major: major number 318f399d4a2SKyungmin Park * 319f399d4a2SKyungmin Park * This function is similar to 'ubi_get_device()', but it searches the device 320f399d4a2SKyungmin Park * by its major number. 321f399d4a2SKyungmin Park */ 322f399d4a2SKyungmin Park struct ubi_device *ubi_get_by_major(int major) 323f399d4a2SKyungmin Park { 324f399d4a2SKyungmin Park int i; 325f399d4a2SKyungmin Park struct ubi_device *ubi; 326f399d4a2SKyungmin Park 327f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 328f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 329f399d4a2SKyungmin Park ubi = ubi_devices[i]; 330f399d4a2SKyungmin Park if (ubi && MAJOR(ubi->cdev.dev) == major) { 331f399d4a2SKyungmin Park ubi_assert(ubi->ref_count >= 0); 332f399d4a2SKyungmin Park ubi->ref_count += 1; 333f399d4a2SKyungmin Park get_device(&ubi->dev); 334f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 335f399d4a2SKyungmin Park return ubi; 336f399d4a2SKyungmin Park } 337f399d4a2SKyungmin Park } 338f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 339f399d4a2SKyungmin Park 340f399d4a2SKyungmin Park return NULL; 341f399d4a2SKyungmin Park } 342f399d4a2SKyungmin Park 343f399d4a2SKyungmin Park /** 344f399d4a2SKyungmin Park * ubi_major2num - get UBI device number by character device major number. 345f399d4a2SKyungmin Park * @major: major number 346f399d4a2SKyungmin Park * 347f399d4a2SKyungmin Park * This function searches UBI device number object by its major number. If UBI 348f399d4a2SKyungmin Park * device was not found, this function returns -ENODEV, otherwise the UBI device 349f399d4a2SKyungmin Park * number is returned. 350f399d4a2SKyungmin Park */ 351f399d4a2SKyungmin Park int ubi_major2num(int major) 352f399d4a2SKyungmin Park { 353f399d4a2SKyungmin Park int i, ubi_num = -ENODEV; 354f399d4a2SKyungmin Park 355f399d4a2SKyungmin Park spin_lock(&ubi_devices_lock); 356f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 357f399d4a2SKyungmin Park struct ubi_device *ubi = ubi_devices[i]; 358f399d4a2SKyungmin Park 359f399d4a2SKyungmin Park if (ubi && MAJOR(ubi->cdev.dev) == major) { 360f399d4a2SKyungmin Park ubi_num = ubi->ubi_num; 361f399d4a2SKyungmin Park break; 362f399d4a2SKyungmin Park } 363f399d4a2SKyungmin Park } 364f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 365f399d4a2SKyungmin Park 366f399d4a2SKyungmin Park return ubi_num; 367f399d4a2SKyungmin Park } 368f399d4a2SKyungmin Park 369ff94bc40SHeiko Schocher #ifndef __UBOOT__ 370f399d4a2SKyungmin Park /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */ 371f399d4a2SKyungmin Park static ssize_t dev_attribute_show(struct device *dev, 372f399d4a2SKyungmin Park struct device_attribute *attr, char *buf) 373f399d4a2SKyungmin Park { 374f399d4a2SKyungmin Park ssize_t ret; 375f399d4a2SKyungmin Park struct ubi_device *ubi; 376f399d4a2SKyungmin Park 377f399d4a2SKyungmin Park /* 378f399d4a2SKyungmin Park * The below code looks weird, but it actually makes sense. We get the 379f399d4a2SKyungmin Park * UBI device reference from the contained 'struct ubi_device'. But it 380f399d4a2SKyungmin Park * is unclear if the device was removed or not yet. Indeed, if the 381f399d4a2SKyungmin Park * device was removed before we increased its reference count, 382f399d4a2SKyungmin Park * 'ubi_get_device()' will return -ENODEV and we fail. 383f399d4a2SKyungmin Park * 384f399d4a2SKyungmin Park * Remember, 'struct ubi_device' is freed in the release function, so 385f399d4a2SKyungmin Park * we still can use 'ubi->ubi_num'. 386f399d4a2SKyungmin Park */ 387f399d4a2SKyungmin Park ubi = container_of(dev, struct ubi_device, dev); 388f399d4a2SKyungmin Park ubi = ubi_get_device(ubi->ubi_num); 389f399d4a2SKyungmin Park if (!ubi) 390f399d4a2SKyungmin Park return -ENODEV; 391f399d4a2SKyungmin Park 392f399d4a2SKyungmin Park if (attr == &dev_eraseblock_size) 393f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->leb_size); 394f399d4a2SKyungmin Park else if (attr == &dev_avail_eraseblocks) 395f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->avail_pebs); 396f399d4a2SKyungmin Park else if (attr == &dev_total_eraseblocks) 397f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->good_peb_count); 398f399d4a2SKyungmin Park else if (attr == &dev_volumes_count) 399f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT); 400f399d4a2SKyungmin Park else if (attr == &dev_max_ec) 401f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->max_ec); 402f399d4a2SKyungmin Park else if (attr == &dev_reserved_for_bad) 403f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs); 404f399d4a2SKyungmin Park else if (attr == &dev_bad_peb_count) 405f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->bad_peb_count); 406f399d4a2SKyungmin Park else if (attr == &dev_max_vol_count) 407f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->vtbl_slots); 408f399d4a2SKyungmin Park else if (attr == &dev_min_io_size) 409f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->min_io_size); 410f399d4a2SKyungmin Park else if (attr == &dev_bgt_enabled) 411f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->thread_enabled); 412f399d4a2SKyungmin Park else if (attr == &dev_mtd_num) 413f399d4a2SKyungmin Park ret = sprintf(buf, "%d\n", ubi->mtd->index); 414f399d4a2SKyungmin Park else 415f399d4a2SKyungmin Park ret = -EINVAL; 416f399d4a2SKyungmin Park 417f399d4a2SKyungmin Park ubi_put_device(ubi); 418f399d4a2SKyungmin Park return ret; 419f399d4a2SKyungmin Park } 420f399d4a2SKyungmin Park 4210195a7bbSHeiko Schocher static struct attribute *ubi_dev_attrs[] = { 4220195a7bbSHeiko Schocher &dev_eraseblock_size.attr, 4230195a7bbSHeiko Schocher &dev_avail_eraseblocks.attr, 4240195a7bbSHeiko Schocher &dev_total_eraseblocks.attr, 4250195a7bbSHeiko Schocher &dev_volumes_count.attr, 4260195a7bbSHeiko Schocher &dev_max_ec.attr, 4270195a7bbSHeiko Schocher &dev_reserved_for_bad.attr, 4280195a7bbSHeiko Schocher &dev_bad_peb_count.attr, 4290195a7bbSHeiko Schocher &dev_max_vol_count.attr, 4300195a7bbSHeiko Schocher &dev_min_io_size.attr, 4310195a7bbSHeiko Schocher &dev_bgt_enabled.attr, 4320195a7bbSHeiko Schocher &dev_mtd_num.attr, 4330195a7bbSHeiko Schocher NULL 4340195a7bbSHeiko Schocher }; 4350195a7bbSHeiko Schocher ATTRIBUTE_GROUPS(ubi_dev); 4360195a7bbSHeiko Schocher 437ff94bc40SHeiko Schocher static void dev_release(struct device *dev) 438ff94bc40SHeiko Schocher { 439ff94bc40SHeiko Schocher struct ubi_device *ubi = container_of(dev, struct ubi_device, dev); 440ff94bc40SHeiko Schocher 441ff94bc40SHeiko Schocher kfree(ubi); 442ff94bc40SHeiko Schocher } 443f399d4a2SKyungmin Park 444f399d4a2SKyungmin Park /** 445f399d4a2SKyungmin Park * ubi_sysfs_init - initialize sysfs for an UBI device. 446f399d4a2SKyungmin Park * @ubi: UBI device description object 447ff94bc40SHeiko Schocher * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was 448ff94bc40SHeiko Schocher * taken 449f399d4a2SKyungmin Park * 450f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 451f399d4a2SKyungmin Park * case of failure. 452f399d4a2SKyungmin Park */ 453ff94bc40SHeiko Schocher static int ubi_sysfs_init(struct ubi_device *ubi, int *ref) 454f399d4a2SKyungmin Park { 455f399d4a2SKyungmin Park int err; 456f399d4a2SKyungmin Park 457f399d4a2SKyungmin Park ubi->dev.release = dev_release; 458f399d4a2SKyungmin Park ubi->dev.devt = ubi->cdev.dev; 4590195a7bbSHeiko Schocher ubi->dev.class = &ubi_class; 4600195a7bbSHeiko Schocher ubi->dev.groups = ubi_dev_groups; 461ff94bc40SHeiko Schocher dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num); 462f399d4a2SKyungmin Park err = device_register(&ubi->dev); 463f399d4a2SKyungmin Park if (err) 464f399d4a2SKyungmin Park return err; 465f399d4a2SKyungmin Park 466ff94bc40SHeiko Schocher *ref = 1; 4670195a7bbSHeiko Schocher return 0; 468f399d4a2SKyungmin Park } 469f399d4a2SKyungmin Park 470f399d4a2SKyungmin Park /** 471f399d4a2SKyungmin Park * ubi_sysfs_close - close sysfs for an UBI device. 472f399d4a2SKyungmin Park * @ubi: UBI device description object 473f399d4a2SKyungmin Park */ 474f399d4a2SKyungmin Park static void ubi_sysfs_close(struct ubi_device *ubi) 475f399d4a2SKyungmin Park { 476f399d4a2SKyungmin Park device_unregister(&ubi->dev); 477f399d4a2SKyungmin Park } 478f399d4a2SKyungmin Park #endif 479f399d4a2SKyungmin Park 480f399d4a2SKyungmin Park /** 481ff94bc40SHeiko Schocher * kill_volumes - destroy all user volumes. 482f399d4a2SKyungmin Park * @ubi: UBI device description object 483f399d4a2SKyungmin Park */ 484f399d4a2SKyungmin Park static void kill_volumes(struct ubi_device *ubi) 485f399d4a2SKyungmin Park { 486f399d4a2SKyungmin Park int i; 487f399d4a2SKyungmin Park 488f399d4a2SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) 489f399d4a2SKyungmin Park if (ubi->volumes[i]) 490f399d4a2SKyungmin Park ubi_free_volume(ubi, ubi->volumes[i]); 491f399d4a2SKyungmin Park } 492f399d4a2SKyungmin Park 493f399d4a2SKyungmin Park /** 494f399d4a2SKyungmin Park * uif_init - initialize user interfaces for an UBI device. 495f399d4a2SKyungmin Park * @ubi: UBI device description object 496ff94bc40SHeiko Schocher * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was 497ff94bc40SHeiko Schocher * taken, otherwise set to %0 498ff94bc40SHeiko Schocher * 499ff94bc40SHeiko Schocher * This function initializes various user interfaces for an UBI device. If the 500ff94bc40SHeiko Schocher * initialization fails at an early stage, this function frees all the 501ff94bc40SHeiko Schocher * resources it allocated, returns an error, and @ref is set to %0. However, 502ff94bc40SHeiko Schocher * if the initialization fails after the UBI device was registered in the 503ff94bc40SHeiko Schocher * driver core subsystem, this function takes a reference to @ubi->dev, because 504ff94bc40SHeiko Schocher * otherwise the release function ('dev_release()') would free whole @ubi 505ff94bc40SHeiko Schocher * object. The @ref argument is set to %1 in this case. The caller has to put 506ff94bc40SHeiko Schocher * this reference. 507f399d4a2SKyungmin Park * 508f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 509f399d4a2SKyungmin Park * case of failure. 510f399d4a2SKyungmin Park */ 511ff94bc40SHeiko Schocher static int uif_init(struct ubi_device *ubi, int *ref) 512f399d4a2SKyungmin Park { 513f399d4a2SKyungmin Park int i, err; 514ff94bc40SHeiko Schocher #ifndef __UBOOT__ 515f399d4a2SKyungmin Park dev_t dev; 516f399d4a2SKyungmin Park #endif 517f399d4a2SKyungmin Park 518ff94bc40SHeiko Schocher *ref = 0; 519f399d4a2SKyungmin Park sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num); 520f399d4a2SKyungmin Park 521f399d4a2SKyungmin Park /* 522f399d4a2SKyungmin Park * Major numbers for the UBI character devices are allocated 523f399d4a2SKyungmin Park * dynamically. Major numbers of volume character devices are 524f399d4a2SKyungmin Park * equivalent to ones of the corresponding UBI character device. Minor 525f399d4a2SKyungmin Park * numbers of UBI character devices are 0, while minor numbers of 526f399d4a2SKyungmin Park * volume character devices start from 1. Thus, we allocate one major 527f399d4a2SKyungmin Park * number and ubi->vtbl_slots + 1 minor numbers. 528f399d4a2SKyungmin Park */ 529f399d4a2SKyungmin Park err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name); 530f399d4a2SKyungmin Park if (err) { 5310195a7bbSHeiko Schocher ubi_err(ubi, "cannot register UBI character devices"); 532f399d4a2SKyungmin Park return err; 533f399d4a2SKyungmin Park } 534f399d4a2SKyungmin Park 535f399d4a2SKyungmin Park ubi_assert(MINOR(dev) == 0); 536f399d4a2SKyungmin Park cdev_init(&ubi->cdev, &ubi_cdev_operations); 537ff94bc40SHeiko Schocher dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev)); 538f399d4a2SKyungmin Park ubi->cdev.owner = THIS_MODULE; 539f399d4a2SKyungmin Park 540f399d4a2SKyungmin Park err = cdev_add(&ubi->cdev, dev, 1); 541f399d4a2SKyungmin Park if (err) { 5420195a7bbSHeiko Schocher ubi_err(ubi, "cannot add character device"); 543f399d4a2SKyungmin Park goto out_unreg; 544f399d4a2SKyungmin Park } 545f399d4a2SKyungmin Park 546ff94bc40SHeiko Schocher err = ubi_sysfs_init(ubi, ref); 547f399d4a2SKyungmin Park if (err) 548f399d4a2SKyungmin Park goto out_sysfs; 549f399d4a2SKyungmin Park 550f399d4a2SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) 551f399d4a2SKyungmin Park if (ubi->volumes[i]) { 552f399d4a2SKyungmin Park err = ubi_add_volume(ubi, ubi->volumes[i]); 553f399d4a2SKyungmin Park if (err) { 5540195a7bbSHeiko Schocher ubi_err(ubi, "cannot add volume %d", i); 555f399d4a2SKyungmin Park goto out_volumes; 556f399d4a2SKyungmin Park } 557f399d4a2SKyungmin Park } 558f399d4a2SKyungmin Park 559f399d4a2SKyungmin Park return 0; 560f399d4a2SKyungmin Park 561f399d4a2SKyungmin Park out_volumes: 562f399d4a2SKyungmin Park kill_volumes(ubi); 563f399d4a2SKyungmin Park out_sysfs: 564ff94bc40SHeiko Schocher if (*ref) 565ff94bc40SHeiko Schocher get_device(&ubi->dev); 566f399d4a2SKyungmin Park ubi_sysfs_close(ubi); 567f399d4a2SKyungmin Park cdev_del(&ubi->cdev); 568f399d4a2SKyungmin Park out_unreg: 569f399d4a2SKyungmin Park unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 5700195a7bbSHeiko Schocher ubi_err(ubi, "cannot initialize UBI %s, error %d", 5710195a7bbSHeiko Schocher ubi->ubi_name, err); 572f399d4a2SKyungmin Park return err; 573f399d4a2SKyungmin Park } 574f399d4a2SKyungmin Park 575f399d4a2SKyungmin Park /** 576f399d4a2SKyungmin Park * uif_close - close user interfaces for an UBI device. 577f399d4a2SKyungmin Park * @ubi: UBI device description object 578ff94bc40SHeiko Schocher * 579ff94bc40SHeiko Schocher * Note, since this function un-registers UBI volume device objects (@vol->dev), 580ff94bc40SHeiko Schocher * the memory allocated voe the volumes is freed as well (in the release 581ff94bc40SHeiko Schocher * function). 582f399d4a2SKyungmin Park */ 583f399d4a2SKyungmin Park static void uif_close(struct ubi_device *ubi) 584f399d4a2SKyungmin Park { 585f399d4a2SKyungmin Park kill_volumes(ubi); 586f399d4a2SKyungmin Park ubi_sysfs_close(ubi); 587f399d4a2SKyungmin Park cdev_del(&ubi->cdev); 588f399d4a2SKyungmin Park unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1); 589f399d4a2SKyungmin Park } 590f399d4a2SKyungmin Park 591f399d4a2SKyungmin Park /** 592ff94bc40SHeiko Schocher * ubi_free_internal_volumes - free internal volumes. 593ff94bc40SHeiko Schocher * @ubi: UBI device description object 594f399d4a2SKyungmin Park */ 595ff94bc40SHeiko Schocher void ubi_free_internal_volumes(struct ubi_device *ubi) 596f399d4a2SKyungmin Park { 597ff94bc40SHeiko Schocher int i; 598f399d4a2SKyungmin Park 599ff94bc40SHeiko Schocher for (i = ubi->vtbl_slots; 600ff94bc40SHeiko Schocher i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) { 601ff94bc40SHeiko Schocher kfree(ubi->volumes[i]->eba_tbl); 602ff94bc40SHeiko Schocher kfree(ubi->volumes[i]); 603ff94bc40SHeiko Schocher } 604ff94bc40SHeiko Schocher } 605f399d4a2SKyungmin Park 606ff94bc40SHeiko Schocher static int get_bad_peb_limit(const struct ubi_device *ubi, int max_beb_per1024) 607ff94bc40SHeiko Schocher { 608ff94bc40SHeiko Schocher int limit, device_pebs; 609ff94bc40SHeiko Schocher uint64_t device_size; 610f399d4a2SKyungmin Park 611ff94bc40SHeiko Schocher if (!max_beb_per1024) 612f399d4a2SKyungmin Park return 0; 613f399d4a2SKyungmin Park 614ff94bc40SHeiko Schocher /* 615ff94bc40SHeiko Schocher * Here we are using size of the entire flash chip and 616ff94bc40SHeiko Schocher * not just the MTD partition size because the maximum 617ff94bc40SHeiko Schocher * number of bad eraseblocks is a percentage of the 618ff94bc40SHeiko Schocher * whole device and bad eraseblocks are not fairly 619ff94bc40SHeiko Schocher * distributed over the flash chip. So the worst case 620ff94bc40SHeiko Schocher * is that all the bad eraseblocks of the chip are in 621ff94bc40SHeiko Schocher * the MTD partition we are attaching (ubi->mtd). 622ff94bc40SHeiko Schocher */ 623ff94bc40SHeiko Schocher device_size = mtd_get_device_size(ubi->mtd); 624ff94bc40SHeiko Schocher device_pebs = mtd_div_by_eb(device_size, ubi->mtd); 625ff94bc40SHeiko Schocher limit = mult_frac(device_pebs, max_beb_per1024, 1024); 626ff94bc40SHeiko Schocher 627ff94bc40SHeiko Schocher /* Round it up */ 628ff94bc40SHeiko Schocher if (mult_frac(limit, 1024, max_beb_per1024) < device_pebs) 629ff94bc40SHeiko Schocher limit += 1; 630ff94bc40SHeiko Schocher 631ff94bc40SHeiko Schocher return limit; 632f399d4a2SKyungmin Park } 633f399d4a2SKyungmin Park 634f399d4a2SKyungmin Park /** 635ff94bc40SHeiko Schocher * io_init - initialize I/O sub-system for a given UBI device. 636f399d4a2SKyungmin Park * @ubi: UBI device description object 637ff94bc40SHeiko Schocher * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs 638f399d4a2SKyungmin Park * 639f399d4a2SKyungmin Park * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are 640f399d4a2SKyungmin Park * assumed: 641f399d4a2SKyungmin Park * o EC header is always at offset zero - this cannot be changed; 642f399d4a2SKyungmin Park * o VID header starts just after the EC header at the closest address 643f399d4a2SKyungmin Park * aligned to @io->hdrs_min_io_size; 644f399d4a2SKyungmin Park * o data starts just after the VID header at the closest address aligned to 645f399d4a2SKyungmin Park * @io->min_io_size 646f399d4a2SKyungmin Park * 647f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 648f399d4a2SKyungmin Park * case of failure. 649f399d4a2SKyungmin Park */ 650ff94bc40SHeiko Schocher static int io_init(struct ubi_device *ubi, int max_beb_per1024) 651f399d4a2SKyungmin Park { 652ff94bc40SHeiko Schocher dbg_gen("sizeof(struct ubi_ainf_peb) %zu", sizeof(struct ubi_ainf_peb)); 653ff94bc40SHeiko Schocher dbg_gen("sizeof(struct ubi_wl_entry) %zu", sizeof(struct ubi_wl_entry)); 654ff94bc40SHeiko Schocher 655f399d4a2SKyungmin Park if (ubi->mtd->numeraseregions != 0) { 656f399d4a2SKyungmin Park /* 657f399d4a2SKyungmin Park * Some flashes have several erase regions. Different regions 658f399d4a2SKyungmin Park * may have different eraseblock size and other 659f399d4a2SKyungmin Park * characteristics. It looks like mostly multi-region flashes 660f399d4a2SKyungmin Park * have one "main" region and one or more small regions to 661f399d4a2SKyungmin Park * store boot loader code or boot parameters or whatever. I 662f399d4a2SKyungmin Park * guess we should just pick the largest region. But this is 663f399d4a2SKyungmin Park * not implemented. 664f399d4a2SKyungmin Park */ 6650195a7bbSHeiko Schocher ubi_err(ubi, "multiple regions, not implemented"); 666f399d4a2SKyungmin Park return -EINVAL; 667f399d4a2SKyungmin Park } 668f399d4a2SKyungmin Park 669f399d4a2SKyungmin Park if (ubi->vid_hdr_offset < 0) 670f399d4a2SKyungmin Park return -EINVAL; 671f399d4a2SKyungmin Park 672f399d4a2SKyungmin Park /* 673f399d4a2SKyungmin Park * Note, in this implementation we support MTD devices with 0x7FFFFFFF 674f399d4a2SKyungmin Park * physical eraseblocks maximum. 675f399d4a2SKyungmin Park */ 676f399d4a2SKyungmin Park 677f399d4a2SKyungmin Park ubi->peb_size = ubi->mtd->erasesize; 678d318d0c4SStefan Roese ubi->peb_count = mtd_div_by_eb(ubi->mtd->size, ubi->mtd); 679f399d4a2SKyungmin Park ubi->flash_size = ubi->mtd->size; 680f399d4a2SKyungmin Park 681ff94bc40SHeiko Schocher if (mtd_can_have_bb(ubi->mtd)) { 682f399d4a2SKyungmin Park ubi->bad_allowed = 1; 683ff94bc40SHeiko Schocher ubi->bad_peb_limit = get_bad_peb_limit(ubi, max_beb_per1024); 684ff94bc40SHeiko Schocher } 685ff94bc40SHeiko Schocher 686ff94bc40SHeiko Schocher if (ubi->mtd->type == MTD_NORFLASH) { 687ff94bc40SHeiko Schocher ubi_assert(ubi->mtd->writesize == 1); 688ff94bc40SHeiko Schocher ubi->nor_flash = 1; 689ff94bc40SHeiko Schocher } 690f399d4a2SKyungmin Park 691f399d4a2SKyungmin Park ubi->min_io_size = ubi->mtd->writesize; 692f399d4a2SKyungmin Park ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft; 693f399d4a2SKyungmin Park 694f399d4a2SKyungmin Park /* 695f399d4a2SKyungmin Park * Make sure minimal I/O unit is power of 2. Note, there is no 696f399d4a2SKyungmin Park * fundamental reason for this assumption. It is just an optimization 697f399d4a2SKyungmin Park * which allows us to avoid costly division operations. 698f399d4a2SKyungmin Park */ 699f399d4a2SKyungmin Park if (!is_power_of_2(ubi->min_io_size)) { 7000195a7bbSHeiko Schocher ubi_err(ubi, "min. I/O unit (%d) is not power of 2", 701f399d4a2SKyungmin Park ubi->min_io_size); 702f399d4a2SKyungmin Park return -EINVAL; 703f399d4a2SKyungmin Park } 704f399d4a2SKyungmin Park 705f399d4a2SKyungmin Park ubi_assert(ubi->hdrs_min_io_size > 0); 706f399d4a2SKyungmin Park ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size); 707f399d4a2SKyungmin Park ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0); 708f399d4a2SKyungmin Park 709ff94bc40SHeiko Schocher ubi->max_write_size = ubi->mtd->writebufsize; 710ff94bc40SHeiko Schocher /* 711ff94bc40SHeiko Schocher * Maximum write size has to be greater or equivalent to min. I/O 712ff94bc40SHeiko Schocher * size, and be multiple of min. I/O size. 713ff94bc40SHeiko Schocher */ 714ff94bc40SHeiko Schocher if (ubi->max_write_size < ubi->min_io_size || 715ff94bc40SHeiko Schocher ubi->max_write_size % ubi->min_io_size || 716ff94bc40SHeiko Schocher !is_power_of_2(ubi->max_write_size)) { 7170195a7bbSHeiko Schocher ubi_err(ubi, "bad write buffer size %d for %d min. I/O unit", 718ff94bc40SHeiko Schocher ubi->max_write_size, ubi->min_io_size); 719ff94bc40SHeiko Schocher return -EINVAL; 720ff94bc40SHeiko Schocher } 721ff94bc40SHeiko Schocher 722f399d4a2SKyungmin Park /* Calculate default aligned sizes of EC and VID headers */ 723f399d4a2SKyungmin Park ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size); 724f399d4a2SKyungmin Park ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size); 725f399d4a2SKyungmin Park 726ff94bc40SHeiko Schocher dbg_gen("min_io_size %d", ubi->min_io_size); 727ff94bc40SHeiko Schocher dbg_gen("max_write_size %d", ubi->max_write_size); 728ff94bc40SHeiko Schocher dbg_gen("hdrs_min_io_size %d", ubi->hdrs_min_io_size); 729ff94bc40SHeiko Schocher dbg_gen("ec_hdr_alsize %d", ubi->ec_hdr_alsize); 730ff94bc40SHeiko Schocher dbg_gen("vid_hdr_alsize %d", ubi->vid_hdr_alsize); 731f399d4a2SKyungmin Park 732f399d4a2SKyungmin Park if (ubi->vid_hdr_offset == 0) 733f399d4a2SKyungmin Park /* Default offset */ 734f399d4a2SKyungmin Park ubi->vid_hdr_offset = ubi->vid_hdr_aloffset = 735f399d4a2SKyungmin Park ubi->ec_hdr_alsize; 736f399d4a2SKyungmin Park else { 737f399d4a2SKyungmin Park ubi->vid_hdr_aloffset = ubi->vid_hdr_offset & 738f399d4a2SKyungmin Park ~(ubi->hdrs_min_io_size - 1); 739f399d4a2SKyungmin Park ubi->vid_hdr_shift = ubi->vid_hdr_offset - 740f399d4a2SKyungmin Park ubi->vid_hdr_aloffset; 741f399d4a2SKyungmin Park } 742f399d4a2SKyungmin Park 743f399d4a2SKyungmin Park /* Similar for the data offset */ 744ff94bc40SHeiko Schocher ubi->leb_start = ubi->vid_hdr_offset + UBI_VID_HDR_SIZE; 745f399d4a2SKyungmin Park ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size); 746f399d4a2SKyungmin Park 747ff94bc40SHeiko Schocher dbg_gen("vid_hdr_offset %d", ubi->vid_hdr_offset); 748ff94bc40SHeiko Schocher dbg_gen("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset); 749ff94bc40SHeiko Schocher dbg_gen("vid_hdr_shift %d", ubi->vid_hdr_shift); 750ff94bc40SHeiko Schocher dbg_gen("leb_start %d", ubi->leb_start); 751f399d4a2SKyungmin Park 752f399d4a2SKyungmin Park /* The shift must be aligned to 32-bit boundary */ 753f399d4a2SKyungmin Park if (ubi->vid_hdr_shift % 4) { 7540195a7bbSHeiko Schocher ubi_err(ubi, "unaligned VID header shift %d", 755f399d4a2SKyungmin Park ubi->vid_hdr_shift); 756f399d4a2SKyungmin Park return -EINVAL; 757f399d4a2SKyungmin Park } 758f399d4a2SKyungmin Park 759f399d4a2SKyungmin Park /* Check sanity */ 760f399d4a2SKyungmin Park if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE || 761f399d4a2SKyungmin Park ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE || 762f399d4a2SKyungmin Park ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE || 763f399d4a2SKyungmin Park ubi->leb_start & (ubi->min_io_size - 1)) { 7640195a7bbSHeiko Schocher ubi_err(ubi, "bad VID header (%d) or data offsets (%d)", 765f399d4a2SKyungmin Park ubi->vid_hdr_offset, ubi->leb_start); 766f399d4a2SKyungmin Park return -EINVAL; 767f399d4a2SKyungmin Park } 768f399d4a2SKyungmin Park 769f399d4a2SKyungmin Park /* 770ff94bc40SHeiko Schocher * Set maximum amount of physical erroneous eraseblocks to be 10%. 771ff94bc40SHeiko Schocher * Erroneous PEB are those which have read errors. 772ff94bc40SHeiko Schocher */ 773ff94bc40SHeiko Schocher ubi->max_erroneous = ubi->peb_count / 10; 774ff94bc40SHeiko Schocher if (ubi->max_erroneous < 16) 775ff94bc40SHeiko Schocher ubi->max_erroneous = 16; 776ff94bc40SHeiko Schocher dbg_gen("max_erroneous %d", ubi->max_erroneous); 777ff94bc40SHeiko Schocher 778ff94bc40SHeiko Schocher /* 779f399d4a2SKyungmin Park * It may happen that EC and VID headers are situated in one minimal 780f399d4a2SKyungmin Park * I/O unit. In this case we can only accept this UBI image in 781f399d4a2SKyungmin Park * read-only mode. 782f399d4a2SKyungmin Park */ 783f399d4a2SKyungmin Park if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) { 7840195a7bbSHeiko Schocher ubi_warn(ubi, "EC and VID headers are in the same minimal I/O unit, switch to read-only mode"); 785f399d4a2SKyungmin Park ubi->ro_mode = 1; 786f399d4a2SKyungmin Park } 787f399d4a2SKyungmin Park 788f399d4a2SKyungmin Park ubi->leb_size = ubi->peb_size - ubi->leb_start; 789f399d4a2SKyungmin Park 790f399d4a2SKyungmin Park if (!(ubi->mtd->flags & MTD_WRITEABLE)) { 7910195a7bbSHeiko Schocher ubi_msg(ubi, "MTD device %d is write-protected, attach in read-only mode", 792ff94bc40SHeiko Schocher ubi->mtd->index); 793f399d4a2SKyungmin Park ubi->ro_mode = 1; 794f399d4a2SKyungmin Park } 795f399d4a2SKyungmin Park 796f399d4a2SKyungmin Park /* 797ff94bc40SHeiko Schocher * Note, ideally, we have to initialize @ubi->bad_peb_count here. But 798f399d4a2SKyungmin Park * unfortunately, MTD does not provide this information. We should loop 799f399d4a2SKyungmin Park * over all physical eraseblocks and invoke mtd->block_is_bad() for 800ff94bc40SHeiko Schocher * each physical eraseblock. So, we leave @ubi->bad_peb_count 801ff94bc40SHeiko Schocher * uninitialized so far. 802f399d4a2SKyungmin Park */ 803f399d4a2SKyungmin Park 804f399d4a2SKyungmin Park return 0; 805f399d4a2SKyungmin Park } 806f399d4a2SKyungmin Park 807f399d4a2SKyungmin Park /** 808f399d4a2SKyungmin Park * autoresize - re-size the volume which has the "auto-resize" flag set. 809f399d4a2SKyungmin Park * @ubi: UBI device description object 810f399d4a2SKyungmin Park * @vol_id: ID of the volume to re-size 811f399d4a2SKyungmin Park * 812ff94bc40SHeiko Schocher * This function re-sizes the volume marked by the %UBI_VTBL_AUTORESIZE_FLG in 813f399d4a2SKyungmin Park * the volume table to the largest possible size. See comments in ubi-header.h 814f399d4a2SKyungmin Park * for more description of the flag. Returns zero in case of success and a 815f399d4a2SKyungmin Park * negative error code in case of failure. 816f399d4a2SKyungmin Park */ 817f399d4a2SKyungmin Park static int autoresize(struct ubi_device *ubi, int vol_id) 818f399d4a2SKyungmin Park { 819f399d4a2SKyungmin Park struct ubi_volume_desc desc; 820f399d4a2SKyungmin Park struct ubi_volume *vol = ubi->volumes[vol_id]; 821f399d4a2SKyungmin Park int err, old_reserved_pebs = vol->reserved_pebs; 822f399d4a2SKyungmin Park 823ff94bc40SHeiko Schocher if (ubi->ro_mode) { 8240195a7bbSHeiko Schocher ubi_warn(ubi, "skip auto-resize because of R/O mode"); 825ff94bc40SHeiko Schocher return 0; 826ff94bc40SHeiko Schocher } 827ff94bc40SHeiko Schocher 828f399d4a2SKyungmin Park /* 829f399d4a2SKyungmin Park * Clear the auto-resize flag in the volume in-memory copy of the 830ff94bc40SHeiko Schocher * volume table, and 'ubi_resize_volume()' will propagate this change 831f399d4a2SKyungmin Park * to the flash. 832f399d4a2SKyungmin Park */ 833f399d4a2SKyungmin Park ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG; 834f399d4a2SKyungmin Park 835f399d4a2SKyungmin Park if (ubi->avail_pebs == 0) { 836f399d4a2SKyungmin Park struct ubi_vtbl_record vtbl_rec; 837f399d4a2SKyungmin Park 838f399d4a2SKyungmin Park /* 839ff94bc40SHeiko Schocher * No available PEBs to re-size the volume, clear the flag on 840f399d4a2SKyungmin Park * flash and exit. 841f399d4a2SKyungmin Park */ 842ff94bc40SHeiko Schocher vtbl_rec = ubi->vtbl[vol_id]; 843f399d4a2SKyungmin Park err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 844f399d4a2SKyungmin Park if (err) 8450195a7bbSHeiko Schocher ubi_err(ubi, "cannot clean auto-resize flag for volume %d", 846f399d4a2SKyungmin Park vol_id); 847f399d4a2SKyungmin Park } else { 848f399d4a2SKyungmin Park desc.vol = vol; 849f399d4a2SKyungmin Park err = ubi_resize_volume(&desc, 850f399d4a2SKyungmin Park old_reserved_pebs + ubi->avail_pebs); 851f399d4a2SKyungmin Park if (err) 8520195a7bbSHeiko Schocher ubi_err(ubi, "cannot auto-resize volume %d", 8530195a7bbSHeiko Schocher vol_id); 854f399d4a2SKyungmin Park } 855f399d4a2SKyungmin Park 856f399d4a2SKyungmin Park if (err) 857f399d4a2SKyungmin Park return err; 858f399d4a2SKyungmin Park 8590195a7bbSHeiko Schocher ubi_msg(ubi, "volume %d (\"%s\") re-sized from %d to %d LEBs", 8600195a7bbSHeiko Schocher vol_id, vol->name, old_reserved_pebs, vol->reserved_pebs); 861f399d4a2SKyungmin Park return 0; 862f399d4a2SKyungmin Park } 863f399d4a2SKyungmin Park 864f399d4a2SKyungmin Park /** 865f399d4a2SKyungmin Park * ubi_attach_mtd_dev - attach an MTD device. 866ff94bc40SHeiko Schocher * @mtd: MTD device description object 867f399d4a2SKyungmin Park * @ubi_num: number to assign to the new UBI device 868f399d4a2SKyungmin Park * @vid_hdr_offset: VID header offset 869ff94bc40SHeiko Schocher * @max_beb_per1024: maximum expected number of bad PEB per 1024 PEBs 870f399d4a2SKyungmin Park * 871f399d4a2SKyungmin Park * This function attaches MTD device @mtd_dev to UBI and assign @ubi_num number 872f399d4a2SKyungmin Park * to the newly created UBI device, unless @ubi_num is %UBI_DEV_NUM_AUTO, in 873ff94bc40SHeiko Schocher * which case this function finds a vacant device number and assigns it 874f399d4a2SKyungmin Park * automatically. Returns the new UBI device number in case of success and a 875f399d4a2SKyungmin Park * negative error code in case of failure. 876f399d4a2SKyungmin Park * 877f399d4a2SKyungmin Park * Note, the invocations of this function has to be serialized by the 878f399d4a2SKyungmin Park * @ubi_devices_mutex. 879f399d4a2SKyungmin Park */ 880ff94bc40SHeiko Schocher int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, 881ff94bc40SHeiko Schocher int vid_hdr_offset, int max_beb_per1024) 882f399d4a2SKyungmin Park { 883f399d4a2SKyungmin Park struct ubi_device *ubi; 884ff94bc40SHeiko Schocher int i, err, ref = 0; 885ff94bc40SHeiko Schocher 886ff94bc40SHeiko Schocher if (max_beb_per1024 < 0 || max_beb_per1024 > MAX_MTD_UBI_BEB_LIMIT) 887ff94bc40SHeiko Schocher return -EINVAL; 888ff94bc40SHeiko Schocher 889ff94bc40SHeiko Schocher if (!max_beb_per1024) 890ff94bc40SHeiko Schocher max_beb_per1024 = CONFIG_MTD_UBI_BEB_LIMIT; 891f399d4a2SKyungmin Park 892f399d4a2SKyungmin Park /* 893f399d4a2SKyungmin Park * Check if we already have the same MTD device attached. 894f399d4a2SKyungmin Park * 895f399d4a2SKyungmin Park * Note, this function assumes that UBI devices creations and deletions 896f399d4a2SKyungmin Park * are serialized, so it does not take the &ubi_devices_lock. 897f399d4a2SKyungmin Park */ 898f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) { 899f399d4a2SKyungmin Park ubi = ubi_devices[i]; 900f399d4a2SKyungmin Park if (ubi && mtd->index == ubi->mtd->index) { 9010195a7bbSHeiko Schocher ubi_err(ubi, "mtd%d is already attached to ubi%d", 902f399d4a2SKyungmin Park mtd->index, i); 903f399d4a2SKyungmin Park return -EEXIST; 904f399d4a2SKyungmin Park } 905f399d4a2SKyungmin Park } 906f399d4a2SKyungmin Park 907f399d4a2SKyungmin Park /* 908f399d4a2SKyungmin Park * Make sure this MTD device is not emulated on top of an UBI volume 909f399d4a2SKyungmin Park * already. Well, generally this recursion works fine, but there are 910f399d4a2SKyungmin Park * different problems like the UBI module takes a reference to itself 911f399d4a2SKyungmin Park * by attaching (and thus, opening) the emulated MTD device. This 912f399d4a2SKyungmin Park * results in inability to unload the module. And in general it makes 913f399d4a2SKyungmin Park * no sense to attach emulated MTD devices, so we prohibit this. 914f399d4a2SKyungmin Park */ 915f399d4a2SKyungmin Park if (mtd->type == MTD_UBIVOLUME) { 9160195a7bbSHeiko Schocher ubi_err(ubi, "refuse attaching mtd%d - it is already emulated on top of UBI", 917ff94bc40SHeiko Schocher mtd->index); 918f399d4a2SKyungmin Park return -EINVAL; 919f399d4a2SKyungmin Park } 920f399d4a2SKyungmin Park 921f399d4a2SKyungmin Park if (ubi_num == UBI_DEV_NUM_AUTO) { 922f399d4a2SKyungmin Park /* Search for an empty slot in the @ubi_devices array */ 923f399d4a2SKyungmin Park for (ubi_num = 0; ubi_num < UBI_MAX_DEVICES; ubi_num++) 924f399d4a2SKyungmin Park if (!ubi_devices[ubi_num]) 925f399d4a2SKyungmin Park break; 926f399d4a2SKyungmin Park if (ubi_num == UBI_MAX_DEVICES) { 9270195a7bbSHeiko Schocher ubi_err(ubi, "only %d UBI devices may be created", 928ff94bc40SHeiko Schocher UBI_MAX_DEVICES); 929f399d4a2SKyungmin Park return -ENFILE; 930f399d4a2SKyungmin Park } 931f399d4a2SKyungmin Park } else { 932f399d4a2SKyungmin Park if (ubi_num >= UBI_MAX_DEVICES) 933f399d4a2SKyungmin Park return -EINVAL; 934f399d4a2SKyungmin Park 935f399d4a2SKyungmin Park /* Make sure ubi_num is not busy */ 936f399d4a2SKyungmin Park if (ubi_devices[ubi_num]) { 9370195a7bbSHeiko Schocher ubi_err(ubi, "already exists"); 938f399d4a2SKyungmin Park return -EEXIST; 939f399d4a2SKyungmin Park } 940f399d4a2SKyungmin Park } 941f399d4a2SKyungmin Park 942f399d4a2SKyungmin Park ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL); 943f399d4a2SKyungmin Park if (!ubi) 944f399d4a2SKyungmin Park return -ENOMEM; 945f399d4a2SKyungmin Park 946f399d4a2SKyungmin Park ubi->mtd = mtd; 947f399d4a2SKyungmin Park ubi->ubi_num = ubi_num; 948f399d4a2SKyungmin Park ubi->vid_hdr_offset = vid_hdr_offset; 949f399d4a2SKyungmin Park ubi->autoresize_vol_id = -1; 950f399d4a2SKyungmin Park 951ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 952ff94bc40SHeiko Schocher ubi->fm_pool.used = ubi->fm_pool.size = 0; 953ff94bc40SHeiko Schocher ubi->fm_wl_pool.used = ubi->fm_wl_pool.size = 0; 954ff94bc40SHeiko Schocher 955ff94bc40SHeiko Schocher /* 956ff94bc40SHeiko Schocher * fm_pool.max_size is 5% of the total number of PEBs but it's also 957ff94bc40SHeiko Schocher * between UBI_FM_MAX_POOL_SIZE and UBI_FM_MIN_POOL_SIZE. 958ff94bc40SHeiko Schocher */ 959ff94bc40SHeiko Schocher ubi->fm_pool.max_size = min(((int)mtd_div_by_eb(ubi->mtd->size, 960ff94bc40SHeiko Schocher ubi->mtd) / 100) * 5, UBI_FM_MAX_POOL_SIZE); 9610195a7bbSHeiko Schocher ubi->fm_pool.max_size = max(ubi->fm_pool.max_size, 9620195a7bbSHeiko Schocher UBI_FM_MIN_POOL_SIZE); 963ff94bc40SHeiko Schocher 9640195a7bbSHeiko Schocher ubi->fm_wl_pool.max_size = ubi->fm_pool.max_size / 2; 965ff94bc40SHeiko Schocher ubi->fm_disabled = !fm_autoconvert; 9660195a7bbSHeiko Schocher if (fm_debug) 9670195a7bbSHeiko Schocher ubi_enable_dbg_chk_fastmap(ubi); 968ff94bc40SHeiko Schocher 969ff94bc40SHeiko Schocher if (!ubi->fm_disabled && (int)mtd_div_by_eb(ubi->mtd->size, ubi->mtd) 970ff94bc40SHeiko Schocher <= UBI_FM_MAX_START) { 9710195a7bbSHeiko Schocher ubi_err(ubi, "More than %i PEBs are needed for fastmap, sorry.", 972ff94bc40SHeiko Schocher UBI_FM_MAX_START); 973ff94bc40SHeiko Schocher ubi->fm_disabled = 1; 974ff94bc40SHeiko Schocher } 975ff94bc40SHeiko Schocher 9760195a7bbSHeiko Schocher ubi_msg(ubi, "default fastmap pool size: %d", ubi->fm_pool.max_size); 9770195a7bbSHeiko Schocher ubi_msg(ubi, "default fastmap WL pool size: %d", 9780195a7bbSHeiko Schocher ubi->fm_wl_pool.max_size); 979ff94bc40SHeiko Schocher #else 980ff94bc40SHeiko Schocher ubi->fm_disabled = 1; 981ff94bc40SHeiko Schocher #endif 982f399d4a2SKyungmin Park mutex_init(&ubi->buf_mutex); 983f399d4a2SKyungmin Park mutex_init(&ubi->ckvol_mutex); 984ff94bc40SHeiko Schocher mutex_init(&ubi->device_mutex); 985f399d4a2SKyungmin Park spin_lock_init(&ubi->volumes_lock); 9860195a7bbSHeiko Schocher init_rwsem(&ubi->fm_protect); 9870195a7bbSHeiko Schocher init_rwsem(&ubi->fm_eba_sem); 988f399d4a2SKyungmin Park 9890195a7bbSHeiko Schocher ubi_msg(ubi, "attaching mtd%d", mtd->index); 990f399d4a2SKyungmin Park 991ff94bc40SHeiko Schocher err = io_init(ubi, max_beb_per1024); 992f399d4a2SKyungmin Park if (err) 993f399d4a2SKyungmin Park goto out_free; 994f399d4a2SKyungmin Park 99581732935SStefan Roese err = -ENOMEM; 996ff94bc40SHeiko Schocher ubi->peb_buf = vmalloc(ubi->peb_size); 997ff94bc40SHeiko Schocher if (!ubi->peb_buf) 998f399d4a2SKyungmin Park goto out_free; 999f399d4a2SKyungmin Park 1000ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 1001ff94bc40SHeiko Schocher ubi->fm_size = ubi_calc_fm_size(ubi); 1002ff94bc40SHeiko Schocher ubi->fm_buf = vzalloc(ubi->fm_size); 1003ff94bc40SHeiko Schocher if (!ubi->fm_buf) 1004f399d4a2SKyungmin Park goto out_free; 1005f399d4a2SKyungmin Park #endif 1006ff94bc40SHeiko Schocher err = ubi_attach(ubi, 0); 1007f399d4a2SKyungmin Park if (err) { 10080195a7bbSHeiko Schocher ubi_err(ubi, "failed to attach mtd%d, error %d", 10090195a7bbSHeiko Schocher mtd->index, err); 1010f399d4a2SKyungmin Park goto out_free; 1011f399d4a2SKyungmin Park } 1012f399d4a2SKyungmin Park 1013f399d4a2SKyungmin Park if (ubi->autoresize_vol_id != -1) { 1014f399d4a2SKyungmin Park err = autoresize(ubi, ubi->autoresize_vol_id); 1015f399d4a2SKyungmin Park if (err) 1016f399d4a2SKyungmin Park goto out_detach; 1017f399d4a2SKyungmin Park } 1018f399d4a2SKyungmin Park 1019ff94bc40SHeiko Schocher err = uif_init(ubi, &ref); 1020f399d4a2SKyungmin Park if (err) 1021f399d4a2SKyungmin Park goto out_detach; 1022f399d4a2SKyungmin Park 1023ff94bc40SHeiko Schocher err = ubi_debugfs_init_dev(ubi); 1024ff94bc40SHeiko Schocher if (err) 1025ff94bc40SHeiko Schocher goto out_uif; 1026ff94bc40SHeiko Schocher 1027ff94bc40SHeiko Schocher ubi->bgt_thread = kthread_create(ubi_thread, ubi, "%s", ubi->bgt_name); 1028f399d4a2SKyungmin Park if (IS_ERR(ubi->bgt_thread)) { 1029f399d4a2SKyungmin Park err = PTR_ERR(ubi->bgt_thread); 10300195a7bbSHeiko Schocher ubi_err(ubi, "cannot spawn \"%s\", error %d", 10310195a7bbSHeiko Schocher ubi->bgt_name, err); 1032ff94bc40SHeiko Schocher goto out_debugfs; 1033f399d4a2SKyungmin Park } 1034f399d4a2SKyungmin Park 10350195a7bbSHeiko Schocher ubi_msg(ubi, "attached mtd%d (name \"%s\", size %llu MiB)", 10360195a7bbSHeiko Schocher mtd->index, mtd->name, ubi->flash_size >> 20); 10370195a7bbSHeiko Schocher ubi_msg(ubi, "PEB size: %d bytes (%d KiB), LEB size: %d bytes", 1038ff94bc40SHeiko Schocher ubi->peb_size, ubi->peb_size >> 10, ubi->leb_size); 10390195a7bbSHeiko Schocher ubi_msg(ubi, "min./max. I/O unit sizes: %d/%d, sub-page size %d", 1040ff94bc40SHeiko Schocher ubi->min_io_size, ubi->max_write_size, ubi->hdrs_min_io_size); 10410195a7bbSHeiko Schocher ubi_msg(ubi, "VID header offset: %d (aligned %d), data offset: %d", 1042ff94bc40SHeiko Schocher ubi->vid_hdr_offset, ubi->vid_hdr_aloffset, ubi->leb_start); 10430195a7bbSHeiko Schocher ubi_msg(ubi, "good PEBs: %d, bad PEBs: %d, corrupted PEBs: %d", 1044ff94bc40SHeiko Schocher ubi->good_peb_count, ubi->bad_peb_count, ubi->corr_peb_count); 10450195a7bbSHeiko Schocher ubi_msg(ubi, "user volume: %d, internal volumes: %d, max. volumes count: %d", 1046ff94bc40SHeiko Schocher ubi->vol_count - UBI_INT_VOL_COUNT, UBI_INT_VOL_COUNT, 1047ff94bc40SHeiko Schocher ubi->vtbl_slots); 10480195a7bbSHeiko Schocher ubi_msg(ubi, "max/mean erase counter: %d/%d, WL threshold: %d, image sequence number: %u", 1049ff94bc40SHeiko Schocher ubi->max_ec, ubi->mean_ec, CONFIG_MTD_UBI_WL_THRESHOLD, 1050ff94bc40SHeiko Schocher ubi->image_seq); 10510195a7bbSHeiko Schocher ubi_msg(ubi, "available PEBs: %d, total reserved PEBs: %d, PEBs reserved for bad PEB handling: %d", 1052ff94bc40SHeiko Schocher ubi->avail_pebs, ubi->rsvd_pebs, ubi->beb_rsvd_pebs); 1053f399d4a2SKyungmin Park 1054ff94bc40SHeiko Schocher /* 1055ff94bc40SHeiko Schocher * The below lock makes sure we do not race with 'ubi_thread()' which 1056ff94bc40SHeiko Schocher * checks @ubi->thread_enabled. Otherwise we may fail to wake it up. 1057ff94bc40SHeiko Schocher */ 1058ff94bc40SHeiko Schocher spin_lock(&ubi->wl_lock); 1059f399d4a2SKyungmin Park ubi->thread_enabled = 1; 10600195a7bbSHeiko Schocher #ifndef __UBOOT__ 1061f399d4a2SKyungmin Park wake_up_process(ubi->bgt_thread); 10620195a7bbSHeiko Schocher #else 10630195a7bbSHeiko Schocher /* 10640195a7bbSHeiko Schocher * U-Boot special: We have no bgt_thread in U-Boot! 10650195a7bbSHeiko Schocher * So just call do_work() here directly. 10660195a7bbSHeiko Schocher */ 10670195a7bbSHeiko Schocher err = do_work(ubi); 10680195a7bbSHeiko Schocher if (err) { 10690195a7bbSHeiko Schocher ubi_err(ubi, "%s: work failed with error code %d", 10700195a7bbSHeiko Schocher ubi->bgt_name, err); 10710195a7bbSHeiko Schocher } 10720195a7bbSHeiko Schocher #endif 10730195a7bbSHeiko Schocher 1074ff94bc40SHeiko Schocher spin_unlock(&ubi->wl_lock); 1075f399d4a2SKyungmin Park 1076f399d4a2SKyungmin Park ubi_devices[ubi_num] = ubi; 1077ff94bc40SHeiko Schocher ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL); 1078f399d4a2SKyungmin Park return ubi_num; 1079f399d4a2SKyungmin Park 1080ff94bc40SHeiko Schocher out_debugfs: 1081ff94bc40SHeiko Schocher ubi_debugfs_exit_dev(ubi); 1082f399d4a2SKyungmin Park out_uif: 1083ff94bc40SHeiko Schocher get_device(&ubi->dev); 1084ff94bc40SHeiko Schocher ubi_assert(ref); 1085f399d4a2SKyungmin Park uif_close(ubi); 1086f399d4a2SKyungmin Park out_detach: 1087f399d4a2SKyungmin Park ubi_wl_close(ubi); 1088ff94bc40SHeiko Schocher ubi_free_internal_volumes(ubi); 1089f399d4a2SKyungmin Park vfree(ubi->vtbl); 1090f399d4a2SKyungmin Park out_free: 1091ff94bc40SHeiko Schocher vfree(ubi->peb_buf); 1092ff94bc40SHeiko Schocher vfree(ubi->fm_buf); 1093ff94bc40SHeiko Schocher if (ref) 1094ff94bc40SHeiko Schocher put_device(&ubi->dev); 1095ff94bc40SHeiko Schocher else 1096f399d4a2SKyungmin Park kfree(ubi); 1097f399d4a2SKyungmin Park return err; 1098f399d4a2SKyungmin Park } 1099f399d4a2SKyungmin Park 1100f399d4a2SKyungmin Park /** 1101f399d4a2SKyungmin Park * ubi_detach_mtd_dev - detach an MTD device. 1102f399d4a2SKyungmin Park * @ubi_num: UBI device number to detach from 1103f399d4a2SKyungmin Park * @anyway: detach MTD even if device reference count is not zero 1104f399d4a2SKyungmin Park * 1105f399d4a2SKyungmin Park * This function destroys an UBI device number @ubi_num and detaches the 1106f399d4a2SKyungmin Park * underlying MTD device. Returns zero in case of success and %-EBUSY if the 1107f399d4a2SKyungmin Park * UBI device is busy and cannot be destroyed, and %-EINVAL if it does not 1108f399d4a2SKyungmin Park * exist. 1109f399d4a2SKyungmin Park * 1110f399d4a2SKyungmin Park * Note, the invocations of this function has to be serialized by the 1111f399d4a2SKyungmin Park * @ubi_devices_mutex. 1112f399d4a2SKyungmin Park */ 1113f399d4a2SKyungmin Park int ubi_detach_mtd_dev(int ubi_num, int anyway) 1114f399d4a2SKyungmin Park { 1115f399d4a2SKyungmin Park struct ubi_device *ubi; 1116f399d4a2SKyungmin Park 1117f399d4a2SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 1118f399d4a2SKyungmin Park return -EINVAL; 1119f399d4a2SKyungmin Park 1120ff94bc40SHeiko Schocher ubi = ubi_get_device(ubi_num); 1121ff94bc40SHeiko Schocher if (!ubi) 1122f399d4a2SKyungmin Park return -EINVAL; 1123f399d4a2SKyungmin Park 1124ff94bc40SHeiko Schocher spin_lock(&ubi_devices_lock); 1125ff94bc40SHeiko Schocher put_device(&ubi->dev); 1126ff94bc40SHeiko Schocher ubi->ref_count -= 1; 1127f399d4a2SKyungmin Park if (ubi->ref_count) { 1128f399d4a2SKyungmin Park if (!anyway) { 1129f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 1130f399d4a2SKyungmin Park return -EBUSY; 1131f399d4a2SKyungmin Park } 1132f399d4a2SKyungmin Park /* This may only happen if there is a bug */ 11330195a7bbSHeiko Schocher ubi_err(ubi, "%s reference count %d, destroy anyway", 1134f399d4a2SKyungmin Park ubi->ubi_name, ubi->ref_count); 1135f399d4a2SKyungmin Park } 1136f399d4a2SKyungmin Park ubi_devices[ubi_num] = NULL; 1137f399d4a2SKyungmin Park spin_unlock(&ubi_devices_lock); 1138f399d4a2SKyungmin Park 1139f399d4a2SKyungmin Park ubi_assert(ubi_num == ubi->ubi_num); 1140ff94bc40SHeiko Schocher ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL); 11410195a7bbSHeiko Schocher ubi_msg(ubi, "detaching mtd%d", ubi->mtd->index); 1142ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 1143ff94bc40SHeiko Schocher /* If we don't write a new fastmap at detach time we lose all 11440195a7bbSHeiko Schocher * EC updates that have been made since the last written fastmap. 11450195a7bbSHeiko Schocher * In case of fastmap debugging we omit the update to simulate an 11460195a7bbSHeiko Schocher * unclean shutdown. */ 11470195a7bbSHeiko Schocher if (!ubi_dbg_chk_fastmap(ubi)) 1148ff94bc40SHeiko Schocher ubi_update_fastmap(ubi); 1149ff94bc40SHeiko Schocher #endif 1150f399d4a2SKyungmin Park /* 1151f399d4a2SKyungmin Park * Before freeing anything, we have to stop the background thread to 1152f399d4a2SKyungmin Park * prevent it from doing anything on this device while we are freeing. 1153f399d4a2SKyungmin Park */ 1154f399d4a2SKyungmin Park if (ubi->bgt_thread) 1155f399d4a2SKyungmin Park kthread_stop(ubi->bgt_thread); 1156f399d4a2SKyungmin Park 1157ff94bc40SHeiko Schocher /* 1158ff94bc40SHeiko Schocher * Get a reference to the device in order to prevent 'dev_release()' 1159ff94bc40SHeiko Schocher * from freeing the @ubi object. 1160ff94bc40SHeiko Schocher */ 1161ff94bc40SHeiko Schocher get_device(&ubi->dev); 1162ff94bc40SHeiko Schocher 1163ff94bc40SHeiko Schocher ubi_debugfs_exit_dev(ubi); 1164f399d4a2SKyungmin Park uif_close(ubi); 1165ff94bc40SHeiko Schocher 1166f399d4a2SKyungmin Park ubi_wl_close(ubi); 1167ff94bc40SHeiko Schocher ubi_free_internal_volumes(ubi); 1168f399d4a2SKyungmin Park vfree(ubi->vtbl); 1169f399d4a2SKyungmin Park put_mtd_device(ubi->mtd); 1170ff94bc40SHeiko Schocher vfree(ubi->peb_buf); 1171ff94bc40SHeiko Schocher vfree(ubi->fm_buf); 11720195a7bbSHeiko Schocher ubi_msg(ubi, "mtd%d is detached", ubi->mtd->index); 1173ff94bc40SHeiko Schocher put_device(&ubi->dev); 1174f399d4a2SKyungmin Park return 0; 1175f399d4a2SKyungmin Park } 1176f399d4a2SKyungmin Park 1177ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1178f399d4a2SKyungmin Park /** 1179ff94bc40SHeiko Schocher * open_mtd_by_chdev - open an MTD device by its character device node path. 1180ff94bc40SHeiko Schocher * @mtd_dev: MTD character device node path 1181ff94bc40SHeiko Schocher * 1182ff94bc40SHeiko Schocher * This helper function opens an MTD device by its character node device path. 1183ff94bc40SHeiko Schocher * Returns MTD device description object in case of success and a negative 1184ff94bc40SHeiko Schocher * error code in case of failure. 1185ff94bc40SHeiko Schocher */ 1186ff94bc40SHeiko Schocher static struct mtd_info * __init open_mtd_by_chdev(const char *mtd_dev) 1187ff94bc40SHeiko Schocher { 1188ff94bc40SHeiko Schocher int err, major, minor, mode; 1189ff94bc40SHeiko Schocher struct path path; 1190ff94bc40SHeiko Schocher 1191ff94bc40SHeiko Schocher /* Probably this is an MTD character device node path */ 1192ff94bc40SHeiko Schocher err = kern_path(mtd_dev, LOOKUP_FOLLOW, &path); 1193ff94bc40SHeiko Schocher if (err) 1194ff94bc40SHeiko Schocher return ERR_PTR(err); 1195ff94bc40SHeiko Schocher 1196ff94bc40SHeiko Schocher /* MTD device number is defined by the major / minor numbers */ 11970195a7bbSHeiko Schocher major = imajor(d_backing_inode(path.dentry)); 11980195a7bbSHeiko Schocher minor = iminor(d_backing_inode(path.dentry)); 11990195a7bbSHeiko Schocher mode = d_backing_inode(path.dentry)->i_mode; 1200ff94bc40SHeiko Schocher path_put(&path); 1201ff94bc40SHeiko Schocher if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode)) 1202ff94bc40SHeiko Schocher return ERR_PTR(-EINVAL); 1203ff94bc40SHeiko Schocher 1204ff94bc40SHeiko Schocher if (minor & 1) 1205ff94bc40SHeiko Schocher /* 1206ff94bc40SHeiko Schocher * Just do not think the "/dev/mtdrX" devices support is need, 1207ff94bc40SHeiko Schocher * so do not support them to avoid doing extra work. 1208ff94bc40SHeiko Schocher */ 1209ff94bc40SHeiko Schocher return ERR_PTR(-EINVAL); 1210ff94bc40SHeiko Schocher 1211ff94bc40SHeiko Schocher return get_mtd_device(NULL, minor / 2); 1212ff94bc40SHeiko Schocher } 1213ff94bc40SHeiko Schocher #endif 1214ff94bc40SHeiko Schocher 1215ff94bc40SHeiko Schocher /** 1216ff94bc40SHeiko Schocher * open_mtd_device - open MTD device by name, character device path, or number. 1217ff94bc40SHeiko Schocher * @mtd_dev: name, character device node path, or MTD device device number 1218f399d4a2SKyungmin Park * 1219f399d4a2SKyungmin Park * This function tries to open and MTD device described by @mtd_dev string, 1220ff94bc40SHeiko Schocher * which is first treated as ASCII MTD device number, and if it is not true, it 1221ff94bc40SHeiko Schocher * is treated as MTD device name, and if that is also not true, it is treated 1222ff94bc40SHeiko Schocher * as MTD character device node path. Returns MTD device description object in 1223ff94bc40SHeiko Schocher * case of success and a negative error code in case of failure. 1224f399d4a2SKyungmin Park */ 1225f399d4a2SKyungmin Park static struct mtd_info * __init open_mtd_device(const char *mtd_dev) 1226f399d4a2SKyungmin Park { 1227f399d4a2SKyungmin Park struct mtd_info *mtd; 1228f399d4a2SKyungmin Park int mtd_num; 1229f399d4a2SKyungmin Park char *endp; 1230f399d4a2SKyungmin Park 1231f399d4a2SKyungmin Park mtd_num = simple_strtoul(mtd_dev, &endp, 0); 1232f399d4a2SKyungmin Park if (*endp != '\0' || mtd_dev == endp) { 1233f399d4a2SKyungmin Park /* 1234f399d4a2SKyungmin Park * This does not look like an ASCII integer, probably this is 1235f399d4a2SKyungmin Park * MTD device name. 1236f399d4a2SKyungmin Park */ 1237f399d4a2SKyungmin Park mtd = get_mtd_device_nm(mtd_dev); 1238ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1239ff94bc40SHeiko Schocher if (IS_ERR(mtd) && PTR_ERR(mtd) == -ENODEV) 1240ff94bc40SHeiko Schocher /* Probably this is an MTD character device node path */ 1241ff94bc40SHeiko Schocher mtd = open_mtd_by_chdev(mtd_dev); 1242ff94bc40SHeiko Schocher #endif 1243f399d4a2SKyungmin Park } else 1244f399d4a2SKyungmin Park mtd = get_mtd_device(NULL, mtd_num); 1245f399d4a2SKyungmin Park 1246f399d4a2SKyungmin Park return mtd; 1247f399d4a2SKyungmin Park } 1248f399d4a2SKyungmin Park 1249ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1250ff94bc40SHeiko Schocher static int __init ubi_init(void) 1251ff94bc40SHeiko Schocher #else 1252ff94bc40SHeiko Schocher int ubi_init(void) 1253ff94bc40SHeiko Schocher #endif 1254f399d4a2SKyungmin Park { 1255f399d4a2SKyungmin Park int err, i, k; 1256f399d4a2SKyungmin Park 1257f399d4a2SKyungmin Park /* Ensure that EC and VID headers have correct size */ 1258f399d4a2SKyungmin Park BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64); 1259f399d4a2SKyungmin Park BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64); 1260f399d4a2SKyungmin Park 1261f399d4a2SKyungmin Park if (mtd_devs > UBI_MAX_DEVICES) { 12620195a7bbSHeiko Schocher pr_err("UBI error: too many MTD devices, maximum is %d", 12630195a7bbSHeiko Schocher UBI_MAX_DEVICES); 1264f399d4a2SKyungmin Park return -EINVAL; 1265f399d4a2SKyungmin Park } 1266f399d4a2SKyungmin Park 1267f399d4a2SKyungmin Park /* Create base sysfs directory and sysfs files */ 12680195a7bbSHeiko Schocher err = class_register(&ubi_class); 12690195a7bbSHeiko Schocher if (err < 0) 12700195a7bbSHeiko Schocher return err; 1271f399d4a2SKyungmin Park 1272f399d4a2SKyungmin Park err = misc_register(&ubi_ctrl_cdev); 1273f399d4a2SKyungmin Park if (err) { 12740195a7bbSHeiko Schocher pr_err("UBI error: cannot register device"); 12750195a7bbSHeiko Schocher goto out; 1276f399d4a2SKyungmin Park } 1277f399d4a2SKyungmin Park 1278f399d4a2SKyungmin Park ubi_wl_entry_slab = kmem_cache_create("ubi_wl_entry_slab", 1279f399d4a2SKyungmin Park sizeof(struct ubi_wl_entry), 1280f399d4a2SKyungmin Park 0, 0, NULL); 1281ff94bc40SHeiko Schocher if (!ubi_wl_entry_slab) { 1282ff94bc40SHeiko Schocher err = -ENOMEM; 1283f399d4a2SKyungmin Park goto out_dev_unreg; 1284ff94bc40SHeiko Schocher } 1285ff94bc40SHeiko Schocher 1286ff94bc40SHeiko Schocher err = ubi_debugfs_init(); 1287ff94bc40SHeiko Schocher if (err) 1288ff94bc40SHeiko Schocher goto out_slab; 1289ff94bc40SHeiko Schocher 1290f399d4a2SKyungmin Park 1291f399d4a2SKyungmin Park /* Attach MTD devices */ 1292f399d4a2SKyungmin Park for (i = 0; i < mtd_devs; i++) { 1293f399d4a2SKyungmin Park struct mtd_dev_param *p = &mtd_dev_param[i]; 1294f399d4a2SKyungmin Park struct mtd_info *mtd; 1295f399d4a2SKyungmin Park 1296f399d4a2SKyungmin Park cond_resched(); 1297f399d4a2SKyungmin Park 1298f399d4a2SKyungmin Park mtd = open_mtd_device(p->name); 1299f399d4a2SKyungmin Park if (IS_ERR(mtd)) { 1300f399d4a2SKyungmin Park err = PTR_ERR(mtd); 13010195a7bbSHeiko Schocher pr_err("UBI error: cannot open mtd %s, error %d", 13020195a7bbSHeiko Schocher p->name, err); 1303ff94bc40SHeiko Schocher /* See comment below re-ubi_is_module(). */ 1304ff94bc40SHeiko Schocher if (ubi_is_module()) 1305f399d4a2SKyungmin Park goto out_detach; 1306ff94bc40SHeiko Schocher continue; 1307f399d4a2SKyungmin Park } 1308f399d4a2SKyungmin Park 1309f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1310ff94bc40SHeiko Schocher err = ubi_attach_mtd_dev(mtd, p->ubi_num, 1311ff94bc40SHeiko Schocher p->vid_hdr_offs, p->max_beb_per1024); 1312f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1313f399d4a2SKyungmin Park if (err < 0) { 13140195a7bbSHeiko Schocher pr_err("UBI error: cannot attach mtd%d", 13150195a7bbSHeiko Schocher mtd->index); 1316ff94bc40SHeiko Schocher put_mtd_device(mtd); 1317ff94bc40SHeiko Schocher 1318ff94bc40SHeiko Schocher /* 1319ff94bc40SHeiko Schocher * Originally UBI stopped initializing on any error. 1320ff94bc40SHeiko Schocher * However, later on it was found out that this 1321ff94bc40SHeiko Schocher * behavior is not very good when UBI is compiled into 1322ff94bc40SHeiko Schocher * the kernel and the MTD devices to attach are passed 1323ff94bc40SHeiko Schocher * through the command line. Indeed, UBI failure 1324ff94bc40SHeiko Schocher * stopped whole boot sequence. 1325ff94bc40SHeiko Schocher * 1326ff94bc40SHeiko Schocher * To fix this, we changed the behavior for the 1327ff94bc40SHeiko Schocher * non-module case, but preserved the old behavior for 1328ff94bc40SHeiko Schocher * the module case, just for compatibility. This is a 1329ff94bc40SHeiko Schocher * little inconsistent, though. 1330ff94bc40SHeiko Schocher */ 1331ff94bc40SHeiko Schocher if (ubi_is_module()) 1332f399d4a2SKyungmin Park goto out_detach; 1333f399d4a2SKyungmin Park } 1334f399d4a2SKyungmin Park } 1335f399d4a2SKyungmin Park 13364e67c571SHeiko Schocher err = ubiblock_init(); 13374e67c571SHeiko Schocher if (err) { 13380195a7bbSHeiko Schocher pr_err("UBI error: block: cannot initialize, error %d", err); 13394e67c571SHeiko Schocher 13404e67c571SHeiko Schocher /* See comment above re-ubi_is_module(). */ 13414e67c571SHeiko Schocher if (ubi_is_module()) 13424e67c571SHeiko Schocher goto out_detach; 13434e67c571SHeiko Schocher } 13444e67c571SHeiko Schocher 1345f399d4a2SKyungmin Park return 0; 1346f399d4a2SKyungmin Park 1347f399d4a2SKyungmin Park out_detach: 1348f399d4a2SKyungmin Park for (k = 0; k < i; k++) 1349f399d4a2SKyungmin Park if (ubi_devices[k]) { 1350f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1351f399d4a2SKyungmin Park ubi_detach_mtd_dev(ubi_devices[k]->ubi_num, 1); 1352f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1353f399d4a2SKyungmin Park } 1354ff94bc40SHeiko Schocher ubi_debugfs_exit(); 1355ff94bc40SHeiko Schocher out_slab: 1356f399d4a2SKyungmin Park kmem_cache_destroy(ubi_wl_entry_slab); 1357f399d4a2SKyungmin Park out_dev_unreg: 1358f399d4a2SKyungmin Park misc_deregister(&ubi_ctrl_cdev); 1359f399d4a2SKyungmin Park out: 136040da2a2aSHeiko Schocher #ifdef __UBOOT__ 136140da2a2aSHeiko Schocher /* Reset any globals that the driver depends on being zeroed */ 136240da2a2aSHeiko Schocher mtd_devs = 0; 136340da2a2aSHeiko Schocher #endif 13640195a7bbSHeiko Schocher class_unregister(&ubi_class); 13650195a7bbSHeiko Schocher pr_err("UBI error: cannot initialize UBI, error %d", err); 1366f399d4a2SKyungmin Park return err; 1367f399d4a2SKyungmin Park } 1368ff94bc40SHeiko Schocher late_initcall(ubi_init); 1369f399d4a2SKyungmin Park 1370ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1371ff94bc40SHeiko Schocher static void __exit ubi_exit(void) 1372ff94bc40SHeiko Schocher #else 1373ff94bc40SHeiko Schocher void ubi_exit(void) 1374ff94bc40SHeiko Schocher #endif 1375f399d4a2SKyungmin Park { 1376f399d4a2SKyungmin Park int i; 1377f399d4a2SKyungmin Park 13784e67c571SHeiko Schocher ubiblock_exit(); 13794e67c571SHeiko Schocher 1380f399d4a2SKyungmin Park for (i = 0; i < UBI_MAX_DEVICES; i++) 1381f399d4a2SKyungmin Park if (ubi_devices[i]) { 1382f399d4a2SKyungmin Park mutex_lock(&ubi_devices_mutex); 1383f399d4a2SKyungmin Park ubi_detach_mtd_dev(ubi_devices[i]->ubi_num, 1); 1384f399d4a2SKyungmin Park mutex_unlock(&ubi_devices_mutex); 1385f399d4a2SKyungmin Park } 1386ff94bc40SHeiko Schocher ubi_debugfs_exit(); 1387f399d4a2SKyungmin Park kmem_cache_destroy(ubi_wl_entry_slab); 1388f399d4a2SKyungmin Park misc_deregister(&ubi_ctrl_cdev); 13890195a7bbSHeiko Schocher class_unregister(&ubi_class); 139040da2a2aSHeiko Schocher #ifdef __UBOOT__ 139140da2a2aSHeiko Schocher /* Reset any globals that the driver depends on being zeroed */ 139240da2a2aSHeiko Schocher mtd_devs = 0; 139340da2a2aSHeiko Schocher #endif 1394f399d4a2SKyungmin Park } 1395f399d4a2SKyungmin Park module_exit(ubi_exit); 1396f399d4a2SKyungmin Park 1397f399d4a2SKyungmin Park /** 1398ff94bc40SHeiko Schocher * bytes_str_to_int - convert a number of bytes string into an integer. 1399f399d4a2SKyungmin Park * @str: the string to convert 1400f399d4a2SKyungmin Park * 1401f399d4a2SKyungmin Park * This function returns positive resulting integer in case of success and a 1402f399d4a2SKyungmin Park * negative error code in case of failure. 1403f399d4a2SKyungmin Park */ 1404f399d4a2SKyungmin Park static int __init bytes_str_to_int(const char *str) 1405f399d4a2SKyungmin Park { 1406f399d4a2SKyungmin Park char *endp; 1407f399d4a2SKyungmin Park unsigned long result; 1408f399d4a2SKyungmin Park 1409f399d4a2SKyungmin Park result = simple_strtoul(str, &endp, 0); 1410ff94bc40SHeiko Schocher if (str == endp || result >= INT_MAX) { 14110195a7bbSHeiko Schocher pr_err("UBI error: incorrect bytes count: \"%s\"\n", str); 1412f399d4a2SKyungmin Park return -EINVAL; 1413f399d4a2SKyungmin Park } 1414f399d4a2SKyungmin Park 1415f399d4a2SKyungmin Park switch (*endp) { 1416f399d4a2SKyungmin Park case 'G': 1417f399d4a2SKyungmin Park result *= 1024; 1418f399d4a2SKyungmin Park case 'M': 1419f399d4a2SKyungmin Park result *= 1024; 1420f399d4a2SKyungmin Park case 'K': 1421f399d4a2SKyungmin Park result *= 1024; 1422f399d4a2SKyungmin Park if (endp[1] == 'i' && endp[2] == 'B') 1423f399d4a2SKyungmin Park endp += 2; 1424f399d4a2SKyungmin Park case '\0': 1425f399d4a2SKyungmin Park break; 1426f399d4a2SKyungmin Park default: 14270195a7bbSHeiko Schocher pr_err("UBI error: incorrect bytes count: \"%s\"\n", str); 1428f399d4a2SKyungmin Park return -EINVAL; 1429f399d4a2SKyungmin Park } 1430f399d4a2SKyungmin Park 1431f399d4a2SKyungmin Park return result; 1432f399d4a2SKyungmin Park } 1433f399d4a2SKyungmin Park 1434ff94bc40SHeiko Schocher int kstrtoint(const char *s, unsigned int base, int *res) 1435ff94bc40SHeiko Schocher { 1436ff94bc40SHeiko Schocher unsigned long long tmp; 1437ff94bc40SHeiko Schocher 1438ff94bc40SHeiko Schocher tmp = simple_strtoull(s, NULL, base); 1439ff94bc40SHeiko Schocher if (tmp != (unsigned long long)(int)tmp) 1440ff94bc40SHeiko Schocher return -ERANGE; 1441ff94bc40SHeiko Schocher 1442ff94bc40SHeiko Schocher return (int)tmp; 1443ff94bc40SHeiko Schocher } 1444ff94bc40SHeiko Schocher 1445f399d4a2SKyungmin Park /** 1446f399d4a2SKyungmin Park * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter. 1447f399d4a2SKyungmin Park * @val: the parameter value to parse 1448f399d4a2SKyungmin Park * @kp: not used 1449f399d4a2SKyungmin Park * 1450f399d4a2SKyungmin Park * This function returns zero in case of success and a negative error code in 1451f399d4a2SKyungmin Park * case of error. 1452f399d4a2SKyungmin Park */ 1453ff94bc40SHeiko Schocher #ifndef __UBOOT__ 1454ff94bc40SHeiko Schocher static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp) 1455ff94bc40SHeiko Schocher #else 1456ff94bc40SHeiko Schocher int ubi_mtd_param_parse(const char *val, struct kernel_param *kp) 1457ff94bc40SHeiko Schocher #endif 1458f399d4a2SKyungmin Park { 1459f399d4a2SKyungmin Park int i, len; 1460f399d4a2SKyungmin Park struct mtd_dev_param *p; 1461f399d4a2SKyungmin Park char buf[MTD_PARAM_LEN_MAX]; 1462f399d4a2SKyungmin Park char *pbuf = &buf[0]; 1463ff94bc40SHeiko Schocher char *tokens[MTD_PARAM_MAX_COUNT], *token; 1464f399d4a2SKyungmin Park 1465f399d4a2SKyungmin Park if (!val) 1466f399d4a2SKyungmin Park return -EINVAL; 1467f399d4a2SKyungmin Park 1468f399d4a2SKyungmin Park if (mtd_devs == UBI_MAX_DEVICES) { 14690195a7bbSHeiko Schocher pr_err("UBI error: too many parameters, max. is %d\n", 1470f399d4a2SKyungmin Park UBI_MAX_DEVICES); 1471f399d4a2SKyungmin Park return -EINVAL; 1472f399d4a2SKyungmin Park } 1473f399d4a2SKyungmin Park 1474f399d4a2SKyungmin Park len = strnlen(val, MTD_PARAM_LEN_MAX); 1475f399d4a2SKyungmin Park if (len == MTD_PARAM_LEN_MAX) { 14760195a7bbSHeiko Schocher pr_err("UBI error: parameter \"%s\" is too long, max. is %d\n", 1477ff94bc40SHeiko Schocher val, MTD_PARAM_LEN_MAX); 1478f399d4a2SKyungmin Park return -EINVAL; 1479f399d4a2SKyungmin Park } 1480f399d4a2SKyungmin Park 1481f399d4a2SKyungmin Park if (len == 0) { 1482ff94bc40SHeiko Schocher pr_warn("UBI warning: empty 'mtd=' parameter - ignored\n"); 1483f399d4a2SKyungmin Park return 0; 1484f399d4a2SKyungmin Park } 1485f399d4a2SKyungmin Park 1486f399d4a2SKyungmin Park strcpy(buf, val); 1487f399d4a2SKyungmin Park 1488f399d4a2SKyungmin Park /* Get rid of the final newline */ 1489f399d4a2SKyungmin Park if (buf[len - 1] == '\n') 1490f399d4a2SKyungmin Park buf[len - 1] = '\0'; 1491f399d4a2SKyungmin Park 1492ff94bc40SHeiko Schocher for (i = 0; i < MTD_PARAM_MAX_COUNT; i++) 1493f399d4a2SKyungmin Park tokens[i] = strsep(&pbuf, ","); 1494f399d4a2SKyungmin Park 1495f399d4a2SKyungmin Park if (pbuf) { 14960195a7bbSHeiko Schocher pr_err("UBI error: too many arguments at \"%s\"\n", val); 1497f399d4a2SKyungmin Park return -EINVAL; 1498f399d4a2SKyungmin Park } 1499f399d4a2SKyungmin Park 1500f399d4a2SKyungmin Park p = &mtd_dev_param[mtd_devs]; 1501f399d4a2SKyungmin Park strcpy(&p->name[0], tokens[0]); 1502f399d4a2SKyungmin Park 1503ff94bc40SHeiko Schocher token = tokens[1]; 1504ff94bc40SHeiko Schocher if (token) { 1505ff94bc40SHeiko Schocher p->vid_hdr_offs = bytes_str_to_int(token); 1506f399d4a2SKyungmin Park 1507f399d4a2SKyungmin Park if (p->vid_hdr_offs < 0) 1508f399d4a2SKyungmin Park return p->vid_hdr_offs; 1509ff94bc40SHeiko Schocher } 1510ff94bc40SHeiko Schocher 1511ff94bc40SHeiko Schocher token = tokens[2]; 1512ff94bc40SHeiko Schocher if (token) { 1513ff94bc40SHeiko Schocher int err = kstrtoint(token, 10, &p->max_beb_per1024); 1514ff94bc40SHeiko Schocher 1515ff94bc40SHeiko Schocher if (err) { 15160195a7bbSHeiko Schocher pr_err("UBI error: bad value for max_beb_per1024 parameter: %s", 1517ff94bc40SHeiko Schocher token); 1518ff94bc40SHeiko Schocher return -EINVAL; 1519ff94bc40SHeiko Schocher } 1520ff94bc40SHeiko Schocher } 1521ff94bc40SHeiko Schocher 1522ff94bc40SHeiko Schocher token = tokens[3]; 1523ff94bc40SHeiko Schocher if (token) { 1524ff94bc40SHeiko Schocher int err = kstrtoint(token, 10, &p->ubi_num); 1525ff94bc40SHeiko Schocher 1526ff94bc40SHeiko Schocher if (err) { 15270195a7bbSHeiko Schocher pr_err("UBI error: bad value for ubi_num parameter: %s", 15280195a7bbSHeiko Schocher token); 1529ff94bc40SHeiko Schocher return -EINVAL; 1530ff94bc40SHeiko Schocher } 1531ff94bc40SHeiko Schocher } else 1532ff94bc40SHeiko Schocher p->ubi_num = UBI_DEV_NUM_AUTO; 1533f399d4a2SKyungmin Park 1534f399d4a2SKyungmin Park mtd_devs += 1; 1535f399d4a2SKyungmin Park return 0; 1536f399d4a2SKyungmin Park } 1537f399d4a2SKyungmin Park 1538f399d4a2SKyungmin Park module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000); 1539ff94bc40SHeiko Schocher MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: mtd=<name|num|path>[,<vid_hdr_offs>[,max_beb_per1024[,ubi_num]]].\n" 1540f399d4a2SKyungmin Park "Multiple \"mtd\" parameters may be specified.\n" 1541ff94bc40SHeiko Schocher "MTD devices may be specified by their number, name, or path to the MTD character device node.\n" 1542ff94bc40SHeiko Schocher "Optional \"vid_hdr_offs\" parameter specifies UBI VID header position to be used by UBI. (default value if 0)\n" 1543ff94bc40SHeiko Schocher "Optional \"max_beb_per1024\" parameter specifies the maximum expected bad eraseblock per 1024 eraseblocks. (default value (" 1544ff94bc40SHeiko Schocher __stringify(CONFIG_MTD_UBI_BEB_LIMIT) ") if 0)\n" 1545ff94bc40SHeiko Schocher "Optional \"ubi_num\" parameter specifies UBI device number which have to be assigned to the newly created UBI device (assigned automatically by default)\n" 1546ff94bc40SHeiko Schocher "\n" 1547ff94bc40SHeiko Schocher "Example 1: mtd=/dev/mtd0 - attach MTD device /dev/mtd0.\n" 1548ff94bc40SHeiko Schocher "Example 2: mtd=content,1984 mtd=4 - attach MTD device with name \"content\" using VID header offset 1984, and MTD device number 4 with default VID header offset.\n" 1549ff94bc40SHeiko Schocher "Example 3: mtd=/dev/mtd1,0,25 - attach MTD device /dev/mtd1 using default VID header offset and reserve 25*nand_size_in_blocks/1024 erase blocks for bad block handling.\n" 1550ff94bc40SHeiko Schocher "Example 4: mtd=/dev/mtd1,0,0,5 - attach MTD device /dev/mtd1 to UBI 5 and using default values for the other fields.\n" 1551ff94bc40SHeiko Schocher "\t(e.g. if the NAND *chipset* has 4096 PEB, 100 will be reserved for this UBI device)."); 1552ff94bc40SHeiko Schocher #ifdef CONFIG_MTD_UBI_FASTMAP 1553ff94bc40SHeiko Schocher module_param(fm_autoconvert, bool, 0644); 1554ff94bc40SHeiko Schocher MODULE_PARM_DESC(fm_autoconvert, "Set this parameter to enable fastmap automatically on images without a fastmap."); 15550195a7bbSHeiko Schocher module_param(fm_debug, bool, 0); 15560195a7bbSHeiko Schocher MODULE_PARM_DESC(fm_debug, "Set this parameter to enable fastmap debugging by default. Warning, this will make fastmap slow!"); 1557ff94bc40SHeiko Schocher #endif 1558f399d4a2SKyungmin Park MODULE_VERSION(__stringify(UBI_VERSION)); 1559f399d4a2SKyungmin Park MODULE_DESCRIPTION("UBI - Unsorted Block Images"); 1560f399d4a2SKyungmin Park MODULE_AUTHOR("Artem Bityutskiy"); 1561f399d4a2SKyungmin Park MODULE_LICENSE("GPL"); 1562