12d262c48SKyungmin Park /* 22d262c48SKyungmin Park * Copyright (c) International Business Machines Corp., 2006 32d262c48SKyungmin Park * 4*1a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 52d262c48SKyungmin Park * 62d262c48SKyungmin Park * Author: Artem Bityutskiy (Битюцкий Артём) 72d262c48SKyungmin Park */ 82d262c48SKyungmin Park 92d262c48SKyungmin Park /* This file mostly implements UBI kernel API functions */ 102d262c48SKyungmin Park 112d262c48SKyungmin Park #ifdef UBI_LINUX 122d262c48SKyungmin Park #include <linux/module.h> 132d262c48SKyungmin Park #include <linux/err.h> 142d262c48SKyungmin Park #include <asm/div64.h> 152d262c48SKyungmin Park #endif 162d262c48SKyungmin Park 172d262c48SKyungmin Park #include <ubi_uboot.h> 182d262c48SKyungmin Park #include "ubi.h" 192d262c48SKyungmin Park 202d262c48SKyungmin Park /** 212d262c48SKyungmin Park * ubi_get_device_info - get information about UBI device. 222d262c48SKyungmin Park * @ubi_num: UBI device number 232d262c48SKyungmin Park * @di: the information is stored here 242d262c48SKyungmin Park * 252d262c48SKyungmin Park * This function returns %0 in case of success, %-EINVAL if the UBI device 262d262c48SKyungmin Park * number is invalid, and %-ENODEV if there is no such UBI device. 272d262c48SKyungmin Park */ 282d262c48SKyungmin Park int ubi_get_device_info(int ubi_num, struct ubi_device_info *di) 292d262c48SKyungmin Park { 302d262c48SKyungmin Park struct ubi_device *ubi; 312d262c48SKyungmin Park 322d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 332d262c48SKyungmin Park return -EINVAL; 342d262c48SKyungmin Park 352d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 362d262c48SKyungmin Park if (!ubi) 372d262c48SKyungmin Park return -ENODEV; 382d262c48SKyungmin Park 392d262c48SKyungmin Park di->ubi_num = ubi->ubi_num; 402d262c48SKyungmin Park di->leb_size = ubi->leb_size; 412d262c48SKyungmin Park di->min_io_size = ubi->min_io_size; 422d262c48SKyungmin Park di->ro_mode = ubi->ro_mode; 432d262c48SKyungmin Park di->cdev = ubi->cdev.dev; 442d262c48SKyungmin Park 452d262c48SKyungmin Park ubi_put_device(ubi); 462d262c48SKyungmin Park return 0; 472d262c48SKyungmin Park } 482d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_get_device_info); 492d262c48SKyungmin Park 502d262c48SKyungmin Park /** 512d262c48SKyungmin Park * ubi_get_volume_info - get information about UBI volume. 522d262c48SKyungmin Park * @desc: volume descriptor 532d262c48SKyungmin Park * @vi: the information is stored here 542d262c48SKyungmin Park */ 552d262c48SKyungmin Park void ubi_get_volume_info(struct ubi_volume_desc *desc, 562d262c48SKyungmin Park struct ubi_volume_info *vi) 572d262c48SKyungmin Park { 582d262c48SKyungmin Park const struct ubi_volume *vol = desc->vol; 592d262c48SKyungmin Park const struct ubi_device *ubi = vol->ubi; 602d262c48SKyungmin Park 612d262c48SKyungmin Park vi->vol_id = vol->vol_id; 622d262c48SKyungmin Park vi->ubi_num = ubi->ubi_num; 632d262c48SKyungmin Park vi->size = vol->reserved_pebs; 642d262c48SKyungmin Park vi->used_bytes = vol->used_bytes; 652d262c48SKyungmin Park vi->vol_type = vol->vol_type; 662d262c48SKyungmin Park vi->corrupted = vol->corrupted; 672d262c48SKyungmin Park vi->upd_marker = vol->upd_marker; 682d262c48SKyungmin Park vi->alignment = vol->alignment; 692d262c48SKyungmin Park vi->usable_leb_size = vol->usable_leb_size; 702d262c48SKyungmin Park vi->name_len = vol->name_len; 712d262c48SKyungmin Park vi->name = vol->name; 722d262c48SKyungmin Park vi->cdev = vol->cdev.dev; 732d262c48SKyungmin Park } 742d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_get_volume_info); 752d262c48SKyungmin Park 762d262c48SKyungmin Park /** 772d262c48SKyungmin Park * ubi_open_volume - open UBI volume. 782d262c48SKyungmin Park * @ubi_num: UBI device number 792d262c48SKyungmin Park * @vol_id: volume ID 802d262c48SKyungmin Park * @mode: open mode 812d262c48SKyungmin Park * 822d262c48SKyungmin Park * The @mode parameter specifies if the volume should be opened in read-only 832d262c48SKyungmin Park * mode, read-write mode, or exclusive mode. The exclusive mode guarantees that 842d262c48SKyungmin Park * nobody else will be able to open this volume. UBI allows to have many volume 852d262c48SKyungmin Park * readers and one writer at a time. 862d262c48SKyungmin Park * 872d262c48SKyungmin Park * If a static volume is being opened for the first time since boot, it will be 882d262c48SKyungmin Park * checked by this function, which means it will be fully read and the CRC 892d262c48SKyungmin Park * checksum of each logical eraseblock will be checked. 902d262c48SKyungmin Park * 912d262c48SKyungmin Park * This function returns volume descriptor in case of success and a negative 922d262c48SKyungmin Park * error code in case of failure. 932d262c48SKyungmin Park */ 942d262c48SKyungmin Park struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode) 952d262c48SKyungmin Park { 962d262c48SKyungmin Park int err; 972d262c48SKyungmin Park struct ubi_volume_desc *desc; 982d262c48SKyungmin Park struct ubi_device *ubi; 992d262c48SKyungmin Park struct ubi_volume *vol; 1002d262c48SKyungmin Park 1012d262c48SKyungmin Park dbg_msg("open device %d volume %d, mode %d", ubi_num, vol_id, mode); 1022d262c48SKyungmin Park 1032d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 1042d262c48SKyungmin Park return ERR_PTR(-EINVAL); 1052d262c48SKyungmin Park 1062d262c48SKyungmin Park if (mode != UBI_READONLY && mode != UBI_READWRITE && 1072d262c48SKyungmin Park mode != UBI_EXCLUSIVE) 1082d262c48SKyungmin Park return ERR_PTR(-EINVAL); 1092d262c48SKyungmin Park 1102d262c48SKyungmin Park /* 1112d262c48SKyungmin Park * First of all, we have to get the UBI device to prevent its removal. 1122d262c48SKyungmin Park */ 1132d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 1142d262c48SKyungmin Park if (!ubi) 1152d262c48SKyungmin Park return ERR_PTR(-ENODEV); 1162d262c48SKyungmin Park 1172d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) { 1182d262c48SKyungmin Park err = -EINVAL; 1192d262c48SKyungmin Park goto out_put_ubi; 1202d262c48SKyungmin Park } 1212d262c48SKyungmin Park 1222d262c48SKyungmin Park desc = kmalloc(sizeof(struct ubi_volume_desc), GFP_KERNEL); 1232d262c48SKyungmin Park if (!desc) { 1242d262c48SKyungmin Park err = -ENOMEM; 1252d262c48SKyungmin Park goto out_put_ubi; 1262d262c48SKyungmin Park } 1272d262c48SKyungmin Park 1282d262c48SKyungmin Park err = -ENODEV; 1292d262c48SKyungmin Park if (!try_module_get(THIS_MODULE)) 1302d262c48SKyungmin Park goto out_free; 1312d262c48SKyungmin Park 1322d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 1332d262c48SKyungmin Park vol = ubi->volumes[vol_id]; 1342d262c48SKyungmin Park if (!vol) 1352d262c48SKyungmin Park goto out_unlock; 1362d262c48SKyungmin Park 1372d262c48SKyungmin Park err = -EBUSY; 1382d262c48SKyungmin Park switch (mode) { 1392d262c48SKyungmin Park case UBI_READONLY: 1402d262c48SKyungmin Park if (vol->exclusive) 1412d262c48SKyungmin Park goto out_unlock; 1422d262c48SKyungmin Park vol->readers += 1; 1432d262c48SKyungmin Park break; 1442d262c48SKyungmin Park 1452d262c48SKyungmin Park case UBI_READWRITE: 1462d262c48SKyungmin Park if (vol->exclusive || vol->writers > 0) 1472d262c48SKyungmin Park goto out_unlock; 1482d262c48SKyungmin Park vol->writers += 1; 1492d262c48SKyungmin Park break; 1502d262c48SKyungmin Park 1512d262c48SKyungmin Park case UBI_EXCLUSIVE: 1522d262c48SKyungmin Park if (vol->exclusive || vol->writers || vol->readers) 1532d262c48SKyungmin Park goto out_unlock; 1542d262c48SKyungmin Park vol->exclusive = 1; 1552d262c48SKyungmin Park break; 1562d262c48SKyungmin Park } 1572d262c48SKyungmin Park get_device(&vol->dev); 1582d262c48SKyungmin Park vol->ref_count += 1; 1592d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 1602d262c48SKyungmin Park 1612d262c48SKyungmin Park desc->vol = vol; 1622d262c48SKyungmin Park desc->mode = mode; 1632d262c48SKyungmin Park 1642d262c48SKyungmin Park mutex_lock(&ubi->ckvol_mutex); 1652d262c48SKyungmin Park if (!vol->checked) { 1662d262c48SKyungmin Park /* This is the first open - check the volume */ 1672d262c48SKyungmin Park err = ubi_check_volume(ubi, vol_id); 1682d262c48SKyungmin Park if (err < 0) { 1692d262c48SKyungmin Park mutex_unlock(&ubi->ckvol_mutex); 1702d262c48SKyungmin Park ubi_close_volume(desc); 1712d262c48SKyungmin Park return ERR_PTR(err); 1722d262c48SKyungmin Park } 1732d262c48SKyungmin Park if (err == 1) { 1742d262c48SKyungmin Park ubi_warn("volume %d on UBI device %d is corrupted", 1752d262c48SKyungmin Park vol_id, ubi->ubi_num); 1762d262c48SKyungmin Park vol->corrupted = 1; 1772d262c48SKyungmin Park } 1782d262c48SKyungmin Park vol->checked = 1; 1792d262c48SKyungmin Park } 1802d262c48SKyungmin Park mutex_unlock(&ubi->ckvol_mutex); 1812d262c48SKyungmin Park 1822d262c48SKyungmin Park return desc; 1832d262c48SKyungmin Park 1842d262c48SKyungmin Park out_unlock: 1852d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 1862d262c48SKyungmin Park module_put(THIS_MODULE); 1872d262c48SKyungmin Park out_free: 1882d262c48SKyungmin Park kfree(desc); 1892d262c48SKyungmin Park out_put_ubi: 1902d262c48SKyungmin Park ubi_put_device(ubi); 1912d262c48SKyungmin Park return ERR_PTR(err); 1922d262c48SKyungmin Park } 1932d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_open_volume); 1942d262c48SKyungmin Park 1952d262c48SKyungmin Park /** 1962d262c48SKyungmin Park * ubi_open_volume_nm - open UBI volume by name. 1972d262c48SKyungmin Park * @ubi_num: UBI device number 1982d262c48SKyungmin Park * @name: volume name 1992d262c48SKyungmin Park * @mode: open mode 2002d262c48SKyungmin Park * 2012d262c48SKyungmin Park * This function is similar to 'ubi_open_volume()', but opens a volume by name. 2022d262c48SKyungmin Park */ 2032d262c48SKyungmin Park struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name, 2042d262c48SKyungmin Park int mode) 2052d262c48SKyungmin Park { 2062d262c48SKyungmin Park int i, vol_id = -1, len; 2072d262c48SKyungmin Park struct ubi_device *ubi; 2082d262c48SKyungmin Park struct ubi_volume_desc *ret; 2092d262c48SKyungmin Park 2102d262c48SKyungmin Park dbg_msg("open volume %s, mode %d", name, mode); 2112d262c48SKyungmin Park 2122d262c48SKyungmin Park if (!name) 2132d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2142d262c48SKyungmin Park 2152d262c48SKyungmin Park len = strnlen(name, UBI_VOL_NAME_MAX + 1); 2162d262c48SKyungmin Park if (len > UBI_VOL_NAME_MAX) 2172d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2182d262c48SKyungmin Park 2192d262c48SKyungmin Park if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES) 2202d262c48SKyungmin Park return ERR_PTR(-EINVAL); 2212d262c48SKyungmin Park 2222d262c48SKyungmin Park ubi = ubi_get_device(ubi_num); 2232d262c48SKyungmin Park if (!ubi) 2242d262c48SKyungmin Park return ERR_PTR(-ENODEV); 2252d262c48SKyungmin Park 2262d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 2272d262c48SKyungmin Park /* Walk all volumes of this UBI device */ 2282d262c48SKyungmin Park for (i = 0; i < ubi->vtbl_slots; i++) { 2292d262c48SKyungmin Park struct ubi_volume *vol = ubi->volumes[i]; 2302d262c48SKyungmin Park 2312d262c48SKyungmin Park if (vol && len == vol->name_len && !strcmp(name, vol->name)) { 2322d262c48SKyungmin Park vol_id = i; 2332d262c48SKyungmin Park break; 2342d262c48SKyungmin Park } 2352d262c48SKyungmin Park } 2362d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 2372d262c48SKyungmin Park 2382d262c48SKyungmin Park if (vol_id >= 0) 2392d262c48SKyungmin Park ret = ubi_open_volume(ubi_num, vol_id, mode); 2402d262c48SKyungmin Park else 2412d262c48SKyungmin Park ret = ERR_PTR(-ENODEV); 2422d262c48SKyungmin Park 2432d262c48SKyungmin Park /* 2442d262c48SKyungmin Park * We should put the UBI device even in case of success, because 2452d262c48SKyungmin Park * 'ubi_open_volume()' took a reference as well. 2462d262c48SKyungmin Park */ 2472d262c48SKyungmin Park ubi_put_device(ubi); 2482d262c48SKyungmin Park return ret; 2492d262c48SKyungmin Park } 2502d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_open_volume_nm); 2512d262c48SKyungmin Park 2522d262c48SKyungmin Park /** 2532d262c48SKyungmin Park * ubi_close_volume - close UBI volume. 2542d262c48SKyungmin Park * @desc: volume descriptor 2552d262c48SKyungmin Park */ 2562d262c48SKyungmin Park void ubi_close_volume(struct ubi_volume_desc *desc) 2572d262c48SKyungmin Park { 2582d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 2592d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 2602d262c48SKyungmin Park 2612d262c48SKyungmin Park dbg_msg("close volume %d, mode %d", vol->vol_id, desc->mode); 2622d262c48SKyungmin Park 2632d262c48SKyungmin Park spin_lock(&ubi->volumes_lock); 2642d262c48SKyungmin Park switch (desc->mode) { 2652d262c48SKyungmin Park case UBI_READONLY: 2662d262c48SKyungmin Park vol->readers -= 1; 2672d262c48SKyungmin Park break; 2682d262c48SKyungmin Park case UBI_READWRITE: 2692d262c48SKyungmin Park vol->writers -= 1; 2702d262c48SKyungmin Park break; 2712d262c48SKyungmin Park case UBI_EXCLUSIVE: 2722d262c48SKyungmin Park vol->exclusive = 0; 2732d262c48SKyungmin Park } 2742d262c48SKyungmin Park vol->ref_count -= 1; 2752d262c48SKyungmin Park spin_unlock(&ubi->volumes_lock); 2762d262c48SKyungmin Park 2772d262c48SKyungmin Park kfree(desc); 2782d262c48SKyungmin Park put_device(&vol->dev); 2792d262c48SKyungmin Park ubi_put_device(ubi); 2802d262c48SKyungmin Park module_put(THIS_MODULE); 2812d262c48SKyungmin Park } 2822d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_close_volume); 2832d262c48SKyungmin Park 2842d262c48SKyungmin Park /** 2852d262c48SKyungmin Park * ubi_leb_read - read data. 2862d262c48SKyungmin Park * @desc: volume descriptor 2872d262c48SKyungmin Park * @lnum: logical eraseblock number to read from 2882d262c48SKyungmin Park * @buf: buffer where to store the read data 2892d262c48SKyungmin Park * @offset: offset within the logical eraseblock to read from 2902d262c48SKyungmin Park * @len: how many bytes to read 2912d262c48SKyungmin Park * @check: whether UBI has to check the read data's CRC or not. 2922d262c48SKyungmin Park * 2932d262c48SKyungmin Park * This function reads data from offset @offset of logical eraseblock @lnum and 2942d262c48SKyungmin Park * stores the data at @buf. When reading from static volumes, @check specifies 2952d262c48SKyungmin Park * whether the data has to be checked or not. If yes, the whole logical 2962d262c48SKyungmin Park * eraseblock will be read and its CRC checksum will be checked (i.e., the CRC 2972d262c48SKyungmin Park * checksum is per-eraseblock). So checking may substantially slow down the 2982d262c48SKyungmin Park * read speed. The @check argument is ignored for dynamic volumes. 2992d262c48SKyungmin Park * 3002d262c48SKyungmin Park * In case of success, this function returns zero. In case of failure, this 3012d262c48SKyungmin Park * function returns a negative error code. 3022d262c48SKyungmin Park * 3032d262c48SKyungmin Park * %-EBADMSG error code is returned: 3042d262c48SKyungmin Park * o for both static and dynamic volumes if MTD driver has detected a data 3052d262c48SKyungmin Park * integrity problem (unrecoverable ECC checksum mismatch in case of NAND); 3062d262c48SKyungmin Park * o for static volumes in case of data CRC mismatch. 3072d262c48SKyungmin Park * 3082d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 3092d262c48SKyungmin Park * returns immediately with %-EBADF error code. 3102d262c48SKyungmin Park */ 3112d262c48SKyungmin Park int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset, 3122d262c48SKyungmin Park int len, int check) 3132d262c48SKyungmin Park { 3142d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 3152d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 3162d262c48SKyungmin Park int err, vol_id = vol->vol_id; 3172d262c48SKyungmin Park 3182d262c48SKyungmin Park dbg_msg("read %d bytes from LEB %d:%d:%d", len, vol_id, lnum, offset); 3192d262c48SKyungmin Park 3202d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots || lnum < 0 || 3212d262c48SKyungmin Park lnum >= vol->used_ebs || offset < 0 || len < 0 || 3222d262c48SKyungmin Park offset + len > vol->usable_leb_size) 3232d262c48SKyungmin Park return -EINVAL; 3242d262c48SKyungmin Park 3252d262c48SKyungmin Park if (vol->vol_type == UBI_STATIC_VOLUME) { 3262d262c48SKyungmin Park if (vol->used_ebs == 0) 3272d262c48SKyungmin Park /* Empty static UBI volume */ 3282d262c48SKyungmin Park return 0; 3292d262c48SKyungmin Park if (lnum == vol->used_ebs - 1 && 3302d262c48SKyungmin Park offset + len > vol->last_eb_bytes) 3312d262c48SKyungmin Park return -EINVAL; 3322d262c48SKyungmin Park } 3332d262c48SKyungmin Park 3342d262c48SKyungmin Park if (vol->upd_marker) 3352d262c48SKyungmin Park return -EBADF; 3362d262c48SKyungmin Park if (len == 0) 3372d262c48SKyungmin Park return 0; 3382d262c48SKyungmin Park 3392d262c48SKyungmin Park err = ubi_eba_read_leb(ubi, vol, lnum, buf, offset, len, check); 340dfe64e2cSSergey Lapin if (err && mtd_is_eccerr(err) && vol->vol_type == UBI_STATIC_VOLUME) { 3412d262c48SKyungmin Park ubi_warn("mark volume %d as corrupted", vol_id); 3422d262c48SKyungmin Park vol->corrupted = 1; 3432d262c48SKyungmin Park } 3442d262c48SKyungmin Park 3452d262c48SKyungmin Park return err; 3462d262c48SKyungmin Park } 3472d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_read); 3482d262c48SKyungmin Park 3492d262c48SKyungmin Park /** 3502d262c48SKyungmin Park * ubi_leb_write - write data. 3512d262c48SKyungmin Park * @desc: volume descriptor 3522d262c48SKyungmin Park * @lnum: logical eraseblock number to write to 3532d262c48SKyungmin Park * @buf: data to write 3542d262c48SKyungmin Park * @offset: offset within the logical eraseblock where to write 3552d262c48SKyungmin Park * @len: how many bytes to write 3562d262c48SKyungmin Park * @dtype: expected data type 3572d262c48SKyungmin Park * 3582d262c48SKyungmin Park * This function writes @len bytes of data from @buf to offset @offset of 3592d262c48SKyungmin Park * logical eraseblock @lnum. The @dtype argument describes expected lifetime of 3602d262c48SKyungmin Park * the data. 3612d262c48SKyungmin Park * 3622d262c48SKyungmin Park * This function takes care of physical eraseblock write failures. If write to 3632d262c48SKyungmin Park * the physical eraseblock write operation fails, the logical eraseblock is 3642d262c48SKyungmin Park * re-mapped to another physical eraseblock, the data is recovered, and the 3652d262c48SKyungmin Park * write finishes. UBI has a pool of reserved physical eraseblocks for this. 3662d262c48SKyungmin Park * 3672d262c48SKyungmin Park * If all the data were successfully written, zero is returned. If an error 3682d262c48SKyungmin Park * occurred and UBI has not been able to recover from it, this function returns 3692d262c48SKyungmin Park * a negative error code. Note, in case of an error, it is possible that 3702d262c48SKyungmin Park * something was still written to the flash media, but that may be some 3712d262c48SKyungmin Park * garbage. 3722d262c48SKyungmin Park * 3732d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 3742d262c48SKyungmin Park * returns immediately with %-EBADF code. 3752d262c48SKyungmin Park */ 3762d262c48SKyungmin Park int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf, 3772d262c48SKyungmin Park int offset, int len, int dtype) 3782d262c48SKyungmin Park { 3792d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 3802d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 3812d262c48SKyungmin Park int vol_id = vol->vol_id; 3822d262c48SKyungmin Park 3832d262c48SKyungmin Park dbg_msg("write %d bytes to LEB %d:%d:%d", len, vol_id, lnum, offset); 3842d262c48SKyungmin Park 3852d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) 3862d262c48SKyungmin Park return -EINVAL; 3872d262c48SKyungmin Park 3882d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 3892d262c48SKyungmin Park return -EROFS; 3902d262c48SKyungmin Park 3912d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs || offset < 0 || len < 0 || 3922d262c48SKyungmin Park offset + len > vol->usable_leb_size || 3932d262c48SKyungmin Park offset & (ubi->min_io_size - 1) || len & (ubi->min_io_size - 1)) 3942d262c48SKyungmin Park return -EINVAL; 3952d262c48SKyungmin Park 3962d262c48SKyungmin Park if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM && 3972d262c48SKyungmin Park dtype != UBI_UNKNOWN) 3982d262c48SKyungmin Park return -EINVAL; 3992d262c48SKyungmin Park 4002d262c48SKyungmin Park if (vol->upd_marker) 4012d262c48SKyungmin Park return -EBADF; 4022d262c48SKyungmin Park 4032d262c48SKyungmin Park if (len == 0) 4042d262c48SKyungmin Park return 0; 4052d262c48SKyungmin Park 4062d262c48SKyungmin Park return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len, dtype); 4072d262c48SKyungmin Park } 4082d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_write); 4092d262c48SKyungmin Park 4102d262c48SKyungmin Park /* 4112d262c48SKyungmin Park * ubi_leb_change - change logical eraseblock atomically. 4122d262c48SKyungmin Park * @desc: volume descriptor 4132d262c48SKyungmin Park * @lnum: logical eraseblock number to change 4142d262c48SKyungmin Park * @buf: data to write 4152d262c48SKyungmin Park * @len: how many bytes to write 4162d262c48SKyungmin Park * @dtype: expected data type 4172d262c48SKyungmin Park * 4182d262c48SKyungmin Park * This function changes the contents of a logical eraseblock atomically. @buf 4192d262c48SKyungmin Park * has to contain new logical eraseblock data, and @len - the length of the 4202d262c48SKyungmin Park * data, which has to be aligned. The length may be shorter then the logical 4212d262c48SKyungmin Park * eraseblock size, ant the logical eraseblock may be appended to more times 4222d262c48SKyungmin Park * later on. This function guarantees that in case of an unclean reboot the old 4232d262c48SKyungmin Park * contents is preserved. Returns zero in case of success and a negative error 4242d262c48SKyungmin Park * code in case of failure. 4252d262c48SKyungmin Park */ 4262d262c48SKyungmin Park int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf, 4272d262c48SKyungmin Park int len, int dtype) 4282d262c48SKyungmin Park { 4292d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 4302d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 4312d262c48SKyungmin Park int vol_id = vol->vol_id; 4322d262c48SKyungmin Park 4332d262c48SKyungmin Park dbg_msg("atomically write %d bytes to LEB %d:%d", len, vol_id, lnum); 4342d262c48SKyungmin Park 4352d262c48SKyungmin Park if (vol_id < 0 || vol_id >= ubi->vtbl_slots) 4362d262c48SKyungmin Park return -EINVAL; 4372d262c48SKyungmin Park 4382d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 4392d262c48SKyungmin Park return -EROFS; 4402d262c48SKyungmin Park 4412d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs || len < 0 || 4422d262c48SKyungmin Park len > vol->usable_leb_size || len & (ubi->min_io_size - 1)) 4432d262c48SKyungmin Park return -EINVAL; 4442d262c48SKyungmin Park 4452d262c48SKyungmin Park if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM && 4462d262c48SKyungmin Park dtype != UBI_UNKNOWN) 4472d262c48SKyungmin Park return -EINVAL; 4482d262c48SKyungmin Park 4492d262c48SKyungmin Park if (vol->upd_marker) 4502d262c48SKyungmin Park return -EBADF; 4512d262c48SKyungmin Park 4522d262c48SKyungmin Park if (len == 0) 4532d262c48SKyungmin Park return 0; 4542d262c48SKyungmin Park 4552d262c48SKyungmin Park return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len, dtype); 4562d262c48SKyungmin Park } 4572d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_change); 4582d262c48SKyungmin Park 4592d262c48SKyungmin Park /** 4602d262c48SKyungmin Park * ubi_leb_erase - erase logical eraseblock. 4612d262c48SKyungmin Park * @desc: volume descriptor 4622d262c48SKyungmin Park * @lnum: logical eraseblock number 4632d262c48SKyungmin Park * 4642d262c48SKyungmin Park * This function un-maps logical eraseblock @lnum and synchronously erases the 4652d262c48SKyungmin Park * correspondent physical eraseblock. Returns zero in case of success and a 4662d262c48SKyungmin Park * negative error code in case of failure. 4672d262c48SKyungmin Park * 4682d262c48SKyungmin Park * If the volume is damaged because of an interrupted update this function just 4692d262c48SKyungmin Park * returns immediately with %-EBADF code. 4702d262c48SKyungmin Park */ 4712d262c48SKyungmin Park int ubi_leb_erase(struct ubi_volume_desc *desc, int lnum) 4722d262c48SKyungmin Park { 4732d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 4742d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 4752d262c48SKyungmin Park int err; 4762d262c48SKyungmin Park 4772d262c48SKyungmin Park dbg_msg("erase LEB %d:%d", vol->vol_id, lnum); 4782d262c48SKyungmin Park 4792d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 4802d262c48SKyungmin Park return -EROFS; 4812d262c48SKyungmin Park 4822d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 4832d262c48SKyungmin Park return -EINVAL; 4842d262c48SKyungmin Park 4852d262c48SKyungmin Park if (vol->upd_marker) 4862d262c48SKyungmin Park return -EBADF; 4872d262c48SKyungmin Park 4882d262c48SKyungmin Park err = ubi_eba_unmap_leb(ubi, vol, lnum); 4892d262c48SKyungmin Park if (err) 4902d262c48SKyungmin Park return err; 4912d262c48SKyungmin Park 4922d262c48SKyungmin Park return ubi_wl_flush(ubi); 4932d262c48SKyungmin Park } 4942d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_erase); 4952d262c48SKyungmin Park 4962d262c48SKyungmin Park /** 4972d262c48SKyungmin Park * ubi_leb_unmap - un-map logical eraseblock. 4982d262c48SKyungmin Park * @desc: volume descriptor 4992d262c48SKyungmin Park * @lnum: logical eraseblock number 5002d262c48SKyungmin Park * 5012d262c48SKyungmin Park * This function un-maps logical eraseblock @lnum and schedules the 5022d262c48SKyungmin Park * corresponding physical eraseblock for erasure, so that it will eventually be 5032d262c48SKyungmin Park * physically erased in background. This operation is much faster then the 5042d262c48SKyungmin Park * erase operation. 5052d262c48SKyungmin Park * 5062d262c48SKyungmin Park * Unlike erase, the un-map operation does not guarantee that the logical 5072d262c48SKyungmin Park * eraseblock will contain all 0xFF bytes when UBI is initialized again. For 5082d262c48SKyungmin Park * example, if several logical eraseblocks are un-mapped, and an unclean reboot 5092d262c48SKyungmin Park * happens after this, the logical eraseblocks will not necessarily be 5102d262c48SKyungmin Park * un-mapped again when this MTD device is attached. They may actually be 5112d262c48SKyungmin Park * mapped to the same physical eraseblocks again. So, this function has to be 5122d262c48SKyungmin Park * used with care. 5132d262c48SKyungmin Park * 5142d262c48SKyungmin Park * In other words, when un-mapping a logical eraseblock, UBI does not store 5152d262c48SKyungmin Park * any information about this on the flash media, it just marks the logical 5162d262c48SKyungmin Park * eraseblock as "un-mapped" in RAM. If UBI is detached before the physical 5172d262c48SKyungmin Park * eraseblock is physically erased, it will be mapped again to the same logical 5182d262c48SKyungmin Park * eraseblock when the MTD device is attached again. 5192d262c48SKyungmin Park * 5202d262c48SKyungmin Park * The main and obvious use-case of this function is when the contents of a 5212d262c48SKyungmin Park * logical eraseblock has to be re-written. Then it is much more efficient to 5222d262c48SKyungmin Park * first un-map it, then write new data, rather then first erase it, then write 5232d262c48SKyungmin Park * new data. Note, once new data has been written to the logical eraseblock, 5242d262c48SKyungmin Park * UBI guarantees that the old contents has gone forever. In other words, if an 5252d262c48SKyungmin Park * unclean reboot happens after the logical eraseblock has been un-mapped and 5262d262c48SKyungmin Park * then written to, it will contain the last written data. 5272d262c48SKyungmin Park * 5282d262c48SKyungmin Park * This function returns zero in case of success and a negative error code in 5292d262c48SKyungmin Park * case of failure. If the volume is damaged because of an interrupted update 5302d262c48SKyungmin Park * this function just returns immediately with %-EBADF code. 5312d262c48SKyungmin Park */ 5322d262c48SKyungmin Park int ubi_leb_unmap(struct ubi_volume_desc *desc, int lnum) 5332d262c48SKyungmin Park { 5342d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 5352d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 5362d262c48SKyungmin Park 5372d262c48SKyungmin Park dbg_msg("unmap LEB %d:%d", vol->vol_id, lnum); 5382d262c48SKyungmin Park 5392d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 5402d262c48SKyungmin Park return -EROFS; 5412d262c48SKyungmin Park 5422d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 5432d262c48SKyungmin Park return -EINVAL; 5442d262c48SKyungmin Park 5452d262c48SKyungmin Park if (vol->upd_marker) 5462d262c48SKyungmin Park return -EBADF; 5472d262c48SKyungmin Park 5482d262c48SKyungmin Park return ubi_eba_unmap_leb(ubi, vol, lnum); 5492d262c48SKyungmin Park } 5502d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_unmap); 5512d262c48SKyungmin Park 5522d262c48SKyungmin Park /** 5532d262c48SKyungmin Park * ubi_leb_map - map logical erasblock to a physical eraseblock. 5542d262c48SKyungmin Park * @desc: volume descriptor 5552d262c48SKyungmin Park * @lnum: logical eraseblock number 5562d262c48SKyungmin Park * @dtype: expected data type 5572d262c48SKyungmin Park * 5582d262c48SKyungmin Park * This function maps an un-mapped logical eraseblock @lnum to a physical 5592d262c48SKyungmin Park * eraseblock. This means, that after a successfull invocation of this 5602d262c48SKyungmin Park * function the logical eraseblock @lnum will be empty (contain only %0xFF 5612d262c48SKyungmin Park * bytes) and be mapped to a physical eraseblock, even if an unclean reboot 5622d262c48SKyungmin Park * happens. 5632d262c48SKyungmin Park * 5642d262c48SKyungmin Park * This function returns zero in case of success, %-EBADF if the volume is 5652d262c48SKyungmin Park * damaged because of an interrupted update, %-EBADMSG if the logical 5662d262c48SKyungmin Park * eraseblock is already mapped, and other negative error codes in case of 5672d262c48SKyungmin Park * other failures. 5682d262c48SKyungmin Park */ 5692d262c48SKyungmin Park int ubi_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype) 5702d262c48SKyungmin Park { 5712d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 5722d262c48SKyungmin Park struct ubi_device *ubi = vol->ubi; 5732d262c48SKyungmin Park 5742d262c48SKyungmin Park dbg_msg("unmap LEB %d:%d", vol->vol_id, lnum); 5752d262c48SKyungmin Park 5762d262c48SKyungmin Park if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME) 5772d262c48SKyungmin Park return -EROFS; 5782d262c48SKyungmin Park 5792d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 5802d262c48SKyungmin Park return -EINVAL; 5812d262c48SKyungmin Park 5822d262c48SKyungmin Park if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM && 5832d262c48SKyungmin Park dtype != UBI_UNKNOWN) 5842d262c48SKyungmin Park return -EINVAL; 5852d262c48SKyungmin Park 5862d262c48SKyungmin Park if (vol->upd_marker) 5872d262c48SKyungmin Park return -EBADF; 5882d262c48SKyungmin Park 5892d262c48SKyungmin Park if (vol->eba_tbl[lnum] >= 0) 5902d262c48SKyungmin Park return -EBADMSG; 5912d262c48SKyungmin Park 5922d262c48SKyungmin Park return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype); 5932d262c48SKyungmin Park } 5942d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_leb_map); 5952d262c48SKyungmin Park 5962d262c48SKyungmin Park /** 5972d262c48SKyungmin Park * ubi_is_mapped - check if logical eraseblock is mapped. 5982d262c48SKyungmin Park * @desc: volume descriptor 5992d262c48SKyungmin Park * @lnum: logical eraseblock number 6002d262c48SKyungmin Park * 6012d262c48SKyungmin Park * This function checks if logical eraseblock @lnum is mapped to a physical 6022d262c48SKyungmin Park * eraseblock. If a logical eraseblock is un-mapped, this does not necessarily 6032d262c48SKyungmin Park * mean it will still be un-mapped after the UBI device is re-attached. The 6042d262c48SKyungmin Park * logical eraseblock may become mapped to the physical eraseblock it was last 6052d262c48SKyungmin Park * mapped to. 6062d262c48SKyungmin Park * 6072d262c48SKyungmin Park * This function returns %1 if the LEB is mapped, %0 if not, and a negative 6082d262c48SKyungmin Park * error code in case of failure. If the volume is damaged because of an 6092d262c48SKyungmin Park * interrupted update this function just returns immediately with %-EBADF error 6102d262c48SKyungmin Park * code. 6112d262c48SKyungmin Park */ 6122d262c48SKyungmin Park int ubi_is_mapped(struct ubi_volume_desc *desc, int lnum) 6132d262c48SKyungmin Park { 6142d262c48SKyungmin Park struct ubi_volume *vol = desc->vol; 6152d262c48SKyungmin Park 6162d262c48SKyungmin Park dbg_msg("test LEB %d:%d", vol->vol_id, lnum); 6172d262c48SKyungmin Park 6182d262c48SKyungmin Park if (lnum < 0 || lnum >= vol->reserved_pebs) 6192d262c48SKyungmin Park return -EINVAL; 6202d262c48SKyungmin Park 6212d262c48SKyungmin Park if (vol->upd_marker) 6222d262c48SKyungmin Park return -EBADF; 6232d262c48SKyungmin Park 6242d262c48SKyungmin Park return vol->eba_tbl[lnum] >= 0; 6252d262c48SKyungmin Park } 6262d262c48SKyungmin Park EXPORT_SYMBOL_GPL(ubi_is_mapped); 627