Lines Matching defs:ubi
36 #include "ubi.h"
66 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
69 /* "Show" method for files in '/<sysfs>/class/ubi/' */
75 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
82 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
104 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
108 const struct ubi_device *ubi;
110 ubi = container_of(dev, struct ubi_device, dev);
112 return sprintf(buf, "%d\n", ubi->leb_size);
114 return sprintf(buf, "%d\n", ubi->avail_pebs);
116 return sprintf(buf, "%d\n", ubi->good_peb_count);
118 return sprintf(buf, "%d\n", ubi->vol_count);
120 return sprintf(buf, "%d\n", ubi->max_ec);
122 return sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
124 return sprintf(buf, "%d\n", ubi->bad_peb_count);
126 return sprintf(buf, "%d\n", ubi->vtbl_slots);
128 return sprintf(buf, "%d\n", ubi->min_io_size);
130 return sprintf(buf, "%d\n", ubi->thread_enabled);
142 * @ubi: UBI device description object
147 static int ubi_sysfs_init(struct ubi_device *ubi)
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);
159 err = device_create_file(&ubi->dev, &dev_eraseblock_size);
162 err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
165 err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
168 err = device_create_file(&ubi->dev, &dev_volumes_count);
171 err = device_create_file(&ubi->dev, &dev_max_ec);
174 err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
177 err = device_create_file(&ubi->dev, &dev_bad_peb_count);
180 err = device_create_file(&ubi->dev, &dev_max_vol_count);
183 err = device_create_file(&ubi->dev, &dev_min_io_size);
186 err = device_create_file(&ubi->dev, &dev_bgt_enabled);
193 device_remove_file(&ubi->dev, &dev_min_io_size);
195 device_remove_file(&ubi->dev, &dev_max_vol_count);
197 device_remove_file(&ubi->dev, &dev_bad_peb_count);
199 device_remove_file(&ubi->dev, &dev_reserved_for_bad);
201 device_remove_file(&ubi->dev, &dev_max_ec);
203 device_remove_file(&ubi->dev, &dev_volumes_count);
205 device_remove_file(&ubi->dev, &dev_total_eraseblocks);
207 device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
209 device_remove_file(&ubi->dev, &dev_eraseblock_size);
211 device_unregister(&ubi->dev);
213 ubi_err("failed to initialize sysfs for %s", ubi->ubi_name);
219 * @ubi: UBI device description object
221 static void ubi_sysfs_close(struct ubi_device *ubi)
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);
238 * @ubi: UBI device description object
240 static void kill_volumes(struct ubi_device *ubi)
244 for (i = 0; i < ubi->vtbl_slots; i++)
245 if (ubi->volumes[i])
246 ubi_free_volume(ubi, i);
251 * @ubi: UBI device description object
256 static int uif_init(struct ubi_device *ubi)
261 mutex_init(&ubi->vtbl_mutex);
262 spin_lock_init(&ubi->volumes_lock);
264 sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
272 * number and ubi->vtbl_slots + 1 minor numbers.
274 err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
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;
285 dev = MKDEV(ubi->major, 0);
286 err = cdev_add(&ubi->cdev, dev, 1);
288 ubi_err("cannot add character device %s", ubi->ubi_name);
292 err = ubi_sysfs_init(ubi);
296 for (i = 0; i < ubi->vtbl_slots; i++)
297 if (ubi->volumes[i]) {
298 err = ubi_add_volume(ubi, i);
306 kill_volumes(ubi);
307 ubi_sysfs_close(ubi);
309 cdev_del(&ubi->cdev);
311 unregister_chrdev_region(MKDEV(ubi->major, 0),
312 ubi->vtbl_slots + 1);
318 * @ubi: UBI device description object
320 static void uif_close(struct ubi_device *ubi)
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);
330 * @ubi: UBI device descriptor
340 static int attach_by_scanning(struct ubi_device *ubi)
345 si = ubi_scan(ubi);
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;
354 err = ubi_read_volume_table(ubi, si);
358 err = ubi_wl_init_scan(ubi, si);
362 err = ubi_eba_init_scan(ubi, si);
370 ubi_wl_close(ubi);
372 kfree(ubi->vtbl);
380 * @ubi: UBI device description object
382 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
393 static int io_init(struct ubi_device *ubi)
395 if (ubi->mtd->numeraseregions != 0) {
414 ubi->peb_size = ubi->mtd->erasesize;
415 ubi->peb_count = ubi->mtd->size / ubi->mtd->erasesize;
416 ubi->flash_size = ubi->mtd->size;
418 if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
419 ubi->bad_allowed = 1;
421 ubi->min_io_size = ubi->mtd->writesize;
422 ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
425 if (ubi->min_io_size == 0 ||
426 (ubi->min_io_size & (ubi->min_io_size - 1))) {
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);
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);
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);
444 if (ubi->vid_hdr_offset == 0)
446 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
447 ubi->ec_hdr_alsize;
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;
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);
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);
467 if (ubi->vid_hdr_shift % 4) {
469 ubi->vid_hdr_shift);
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) {
479 ubi->vid_hdr_offset, ubi->leb_start);
488 if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
491 ubi->ro_mode = 1;
494 ubi->leb_size = ubi->peb_size - ubi->leb_start;
496 if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
498 "read-only mode", ubi->mtd->index);
499 ubi->ro_mode = 1;
502 dbg_msg("leb_size %d", ubi->leb_size);
503 dbg_msg("ro_mode %d", ubi->ro_mode);
506 * Note, ideally, we have to initialize ubi->bad_peb_count here. But
509 * each physical eraseblock. So, we skip ubi->bad_peb_count
531 struct ubi_device *ubi;
561 ubi_err("mtd%d is already attached to ubi%d",
567 ubi = ubi_devices[ubi_devices_cnt] = kzalloc(sizeof(struct ubi_device),
569 if (!ubi) {
574 ubi->ubi_num = ubi_devices_cnt;
575 ubi->mtd = mtd;
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);
580 ubi->vid_hdr_offset = vid_hdr_offset;
581 ubi->leb_start = data_offset;
582 err = io_init(ubi);
586 err = attach_by_scanning(ubi);
592 err = uif_init(ubi);
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);
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);
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);
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);
618 ubi->beb_rsvd_pebs);
619 ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
623 ubi->thread_enabled = 1;
624 wake_up_process(ubi->bgt_thread);
630 ubi_eba_close(ubi);
631 ubi_wl_close(ubi);
632 kfree(ubi->vtbl);
634 kfree(ubi);
643 * @ubi: UBI device description object
645 static void detach_mtd_dev(struct ubi_device *ubi)
647 int ubi_num = ubi->ubi_num, mtd_num = ubi->mtd->index;
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);
659 ubi_msg("mtd%d is detached from ubi%d", mtd_num, ubi_num);