Merge master.kernel.org:/pub/scm/linux/kernel/git/lethal/sh-2.6
[linux-2.6] / drivers / mtd / ubi / build.c
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  * Copyright (c) Nokia Corporation, 2007
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13  * the GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Author: Artem Bityutskiy (Битюцкий Артём),
20  *         Frank Haverkamp
21  */
22
23 /*
24  * This file includes UBI initialization and building of UBI devices. At the
25  * moment UBI devices may only be added while UBI is initialized, but dynamic
26  * device add/remove functionality is planned. Also, at the moment we only
27  * attach UBI devices by scanning, which will become a bottleneck when flashes
28  * reach certain large size. Then one may improve UBI and add other methods.
29  */
30
31 #include <linux/err.h>
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/stringify.h>
35 #include <linux/stat.h>
36 #include "ubi.h"
37
38 /* Maximum length of the 'mtd=' parameter */
39 #define MTD_PARAM_LEN_MAX 64
40
41 /**
42  * struct mtd_dev_param - MTD device parameter description data structure.
43  * @name: MTD device name or number string
44  * @vid_hdr_offs: VID header offset
45  * @data_offs: data offset
46  */
47 struct mtd_dev_param
48 {
49         char name[MTD_PARAM_LEN_MAX];
50         int vid_hdr_offs;
51         int data_offs;
52 };
53
54 /* Numbers of elements set in the @mtd_dev_param array */
55 static int mtd_devs = 0;
56
57 /* MTD devices specification parameters */
58 static struct mtd_dev_param mtd_dev_param[UBI_MAX_DEVICES];
59
60 /* Number of UBI devices in system */
61 int ubi_devices_cnt;
62
63 /* All UBI devices in system */
64 struct ubi_device *ubi_devices[UBI_MAX_DEVICES];
65
66 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
67 struct class *ubi_class;
68
69 /* "Show" method for files in '/<sysfs>/class/ubi/' */
70 static ssize_t ubi_version_show(struct class *class, char *buf)
71 {
72         return sprintf(buf, "%d\n", UBI_VERSION);
73 }
74
75 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
76 static struct class_attribute ubi_version =
77         __ATTR(version, S_IRUGO, ubi_version_show, NULL);
78
79 static ssize_t dev_attribute_show(struct device *dev,
80                                   struct device_attribute *attr, char *buf);
81
82 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
83 static struct device_attribute dev_eraseblock_size =
84         __ATTR(eraseblock_size, S_IRUGO, dev_attribute_show, NULL);
85 static struct device_attribute dev_avail_eraseblocks =
86         __ATTR(avail_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
87 static struct device_attribute dev_total_eraseblocks =
88         __ATTR(total_eraseblocks, S_IRUGO, dev_attribute_show, NULL);
89 static struct device_attribute dev_volumes_count =
90         __ATTR(volumes_count, S_IRUGO, dev_attribute_show, NULL);
91 static struct device_attribute dev_max_ec =
92         __ATTR(max_ec, S_IRUGO, dev_attribute_show, NULL);
93 static struct device_attribute dev_reserved_for_bad =
94         __ATTR(reserved_for_bad, S_IRUGO, dev_attribute_show, NULL);
95 static struct device_attribute dev_bad_peb_count =
96         __ATTR(bad_peb_count, S_IRUGO, dev_attribute_show, NULL);
97 static struct device_attribute dev_max_vol_count =
98         __ATTR(max_vol_count, S_IRUGO, dev_attribute_show, NULL);
99 static struct device_attribute dev_min_io_size =
100         __ATTR(min_io_size, S_IRUGO, dev_attribute_show, NULL);
101 static struct device_attribute dev_bgt_enabled =
102         __ATTR(bgt_enabled, S_IRUGO, dev_attribute_show, NULL);
103
104 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
105 static ssize_t dev_attribute_show(struct device *dev,
106                                   struct device_attribute *attr, char *buf)
107 {
108         const struct ubi_device *ubi;
109
110         ubi = container_of(dev, struct ubi_device, dev);
111         if (attr == &dev_eraseblock_size)
112                 return sprintf(buf, "%d\n", ubi->leb_size);
113         else if (attr == &dev_avail_eraseblocks)
114                 return sprintf(buf, "%d\n", ubi->avail_pebs);
115         else if (attr == &dev_total_eraseblocks)
116                 return sprintf(buf, "%d\n", ubi->good_peb_count);
117         else if (attr == &dev_volumes_count)
118                 return sprintf(buf, "%d\n", ubi->vol_count);
119         else if (attr == &dev_max_ec)
120                 return sprintf(buf, "%d\n", ubi->max_ec);
121         else if (attr == &dev_reserved_for_bad)
122                 return sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
123         else if (attr == &dev_bad_peb_count)
124                 return sprintf(buf, "%d\n", ubi->bad_peb_count);
125         else if (attr == &dev_max_vol_count)
126                 return sprintf(buf, "%d\n", ubi->vtbl_slots);
127         else if (attr == &dev_min_io_size)
128                 return sprintf(buf, "%d\n", ubi->min_io_size);
129         else if (attr == &dev_bgt_enabled)
130                 return sprintf(buf, "%d\n", ubi->thread_enabled);
131         else
132                 BUG();
133
134         return 0;
135 }
136
137 /* Fake "release" method for UBI devices */
138 static void dev_release(struct device *dev) { }
139
140 /**
141  * ubi_sysfs_init - initialize sysfs for an UBI device.
142  * @ubi: UBI device description object
143  *
144  * This function returns zero in case of success and a negative error code in
145  * case of failure.
146  */
147 static int ubi_sysfs_init(struct ubi_device *ubi)
148 {
149         int err;
150
151         ubi->dev.release = dev_release;
152         ubi->dev.devt = MKDEV(ubi->major, 0);
153         ubi->dev.class = ubi_class;
154         sprintf(&ubi->dev.bus_id[0], UBI_NAME_STR"%d", ubi->ubi_num);
155         err = device_register(&ubi->dev);
156         if (err)
157                 goto out;
158
159         err = device_create_file(&ubi->dev, &dev_eraseblock_size);
160         if (err)
161                 goto out_unregister;
162         err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
163         if (err)
164                 goto out_eraseblock_size;
165         err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
166         if (err)
167                 goto out_avail_eraseblocks;
168         err = device_create_file(&ubi->dev, &dev_volumes_count);
169         if (err)
170                 goto out_total_eraseblocks;
171         err = device_create_file(&ubi->dev, &dev_max_ec);
172         if (err)
173                 goto out_volumes_count;
174         err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
175         if (err)
176                 goto out_volumes_max_ec;
177         err = device_create_file(&ubi->dev, &dev_bad_peb_count);
178         if (err)
179                 goto out_reserved_for_bad;
180         err = device_create_file(&ubi->dev, &dev_max_vol_count);
181         if (err)
182                 goto out_bad_peb_count;
183         err = device_create_file(&ubi->dev, &dev_min_io_size);
184         if (err)
185                 goto out_max_vol_count;
186         err = device_create_file(&ubi->dev, &dev_bgt_enabled);
187         if (err)
188                 goto out_min_io_size;
189
190         return 0;
191
192 out_min_io_size:
193         device_remove_file(&ubi->dev, &dev_min_io_size);
194 out_max_vol_count:
195         device_remove_file(&ubi->dev, &dev_max_vol_count);
196 out_bad_peb_count:
197         device_remove_file(&ubi->dev, &dev_bad_peb_count);
198 out_reserved_for_bad:
199         device_remove_file(&ubi->dev, &dev_reserved_for_bad);
200 out_volumes_max_ec:
201         device_remove_file(&ubi->dev, &dev_max_ec);
202 out_volumes_count:
203         device_remove_file(&ubi->dev, &dev_volumes_count);
204 out_total_eraseblocks:
205         device_remove_file(&ubi->dev, &dev_total_eraseblocks);
206 out_avail_eraseblocks:
207         device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
208 out_eraseblock_size:
209         device_remove_file(&ubi->dev, &dev_eraseblock_size);
210 out_unregister:
211         device_unregister(&ubi->dev);
212 out:
213         ubi_err("failed to initialize sysfs for %s", ubi->ubi_name);
214         return err;
215 }
216
217 /**
218  * ubi_sysfs_close - close sysfs for an UBI device.
219  * @ubi: UBI device description object
220  */
221 static void ubi_sysfs_close(struct ubi_device *ubi)
222 {
223         device_remove_file(&ubi->dev, &dev_bgt_enabled);
224         device_remove_file(&ubi->dev, &dev_min_io_size);
225         device_remove_file(&ubi->dev, &dev_max_vol_count);
226         device_remove_file(&ubi->dev, &dev_bad_peb_count);
227         device_remove_file(&ubi->dev, &dev_reserved_for_bad);
228         device_remove_file(&ubi->dev, &dev_max_ec);
229         device_remove_file(&ubi->dev, &dev_volumes_count);
230         device_remove_file(&ubi->dev, &dev_total_eraseblocks);
231         device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
232         device_remove_file(&ubi->dev, &dev_eraseblock_size);
233         device_unregister(&ubi->dev);
234 }
235
236 /**
237  * kill_volumes - destroy all volumes.
238  * @ubi: UBI device description object
239  */
240 static void kill_volumes(struct ubi_device *ubi)
241 {
242         int i;
243
244         for (i = 0; i < ubi->vtbl_slots; i++)
245                 if (ubi->volumes[i])
246                         ubi_free_volume(ubi, i);
247 }
248
249 /**
250  * uif_init - initialize user interfaces for an UBI device.
251  * @ubi: UBI device description object
252  *
253  * This function returns zero in case of success and a negative error code in
254  * case of failure.
255  */
256 static int uif_init(struct ubi_device *ubi)
257 {
258         int i, err;
259         dev_t dev;
260
261         mutex_init(&ubi->vtbl_mutex);
262         spin_lock_init(&ubi->volumes_lock);
263
264         sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
265
266         /*
267          * Major numbers for the UBI character devices are allocated
268          * dynamically. Major numbers of volume character devices are
269          * equivalent to ones of the corresponding UBI character device. Minor
270          * numbers of UBI character devices are 0, while minor numbers of
271          * volume character devices start from 1. Thus, we allocate one major
272          * number and ubi->vtbl_slots + 1 minor numbers.
273          */
274         err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
275         if (err) {
276                 ubi_err("cannot register UBI character devices");
277                 return err;
278         }
279
280         cdev_init(&ubi->cdev, &ubi_cdev_operations);
281         ubi->major = MAJOR(dev);
282         dbg_msg("%s major is %u", ubi->ubi_name, ubi->major);
283         ubi->cdev.owner = THIS_MODULE;
284
285         dev = MKDEV(ubi->major, 0);
286         err = cdev_add(&ubi->cdev, dev, 1);
287         if (err) {
288                 ubi_err("cannot add character device %s", ubi->ubi_name);
289                 goto out_unreg;
290         }
291
292         err = ubi_sysfs_init(ubi);
293         if (err)
294                 goto out_cdev;
295
296         for (i = 0; i < ubi->vtbl_slots; i++)
297                 if (ubi->volumes[i]) {
298                         err = ubi_add_volume(ubi, i);
299                         if (err)
300                                 goto out_volumes;
301                 }
302
303         return 0;
304
305 out_volumes:
306         kill_volumes(ubi);
307         ubi_sysfs_close(ubi);
308 out_cdev:
309         cdev_del(&ubi->cdev);
310 out_unreg:
311         unregister_chrdev_region(MKDEV(ubi->major, 0),
312                                  ubi->vtbl_slots + 1);
313         return err;
314 }
315
316 /**
317  * uif_close - close user interfaces for an UBI device.
318  * @ubi: UBI device description object
319  */
320 static void uif_close(struct ubi_device *ubi)
321 {
322         kill_volumes(ubi);
323         ubi_sysfs_close(ubi);
324         cdev_del(&ubi->cdev);
325         unregister_chrdev_region(MKDEV(ubi->major, 0), ubi->vtbl_slots + 1);
326 }
327
328 /**
329  * attach_by_scanning - attach an MTD device using scanning method.
330  * @ubi: UBI device descriptor
331  *
332  * This function returns zero in case of success and a negative error code in
333  * case of failure.
334  *
335  * Note, currently this is the only method to attach UBI devices. Hopefully in
336  * the future we'll have more scalable attaching methods and avoid full media
337  * scanning. But even in this case scanning will be needed as a fall-back
338  * attaching method if there are some on-flash table corruptions.
339  */
340 static int attach_by_scanning(struct ubi_device *ubi)
341 {
342         int err;
343         struct ubi_scan_info *si;
344
345         si = ubi_scan(ubi);
346         if (IS_ERR(si))
347                 return PTR_ERR(si);
348
349         ubi->bad_peb_count = si->bad_peb_count;
350         ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
351         ubi->max_ec = si->max_ec;
352         ubi->mean_ec = si->mean_ec;
353
354         err = ubi_read_volume_table(ubi, si);
355         if (err)
356                 goto out_si;
357
358         err = ubi_wl_init_scan(ubi, si);
359         if (err)
360                 goto out_vtbl;
361
362         err = ubi_eba_init_scan(ubi, si);
363         if (err)
364                 goto out_wl;
365
366         ubi_scan_destroy_si(si);
367         return 0;
368
369 out_wl:
370         ubi_wl_close(ubi);
371 out_vtbl:
372         kfree(ubi->vtbl);
373 out_si:
374         ubi_scan_destroy_si(si);
375         return err;
376 }
377
378 /**
379  * io_init - initialize I/O unit for a given UBI device.
380  * @ubi: UBI device description object
381  *
382  * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
383  * assumed:
384  *   o EC header is always at offset zero - this cannot be changed;
385  *   o VID header starts just after the EC header at the closest address
386  *   aligned to @io->@hdrs_min_io_size;
387  *   o data starts just after the VID header at the closest address aligned to
388  *     @io->@min_io_size
389  *
390  * This function returns zero in case of success and a negative error code in
391  * case of failure.
392  */
393 static int io_init(struct ubi_device *ubi)
394 {
395         if (ubi->mtd->numeraseregions != 0) {
396                 /*
397                  * Some flashes have several erase regions. Different regions
398                  * may have different eraseblock size and other
399                  * characteristics. It looks like mostly multi-region flashes
400                  * have one "main" region and one or more small regions to
401                  * store boot loader code or boot parameters or whatever. I
402                  * guess we should just pick the largest region. But this is
403                  * not implemented.
404                  */
405                 ubi_err("multiple regions, not implemented");
406                 return -EINVAL;
407         }
408
409         /*
410          * Note, in this implementation we support MTD devices with 0x7FFFFFFF
411          * physical eraseblocks maximum.
412          */
413
414         ubi->peb_size   = ubi->mtd->erasesize;
415         ubi->peb_count  = ubi->mtd->size / ubi->mtd->erasesize;
416         ubi->flash_size = ubi->mtd->size;
417
418         if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
419                 ubi->bad_allowed = 1;
420
421         ubi->min_io_size = ubi->mtd->writesize;
422         ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
423
424         /* Make sure minimal I/O unit is power of 2 */
425         if (ubi->min_io_size == 0 ||
426             (ubi->min_io_size & (ubi->min_io_size - 1))) {
427                 ubi_err("bad min. I/O unit");
428                 return -EINVAL;
429         }
430
431         ubi_assert(ubi->hdrs_min_io_size > 0);
432         ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
433         ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
434
435         /* Calculate default aligned sizes of EC and VID headers */
436         ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
437         ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
438
439         dbg_msg("min_io_size      %d", ubi->min_io_size);
440         dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
441         dbg_msg("ec_hdr_alsize    %d", ubi->ec_hdr_alsize);
442         dbg_msg("vid_hdr_alsize   %d", ubi->vid_hdr_alsize);
443
444         if (ubi->vid_hdr_offset == 0)
445                 /* Default offset */
446                 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
447                                       ubi->ec_hdr_alsize;
448         else {
449                 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
450                                                 ~(ubi->hdrs_min_io_size - 1);
451                 ubi->vid_hdr_shift = ubi->vid_hdr_offset -
452                                                 ubi->vid_hdr_aloffset;
453         }
454
455         /* Similar for the data offset */
456         if (ubi->leb_start == 0) {
457                 ubi->leb_start = ubi->vid_hdr_offset + ubi->vid_hdr_alsize;
458                 ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
459         }
460
461         dbg_msg("vid_hdr_offset   %d", ubi->vid_hdr_offset);
462         dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
463         dbg_msg("vid_hdr_shift    %d", ubi->vid_hdr_shift);
464         dbg_msg("leb_start        %d", ubi->leb_start);
465
466         /* The shift must be aligned to 32-bit boundary */
467         if (ubi->vid_hdr_shift % 4) {
468                 ubi_err("unaligned VID header shift %d",
469                         ubi->vid_hdr_shift);
470                 return -EINVAL;
471         }
472
473         /* Check sanity */
474         if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
475             ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
476             ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
477             ubi->leb_start % ubi->min_io_size) {
478                 ubi_err("bad VID header (%d) or data offsets (%d)",
479                         ubi->vid_hdr_offset, ubi->leb_start);
480                 return -EINVAL;
481         }
482
483         /*
484          * It may happen that EC and VID headers are situated in one minimal
485          * I/O unit. In this case we can only accept this UBI image in
486          * read-only mode.
487          */
488         if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
489                 ubi_warn("EC and VID headers are in the same minimal I/O unit, "
490                          "switch to read-only mode");
491                 ubi->ro_mode = 1;
492         }
493
494         ubi->leb_size = ubi->peb_size - ubi->leb_start;
495
496         if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
497                 ubi_msg("MTD device %d is write-protected, attach in "
498                         "read-only mode", ubi->mtd->index);
499                 ubi->ro_mode = 1;
500         }
501
502         dbg_msg("leb_size         %d", ubi->leb_size);
503         dbg_msg("ro_mode          %d", ubi->ro_mode);
504
505         /*
506          * Note, ideally, we have to initialize ubi->bad_peb_count here. But
507          * unfortunately, MTD does not provide this information. We should loop
508          * over all physical eraseblocks and invoke mtd->block_is_bad() for
509          * each physical eraseblock. So, we skip ubi->bad_peb_count
510          * uninitialized and initialize it after scanning.
511          */
512
513         return 0;
514 }
515
516 /**
517  * attach_mtd_dev - attach an MTD device.
518  * @mtd_dev: MTD device name or number string
519  * @vid_hdr_offset: VID header offset
520  * @data_offset: data offset
521  *
522  * This function attaches an MTD device to UBI. It first treats @mtd_dev as the
523  * MTD device name, and tries to open it by this name. If it is unable to open,
524  * it tries to convert @mtd_dev to an integer and open the MTD device by its
525  * number. Returns zero in case of success and a negative error code in case of
526  * failure.
527  */
528 static int attach_mtd_dev(const char *mtd_dev, int vid_hdr_offset,
529                           int data_offset)
530 {
531         struct ubi_device *ubi;
532         struct mtd_info *mtd;
533         int i, err;
534
535         mtd = get_mtd_device_nm(mtd_dev);
536         if (IS_ERR(mtd)) {
537                 int mtd_num;
538                 char *endp;
539
540                 if (PTR_ERR(mtd) != -ENODEV)
541                         return PTR_ERR(mtd);
542
543                 /*
544                  * Probably this is not MTD device name but MTD device number -
545                  * check this out.
546                  */
547                 mtd_num = simple_strtoul(mtd_dev, &endp, 0);
548                 if (*endp != '\0' || mtd_dev == endp) {
549                         ubi_err("incorrect MTD device: \"%s\"", mtd_dev);
550                         return -ENODEV;
551                 }
552
553                 mtd = get_mtd_device(NULL, mtd_num);
554                 if (IS_ERR(mtd))
555                         return PTR_ERR(mtd);
556         }
557
558         /* Check if we already have the same MTD device attached */
559         for (i = 0; i < ubi_devices_cnt; i++)
560                 if (ubi_devices[i]->mtd->index == mtd->index) {
561                         ubi_err("mtd%d is already attached to ubi%d",
562                                 mtd->index, i);
563                         err = -EINVAL;
564                         goto out_mtd;
565                 }
566
567         ubi = ubi_devices[ubi_devices_cnt] = kzalloc(sizeof(struct ubi_device),
568                                                       GFP_KERNEL);
569         if (!ubi) {
570                 err = -ENOMEM;
571                 goto out_mtd;
572         }
573
574         ubi->ubi_num = ubi_devices_cnt;
575         ubi->mtd = mtd;
576
577         dbg_msg("attaching mtd%d to ubi%d: VID header offset %d data offset %d",
578                 ubi->mtd->index, ubi_devices_cnt, vid_hdr_offset, data_offset);
579
580         ubi->vid_hdr_offset = vid_hdr_offset;
581         ubi->leb_start = data_offset;
582         err = io_init(ubi);
583         if (err)
584                 goto out_free;
585
586         err = attach_by_scanning(ubi);
587         if (err) {
588                 dbg_err("failed to attach by scanning, error %d", err);
589                 goto out_free;
590         }
591
592         err = uif_init(ubi);
593         if (err)
594                 goto out_detach;
595
596         ubi_devices_cnt += 1;
597
598         ubi_msg("attached mtd%d to ubi%d", ubi->mtd->index, ubi_devices_cnt);
599         ubi_msg("MTD device name:            \"%s\"", ubi->mtd->name);
600         ubi_msg("MTD device size:            %llu MiB", ubi->flash_size >> 20);
601         ubi_msg("physical eraseblock size:   %d bytes (%d KiB)",
602                 ubi->peb_size, ubi->peb_size >> 10);
603         ubi_msg("logical eraseblock size:    %d bytes", ubi->leb_size);
604         ubi_msg("number of good PEBs:        %d", ubi->good_peb_count);
605         ubi_msg("number of bad PEBs:         %d", ubi->bad_peb_count);
606         ubi_msg("smallest flash I/O unit:    %d", ubi->min_io_size);
607         ubi_msg("VID header offset:          %d (aligned %d)",
608                 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
609         ubi_msg("data offset:                %d", ubi->leb_start);
610         ubi_msg("max. allowed volumes:       %d", ubi->vtbl_slots);
611         ubi_msg("wear-leveling threshold:    %d", CONFIG_MTD_UBI_WL_THRESHOLD);
612         ubi_msg("number of internal volumes: %d", UBI_INT_VOL_COUNT);
613         ubi_msg("number of user volumes:     %d",
614                 ubi->vol_count - UBI_INT_VOL_COUNT);
615         ubi_msg("available PEBs:             %d", ubi->avail_pebs);
616         ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
617         ubi_msg("number of PEBs reserved for bad PEB handling: %d",
618                 ubi->beb_rsvd_pebs);
619         ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
620
621         /* Enable the background thread */
622         if (!DBG_DISABLE_BGT) {
623                 ubi->thread_enabled = 1;
624                 wake_up_process(ubi->bgt_thread);
625         }
626
627         return 0;
628
629 out_detach:
630         ubi_eba_close(ubi);
631         ubi_wl_close(ubi);
632         kfree(ubi->vtbl);
633 out_free:
634         kfree(ubi);
635 out_mtd:
636         put_mtd_device(mtd);
637         ubi_devices[ubi_devices_cnt] = NULL;
638         return err;
639 }
640
641 /**
642  * detach_mtd_dev - detach an MTD device.
643  * @ubi: UBI device description object
644  */
645 static void detach_mtd_dev(struct ubi_device *ubi)
646 {
647         int ubi_num = ubi->ubi_num, mtd_num = ubi->mtd->index;
648
649         dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
650         uif_close(ubi);
651         ubi_eba_close(ubi);
652         ubi_wl_close(ubi);
653         kfree(ubi->vtbl);
654         put_mtd_device(ubi->mtd);
655         kfree(ubi_devices[ubi_num]);
656         ubi_devices[ubi_num] = NULL;
657         ubi_devices_cnt -= 1;
658         ubi_assert(ubi_devices_cnt >= 0);
659         ubi_msg("mtd%d is detached from ubi%d", mtd_num, ubi_num);
660 }
661
662 static int __init ubi_init(void)
663 {
664         int err, i, k;
665
666         /* Ensure that EC and VID headers have correct size */
667         BUILD_BUG_ON(sizeof(struct ubi_ec_hdr) != 64);
668         BUILD_BUG_ON(sizeof(struct ubi_vid_hdr) != 64);
669
670         if (mtd_devs > UBI_MAX_DEVICES) {
671                 printk("UBI error: too many MTD devices, maximum is %d\n",
672                        UBI_MAX_DEVICES);
673                 return -EINVAL;
674         }
675
676         ubi_class = class_create(THIS_MODULE, UBI_NAME_STR);
677         if (IS_ERR(ubi_class))
678                 return PTR_ERR(ubi_class);
679
680         err = class_create_file(ubi_class, &ubi_version);
681         if (err)
682                 goto out_class;
683
684         /* Attach MTD devices */
685         for (i = 0; i < mtd_devs; i++) {
686                 struct mtd_dev_param *p = &mtd_dev_param[i];
687
688                 cond_resched();
689
690                 if (!p->name) {
691                         dbg_err("empty name");
692                         err = -EINVAL;
693                         goto out_detach;
694                 }
695
696                 err = attach_mtd_dev(p->name, p->vid_hdr_offs, p->data_offs);
697                 if (err)
698                         goto out_detach;
699         }
700
701         return 0;
702
703 out_detach:
704         for (k = 0; k < i; k++)
705                 detach_mtd_dev(ubi_devices[k]);
706         class_remove_file(ubi_class, &ubi_version);
707 out_class:
708         class_destroy(ubi_class);
709         return err;
710 }
711 module_init(ubi_init);
712
713 static void __exit ubi_exit(void)
714 {
715         int i, n = ubi_devices_cnt;
716
717         for (i = 0; i < n; i++)
718                 detach_mtd_dev(ubi_devices[i]);
719         class_remove_file(ubi_class, &ubi_version);
720         class_destroy(ubi_class);
721 }
722 module_exit(ubi_exit);
723
724 /**
725  * bytes_str_to_int - convert a string representing number of bytes to an
726  * integer.
727  * @str: the string to convert
728  *
729  * This function returns positive resulting integer in case of success and a
730  * negative error code in case of failure.
731  */
732 static int __init bytes_str_to_int(const char *str)
733 {
734         char *endp;
735         unsigned long result;
736
737         result = simple_strtoul(str, &endp, 0);
738         if (str == endp || result < 0) {
739                 printk("UBI error: incorrect bytes count: \"%s\"\n", str);
740                 return -EINVAL;
741         }
742
743         switch (*endp) {
744         case 'G':
745                 result *= 1024;
746         case 'M':
747                 result *= 1024;
748         case 'K':
749         case 'k':
750                 result *= 1024;
751                 if (endp[1] == 'i' && (endp[2] == '\0' ||
752                           endp[2] == 'B'  || endp[2] == 'b'))
753                         endp += 2;
754         case '\0':
755                 break;
756         default:
757                 printk("UBI error: incorrect bytes count: \"%s\"\n", str);
758                 return -EINVAL;
759         }
760
761         return result;
762 }
763
764 /**
765  * ubi_mtd_param_parse - parse the 'mtd=' UBI parameter.
766  * @val: the parameter value to parse
767  * @kp: not used
768  *
769  * This function returns zero in case of success and a negative error code in
770  * case of error.
771  */
772 static int __init ubi_mtd_param_parse(const char *val, struct kernel_param *kp)
773 {
774         int i, len;
775         struct mtd_dev_param *p;
776         char buf[MTD_PARAM_LEN_MAX];
777         char *pbuf = &buf[0];
778         char *tokens[3] = {NULL, NULL, NULL};
779
780         if (mtd_devs == UBI_MAX_DEVICES) {
781                 printk("UBI error: too many parameters, max. is %d\n",
782                        UBI_MAX_DEVICES);
783                 return -EINVAL;
784         }
785
786         len = strnlen(val, MTD_PARAM_LEN_MAX);
787         if (len == MTD_PARAM_LEN_MAX) {
788                 printk("UBI error: parameter \"%s\" is too long, max. is %d\n",
789                        val, MTD_PARAM_LEN_MAX);
790                 return -EINVAL;
791         }
792
793         if (len == 0) {
794                 printk("UBI warning: empty 'mtd=' parameter - ignored\n");
795                 return 0;
796         }
797
798         strcpy(buf, val);
799
800         /* Get rid of the final newline */
801         if (buf[len - 1] == '\n')
802                 buf[len - 1] = 0;
803
804         for (i = 0; i < 3; i++)
805                 tokens[i] = strsep(&pbuf, ",");
806
807         if (pbuf) {
808                 printk("UBI error: too many arguments at \"%s\"\n", val);
809                 return -EINVAL;
810         }
811
812         if (tokens[0] == '\0')
813                 return -EINVAL;
814
815         p = &mtd_dev_param[mtd_devs];
816         strcpy(&p->name[0], tokens[0]);
817
818         if (tokens[1])
819                 p->vid_hdr_offs = bytes_str_to_int(tokens[1]);
820         if (tokens[2])
821                 p->data_offs = bytes_str_to_int(tokens[2]);
822
823         if (p->vid_hdr_offs < 0)
824                 return p->vid_hdr_offs;
825         if (p->data_offs < 0)
826                 return p->data_offs;
827
828         mtd_devs += 1;
829         return 0;
830 }
831
832 module_param_call(mtd, ubi_mtd_param_parse, NULL, NULL, 000);
833 MODULE_PARM_DESC(mtd, "MTD devices to attach. Parameter format: "
834                       "mtd=<name|num>[,<vid_hdr_offs>,<data_offs>]. "
835                       "Multiple \"mtd\" parameters may be specified.\n"
836                       "MTD devices may be specified by their number or name. "
837                       "Optional \"vid_hdr_offs\" and \"data_offs\" parameters "
838                       "specify UBI VID header position and data starting "
839                       "position to be used by UBI.\n"
840                       "Example: mtd=content,1984,2048 mtd=4 - attach MTD device"
841                       "with name content using VID header offset 1984 and data "
842                       "start 2048, and MTD device number 4 using default "
843                       "offsets");
844
845 MODULE_VERSION(__stringify(UBI_VERSION));
846 MODULE_DESCRIPTION("UBI - Unsorted Block Images");
847 MODULE_AUTHOR("Artem Bityutskiy");
848 MODULE_LICENSE("GPL");