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