Lines Matching refs:ubi
47 #include "ubi.h"
75 /* Root UBI "class" object (corresponds to '/<sysfs>/class/ubi/') */
94 /* Protects @ubi_devices and @ubi->ref_count */
97 /* "Show" method for files in '/<sysfs>/class/ubi/' */
104 /* UBI version attribute ('/<sysfs>/class/ubi/version') */
111 /* UBI device attributes (correspond to files in '/<sysfs>/class/ubi/ubiX') */
137 * @ubi: UBI device description object
145 int ubi_volume_notify(struct ubi_device *ubi, struct ubi_volume *vol, int ntype)
149 ubi_do_get_device_info(ubi, &nt.di);
150 ubi_do_get_volume_info(ubi, vol, &nt.vi);
156 * @ubi: UBI device description object
160 * This function walks all volumes of UBI device @ubi and sends the @ntype
165 int ubi_notify_all(struct ubi_device *ubi, int ntype, struct notifier_block *nb)
170 ubi_do_get_device_info(ubi, &nt.di);
172 mutex_lock(&ubi->device_mutex);
173 for (i = 0; i < ubi->vtbl_slots; i++) {
175 * Since the @ubi->device is locked, and we are not going to
176 * change @ubi->volumes, we do not have to lock
177 * @ubi->volumes_lock.
179 if (!ubi->volumes[i])
182 ubi_do_get_volume_info(ubi, ubi->volumes[i], &nt.vi);
190 mutex_unlock(&ubi->device_mutex);
213 struct ubi_device *ubi = ubi_devices[i];
215 if (!ubi)
217 count += ubi_notify_all(ubi, UBI_VOLUME_ADDED, nb);
234 struct ubi_device *ubi;
237 ubi = ubi_devices[ubi_num];
238 if (ubi) {
239 ubi_assert(ubi->ref_count >= 0);
240 ubi->ref_count += 1;
241 get_device(&ubi->dev);
245 return ubi;
250 * @ubi: UBI device description object
252 void ubi_put_device(struct ubi_device *ubi)
255 ubi->ref_count -= 1;
256 put_device(&ubi->dev);
270 struct ubi_device *ubi;
274 ubi = ubi_devices[i];
275 if (ubi && MAJOR(ubi->cdev.dev) == major) {
276 ubi_assert(ubi->ref_count >= 0);
277 ubi->ref_count += 1;
278 get_device(&ubi->dev);
280 return ubi;
302 struct ubi_device *ubi = ubi_devices[i];
304 if (ubi && MAJOR(ubi->cdev.dev) == major) {
305 ubi_num = ubi->ubi_num;
314 /* "Show" method for files in '/<sysfs>/class/ubi/ubiX/' */
319 struct ubi_device *ubi;
329 * we still can use 'ubi->ubi_num'.
331 ubi = container_of(dev, struct ubi_device, dev);
332 ubi = ubi_get_device(ubi->ubi_num);
333 if (!ubi)
337 ret = sprintf(buf, "%d\n", ubi->leb_size);
339 ret = sprintf(buf, "%d\n", ubi->avail_pebs);
341 ret = sprintf(buf, "%d\n", ubi->good_peb_count);
343 ret = sprintf(buf, "%d\n", ubi->vol_count - UBI_INT_VOL_COUNT);
345 ret = sprintf(buf, "%d\n", ubi->max_ec);
347 ret = sprintf(buf, "%d\n", ubi->beb_rsvd_pebs);
349 ret = sprintf(buf, "%d\n", ubi->bad_peb_count);
351 ret = sprintf(buf, "%d\n", ubi->vtbl_slots);
353 ret = sprintf(buf, "%d\n", ubi->min_io_size);
355 ret = sprintf(buf, "%d\n", ubi->thread_enabled);
357 ret = sprintf(buf, "%d\n", ubi->mtd->index);
361 ubi_put_device(ubi);
367 struct ubi_device *ubi = container_of(dev, struct ubi_device, dev);
369 kfree(ubi);
374 * @ubi: UBI device description object
375 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
381 static int ubi_sysfs_init(struct ubi_device *ubi, int *ref)
385 ubi->dev.release = dev_release;
386 ubi->dev.devt = ubi->cdev.dev;
387 ubi->dev.class = ubi_class;
388 dev_set_name(&ubi->dev, UBI_NAME_STR"%d", ubi->ubi_num);
389 err = device_register(&ubi->dev);
394 err = device_create_file(&ubi->dev, &dev_eraseblock_size);
397 err = device_create_file(&ubi->dev, &dev_avail_eraseblocks);
400 err = device_create_file(&ubi->dev, &dev_total_eraseblocks);
403 err = device_create_file(&ubi->dev, &dev_volumes_count);
406 err = device_create_file(&ubi->dev, &dev_max_ec);
409 err = device_create_file(&ubi->dev, &dev_reserved_for_bad);
412 err = device_create_file(&ubi->dev, &dev_bad_peb_count);
415 err = device_create_file(&ubi->dev, &dev_max_vol_count);
418 err = device_create_file(&ubi->dev, &dev_min_io_size);
421 err = device_create_file(&ubi->dev, &dev_bgt_enabled);
424 err = device_create_file(&ubi->dev, &dev_mtd_num);
430 * @ubi: UBI device description object
432 static void ubi_sysfs_close(struct ubi_device *ubi)
434 device_remove_file(&ubi->dev, &dev_mtd_num);
435 device_remove_file(&ubi->dev, &dev_bgt_enabled);
436 device_remove_file(&ubi->dev, &dev_min_io_size);
437 device_remove_file(&ubi->dev, &dev_max_vol_count);
438 device_remove_file(&ubi->dev, &dev_bad_peb_count);
439 device_remove_file(&ubi->dev, &dev_reserved_for_bad);
440 device_remove_file(&ubi->dev, &dev_max_ec);
441 device_remove_file(&ubi->dev, &dev_volumes_count);
442 device_remove_file(&ubi->dev, &dev_total_eraseblocks);
443 device_remove_file(&ubi->dev, &dev_avail_eraseblocks);
444 device_remove_file(&ubi->dev, &dev_eraseblock_size);
445 device_unregister(&ubi->dev);
450 * @ubi: UBI device description object
452 static void kill_volumes(struct ubi_device *ubi)
456 for (i = 0; i < ubi->vtbl_slots; i++)
457 if (ubi->volumes[i])
458 ubi_free_volume(ubi, ubi->volumes[i]);
463 * @ubi: UBI device description object
464 * @ref: set to %1 on exit in case of failure if a reference to @ubi->dev was
471 * driver core subsystem, this function takes a reference to @ubi->dev, because
472 * otherwise the release function ('dev_release()') would free whole @ubi
479 static int uif_init(struct ubi_device *ubi, int *ref)
485 sprintf(ubi->ubi_name, UBI_NAME_STR "%d", ubi->ubi_num);
493 * number and ubi->vtbl_slots + 1 minor numbers.
495 err = alloc_chrdev_region(&dev, 0, ubi->vtbl_slots + 1, ubi->ubi_name);
502 cdev_init(&ubi->cdev, &ubi_cdev_operations);
503 dbg_gen("%s major is %u", ubi->ubi_name, MAJOR(dev));
504 ubi->cdev.owner = THIS_MODULE;
506 err = cdev_add(&ubi->cdev, dev, 1);
512 err = ubi_sysfs_init(ubi, ref);
516 for (i = 0; i < ubi->vtbl_slots; i++)
517 if (ubi->volumes[i]) {
518 err = ubi_add_volume(ubi, ubi->volumes[i]);
528 kill_volumes(ubi);
531 get_device(&ubi->dev);
532 ubi_sysfs_close(ubi);
533 cdev_del(&ubi->cdev);
535 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
536 ubi_err("cannot initialize UBI %s, error %d", ubi->ubi_name, err);
542 * @ubi: UBI device description object
548 static void uif_close(struct ubi_device *ubi)
550 kill_volumes(ubi);
551 ubi_sysfs_close(ubi);
552 cdev_del(&ubi->cdev);
553 unregister_chrdev_region(ubi->cdev.dev, ubi->vtbl_slots + 1);
558 * @ubi: UBI device description object
560 static void free_internal_volumes(struct ubi_device *ubi)
564 for (i = ubi->vtbl_slots;
565 i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
566 kfree(ubi->volumes[i]->eba_tbl);
567 kfree(ubi->volumes[i]);
573 * @ubi: UBI device descriptor
583 static int attach_by_scanning(struct ubi_device *ubi)
588 si = ubi_scan(ubi);
592 ubi->bad_peb_count = si->bad_peb_count;
593 ubi->good_peb_count = ubi->peb_count - ubi->bad_peb_count;
594 ubi->max_ec = si->max_ec;
595 ubi->mean_ec = si->mean_ec;
598 err = ubi_read_volume_table(ubi, si);
602 err = ubi_wl_init_scan(ubi, si);
606 err = ubi_eba_init_scan(ubi, si);
614 ubi_wl_close(ubi);
616 free_internal_volumes(ubi);
617 vfree(ubi->vtbl);
625 * @ubi: UBI device description object
627 * If @ubi->vid_hdr_offset or @ubi->leb_start is zero, default offsets are
638 static int io_init(struct ubi_device *ubi)
640 if (ubi->mtd->numeraseregions != 0) {
654 if (ubi->vid_hdr_offset < 0)
662 ubi->peb_size = ubi->mtd->erasesize;
663 ubi->peb_count = mtd_div_by_eb(ubi->mtd->size, ubi->mtd);
664 ubi->flash_size = ubi->mtd->size;
666 if (ubi->mtd->block_isbad && ubi->mtd->block_markbad)
667 ubi->bad_allowed = 1;
669 if (ubi->mtd->type == MTD_NORFLASH) {
670 ubi_assert(ubi->mtd->writesize == 1);
671 ubi->nor_flash = 1;
674 ubi->min_io_size = ubi->mtd->writesize;
675 ubi->hdrs_min_io_size = ubi->mtd->writesize >> ubi->mtd->subpage_sft;
682 if (!is_power_of_2(ubi->min_io_size)) {
684 ubi->min_io_size);
688 ubi_assert(ubi->hdrs_min_io_size > 0);
689 ubi_assert(ubi->hdrs_min_io_size <= ubi->min_io_size);
690 ubi_assert(ubi->min_io_size % ubi->hdrs_min_io_size == 0);
693 ubi->ec_hdr_alsize = ALIGN(UBI_EC_HDR_SIZE, ubi->hdrs_min_io_size);
694 ubi->vid_hdr_alsize = ALIGN(UBI_VID_HDR_SIZE, ubi->hdrs_min_io_size);
696 dbg_msg("min_io_size %d", ubi->min_io_size);
697 dbg_msg("hdrs_min_io_size %d", ubi->hdrs_min_io_size);
698 dbg_msg("ec_hdr_alsize %d", ubi->ec_hdr_alsize);
699 dbg_msg("vid_hdr_alsize %d", ubi->vid_hdr_alsize);
701 if (ubi->vid_hdr_offset == 0)
703 ubi->vid_hdr_offset = ubi->vid_hdr_aloffset =
704 ubi->ec_hdr_alsize;
706 ubi->vid_hdr_aloffset = ubi->vid_hdr_offset &
707 ~(ubi->hdrs_min_io_size - 1);
708 ubi->vid_hdr_shift = ubi->vid_hdr_offset -
709 ubi->vid_hdr_aloffset;
713 ubi->leb_start = ubi->vid_hdr_offset + UBI_EC_HDR_SIZE;
714 ubi->leb_start = ALIGN(ubi->leb_start, ubi->min_io_size);
716 dbg_msg("vid_hdr_offset %d", ubi->vid_hdr_offset);
717 dbg_msg("vid_hdr_aloffset %d", ubi->vid_hdr_aloffset);
718 dbg_msg("vid_hdr_shift %d", ubi->vid_hdr_shift);
719 dbg_msg("leb_start %d", ubi->leb_start);
722 if (ubi->vid_hdr_shift % 4) {
724 ubi->vid_hdr_shift);
729 if (ubi->vid_hdr_offset < UBI_EC_HDR_SIZE ||
730 ubi->leb_start < ubi->vid_hdr_offset + UBI_VID_HDR_SIZE ||
731 ubi->leb_start > ubi->peb_size - UBI_VID_HDR_SIZE ||
732 ubi->leb_start & (ubi->min_io_size - 1)) {
734 ubi->vid_hdr_offset, ubi->leb_start);
742 ubi->max_erroneous = ubi->peb_count / 10;
743 if (ubi->max_erroneous < 16)
744 ubi->max_erroneous = 16;
745 dbg_msg("max_erroneous %d", ubi->max_erroneous);
752 if (ubi->vid_hdr_offset + UBI_VID_HDR_SIZE <= ubi->hdrs_min_io_size) {
755 ubi->ro_mode = 1;
758 ubi->leb_size = ubi->peb_size - ubi->leb_start;
760 if (!(ubi->mtd->flags & MTD_WRITEABLE)) {
762 "read-only mode", ubi->mtd->index);
763 ubi->ro_mode = 1;
767 ubi->peb_size, ubi->peb_size >> 10);
768 ubi_msg("logical eraseblock size: %d bytes", ubi->leb_size);
769 ubi_msg("smallest flash I/O unit: %d", ubi->min_io_size);
770 if (ubi->hdrs_min_io_size != ubi->min_io_size)
772 ubi->hdrs_min_io_size);
774 ubi->vid_hdr_offset, ubi->vid_hdr_aloffset);
775 ubi_msg("data offset: %d", ubi->leb_start);
778 * Note, ideally, we have to initialize ubi->bad_peb_count here. But
781 * each physical eraseblock. So, we skip ubi->bad_peb_count
790 * @ubi: UBI device description object
794 * the volume table to the largest possible size. See comments in ubi-header.h
798 static int autoresize(struct ubi_device *ubi, int vol_id)
801 struct ubi_volume *vol = ubi->volumes[vol_id];
809 ubi->vtbl[vol_id].flags &= ~UBI_VTBL_AUTORESIZE_FLG;
811 if (ubi->avail_pebs == 0) {
818 memcpy(&vtbl_rec, &ubi->vtbl[vol_id],
820 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
827 old_reserved_pebs + ubi->avail_pebs);
857 struct ubi_device *ubi;
867 ubi = ubi_devices[i];
868 if (ubi && mtd->index == ubi->mtd->index) {
869 dbg_err("mtd%d is already attached to ubi%d",
905 dbg_err("ubi%d already exists", ubi_num);
910 ubi = kzalloc(sizeof(struct ubi_device), GFP_KERNEL);
911 if (!ubi)
914 ubi->mtd = mtd;
915 ubi->ubi_num = ubi_num;
916 ubi->vid_hdr_offset = vid_hdr_offset;
917 ubi->autoresize_vol_id = -1;
919 mutex_init(&ubi->buf_mutex);
920 mutex_init(&ubi->ckvol_mutex);
921 mutex_init(&ubi->device_mutex);
922 spin_lock_init(&ubi->volumes_lock);
924 ubi_msg("attaching mtd%d to ubi%d", mtd->index, ubi_num);
926 err = io_init(ubi);
931 ubi->peb_buf1 = vmalloc(ubi->peb_size);
932 if (!ubi->peb_buf1)
935 ubi->peb_buf2 = vmalloc(ubi->peb_size);
936 if (!ubi->peb_buf2)
940 mutex_init(&ubi->dbg_buf_mutex);
941 ubi->dbg_peb_buf = vmalloc(ubi->peb_size);
942 if (!ubi->dbg_peb_buf)
946 err = attach_by_scanning(ubi);
952 if (ubi->autoresize_vol_id != -1) {
953 err = autoresize(ubi, ubi->autoresize_vol_id);
958 err = uif_init(ubi, &ref);
962 ubi->bgt_thread = kthread_create(ubi_thread, ubi, ubi->bgt_name);
963 if (IS_ERR(ubi->bgt_thread)) {
964 err = PTR_ERR(ubi->bgt_thread);
965 ubi_err("cannot spawn \"%s\", error %d", ubi->bgt_name,
970 ubi_msg("attached mtd%d to ubi%d", mtd->index, ubi_num);
972 ubi_msg("MTD device size: %llu MiB", ubi->flash_size >> 20);
973 ubi_msg("number of good PEBs: %d", ubi->good_peb_count);
974 ubi_msg("number of bad PEBs: %d", ubi->bad_peb_count);
975 ubi_msg("max. allowed volumes: %d", ubi->vtbl_slots);
979 ubi->vol_count - UBI_INT_VOL_COUNT);
980 ubi_msg("available PEBs: %d", ubi->avail_pebs);
981 ubi_msg("total number of reserved PEBs: %d", ubi->rsvd_pebs);
983 ubi->beb_rsvd_pebs);
984 ubi_msg("max/mean erase counter: %d/%d", ubi->max_ec, ubi->mean_ec);
985 ubi_msg("image sequence number: %d", ubi->image_seq);
989 * checks @ubi->thread_enabled. Otherwise we may fail to wake it up.
991 spin_lock(&ubi->wl_lock);
993 ubi->thread_enabled = 1;
994 wake_up_process(ubi->bgt_thread);
995 spin_unlock(&ubi->wl_lock);
997 ubi_devices[ubi_num] = ubi;
998 ubi_notify_all(ubi, UBI_VOLUME_ADDED, NULL);
1002 uif_close(ubi);
1004 ubi_wl_close(ubi);
1005 free_internal_volumes(ubi);
1006 vfree(ubi->vtbl);
1008 vfree(ubi->peb_buf1);
1009 vfree(ubi->peb_buf2);
1011 vfree(ubi->dbg_peb_buf);
1014 put_device(&ubi->dev);
1016 kfree(ubi);
1035 struct ubi_device *ubi;
1040 ubi = ubi_get_device(ubi_num);
1041 if (!ubi)
1045 put_device(&ubi->dev);
1046 ubi->ref_count -= 1;
1047 if (ubi->ref_count) {
1054 ubi->ubi_name, ubi->ref_count);
1059 ubi_assert(ubi_num == ubi->ubi_num);
1060 ubi_notify_all(ubi, UBI_VOLUME_REMOVED, NULL);
1061 dbg_msg("detaching mtd%d from ubi%d", ubi->mtd->index, ubi_num);
1067 if (ubi->bgt_thread)
1068 kthread_stop(ubi->bgt_thread);
1072 * from freeing the @ubi object.
1074 get_device(&ubi->dev);
1076 uif_close(ubi);
1077 ubi_wl_close(ubi);
1078 free_internal_volumes(ubi);
1079 vfree(ubi->vtbl);
1080 put_mtd_device(ubi->mtd);
1081 vfree(ubi->peb_buf1);
1082 vfree(ubi->peb_buf2);
1084 vfree(ubi->dbg_peb_buf);
1086 ubi_msg("mtd%d is detached from ubi%d", ubi->mtd->index, ubi->ubi_num);
1087 put_device(&ubi->dev);