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