/** * fw_get_filesystem_firmware - load firmware into an allocated buffer. * @dev: An instance of a driver. * * Return: Size of total read, negative value when error. */ static int fw_get_filesystem_firmware(struct udevice *dev) { loff_t actread; char *storage_interface, *dev_part, *ubi_mtdpart, *ubi_volume; int ret; storage_interface = env_get("storage_interface"); dev_part = env_get("fw_dev_part"); ubi_mtdpart = env_get("fw_ubi_mtdpart"); ubi_volume = env_get("fw_ubi_volume"); if (storage_interface && dev_part) { ret = fs_set_blk_dev(storage_interface, dev_part, FS_TYPE_ANY); } else if (storage_interface && ubi_mtdpart && ubi_volume) { ret = mount_ubifs(ubi_mtdpart, ubi_volume); if (ret) return ret; if (!strcmp("ubi", storage_interface)) ret = fs_set_blk_dev(storage_interface, NULL, FS_TYPE_UBIFS); else ret = -ENODEV; } else { ret = select_fs_dev(dev->platdata); } if (ret) goto out; struct firmware *firmwarep = dev_get_priv(dev); if (!firmwarep) return -ENOMEM; ret = fs_read(firmwarep->name, (ulong)map_to_sysmem(firmwarep->data), firmwarep->offset, firmwarep->size, &actread); if (ret) { debug("Error: %d Failed to read %s from flash %lld != %zu.\n", ret, firmwarep->name, actread, firmwarep->size); } else { ret = actread; } out: #ifdef CONFIG_CMD_UBIFS umount_ubifs(); #endif return ret; }
static int select_fs_dev(struct device_platdata *plat) { int ret; if (plat->phandlepart.phandle) { ofnode node; node = ofnode_get_by_phandle(plat->phandlepart.phandle); struct udevice *dev; ret = device_get_global_by_ofnode(node, &dev); if (!ret) { struct blk_desc *desc = blk_get_by_device(dev); if (desc) { ret = fs_set_blk_dev_with_part(desc, plat->phandlepart.partition); } else { debug("%s: No device found\n", __func__); return -ENODEV; } } } else if (plat->mtdpart && plat->ubivol) { ret = mount_ubifs(plat->mtdpart, plat->ubivol); if (ret) return ret; ret = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS); } else { debug("Error: unsupported storage device.\n"); return -ENODEV; } if (ret) debug("Error: could not access storage.\n"); return ret; }
static int ubifs_fill_super(struct super_block *sb, void *data, int silent) { struct ubi_volume_desc *ubi = sb->s_fs_info; struct ubifs_info *c; struct inode *root; int err; c = kzalloc(sizeof(struct ubifs_info), GFP_KERNEL); if (!c) return -ENOMEM; spin_lock_init(&c->cnt_lock); spin_lock_init(&c->cs_lock); spin_lock_init(&c->buds_lock); spin_lock_init(&c->space_lock); spin_lock_init(&c->orphan_lock); init_rwsem(&c->commit_sem); mutex_init(&c->lp_mutex); mutex_init(&c->tnc_mutex); mutex_init(&c->log_mutex); mutex_init(&c->mst_mutex); mutex_init(&c->umount_mutex); init_waitqueue_head(&c->cmt_wq); c->buds = RB_ROOT; c->old_idx = RB_ROOT; c->size_tree = RB_ROOT; c->orph_tree = RB_ROOT; INIT_LIST_HEAD(&c->infos_list); INIT_LIST_HEAD(&c->idx_gc); INIT_LIST_HEAD(&c->replay_list); INIT_LIST_HEAD(&c->replay_buds); INIT_LIST_HEAD(&c->uncat_list); INIT_LIST_HEAD(&c->empty_list); INIT_LIST_HEAD(&c->freeable_list); INIT_LIST_HEAD(&c->frdi_idx_list); INIT_LIST_HEAD(&c->unclean_leb_list); INIT_LIST_HEAD(&c->old_buds); INIT_LIST_HEAD(&c->orph_list); INIT_LIST_HEAD(&c->orph_new); c->highest_inum = UBIFS_FIRST_INO; c->lhead_lnum = c->ltail_lnum = UBIFS_LOG_LNUM; ubi_get_volume_info(ubi, &c->vi); ubi_get_device_info(c->vi.ubi_num, &c->di); /* Re-open the UBI device in read-write mode */ c->ubi = ubi_open_volume(c->vi.ubi_num, c->vi.vol_id, UBI_READONLY); if (IS_ERR(c->ubi)) { err = PTR_ERR(c->ubi); goto out_free; } c->vfs_sb = sb; sb->s_fs_info = c; sb->s_magic = UBIFS_SUPER_MAGIC; sb->s_blocksize = UBIFS_BLOCK_SIZE; sb->s_blocksize_bits = UBIFS_BLOCK_SHIFT; sb->s_dev = c->vi.cdev; sb->s_maxbytes = c->max_inode_sz = key_max_inode_size(c); if (c->max_inode_sz > MAX_LFS_FILESIZE) sb->s_maxbytes = c->max_inode_sz = MAX_LFS_FILESIZE; if (c->rw_incompat) { ubifs_err("the file-system is not R/W-compatible"); ubifs_msg("on-flash format version is w%d/r%d, but software " "only supports up to version w%d/r%d", c->fmt_version, c->ro_compat_version, UBIFS_FORMAT_VERSION, UBIFS_RO_COMPAT_VERSION); return -EROFS; } mutex_lock(&c->umount_mutex); err = mount_ubifs(c); if (err) { ubifs_assert(err < 0); goto out_unlock; } /* Read the root inode */ root = ubifs_iget(sb, UBIFS_ROOT_INO); if (IS_ERR(root)) { err = PTR_ERR(root); goto out_umount; } sb->s_root = NULL; mutex_unlock(&c->umount_mutex); return 0; out_umount: ubifs_umount(c); out_unlock: mutex_unlock(&c->umount_mutex); ubi_close_volume(c->ubi); out_free: kfree(c); return err; }