int i;
 
        /* Warn if we apparently re-register an entity */
-       WARN_ON(entity->parent != NULL);
-       entity->parent = mdev;
+       WARN_ON(entity->graph_obj.mdev != NULL);
+       entity->graph_obj.mdev = mdev;
 
        spin_lock(&mdev->lock);
        /* Initialize media_gobj embedded at the entity */
 void media_device_unregister_entity(struct media_entity *entity)
 {
        int i;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
 
        if (mdev == NULL)
                return;
        media_gobj_remove(&entity->graph_obj);
        list_del(&entity->list);
        spin_unlock(&mdev->lock);
-       entity->parent = NULL;
+       entity->graph_obj.mdev = NULL;
 }
 EXPORT_SYMBOL_GPL(media_device_unregister_entity);
 
 
 __must_check int media_entity_pipeline_start(struct media_entity *entity,
                                             struct media_pipeline *pipe)
 {
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        struct media_entity_graph graph;
        struct media_entity *entity_err = entity;
        int ret;
 
                        ret = entity->ops->link_validate(link);
                        if (ret < 0 && ret != -ENOIOCTLCMD) {
-                               dev_dbg(entity->parent->dev,
+                               dev_dbg(entity->graph_obj.mdev->dev,
                                        "link validation failed for \"%s\":%u -> \"%s\":%u, error %d\n",
                                        link->source->entity->name,
                                        link->source->index,
 
                if (!bitmap_full(active, entity->num_pads)) {
                        ret = -EPIPE;
-                       dev_dbg(entity->parent->dev,
+                       dev_dbg(entity->graph_obj.mdev->dev,
                                "\"%s\":%u must be connected by an enabled link\n",
                                entity->name,
                                (unsigned)find_first_zero_bit(
  */
 void media_entity_pipeline_stop(struct media_entity *entity)
 {
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        struct media_entity_graph graph;
 
        mutex_lock(&mdev->graph_mutex);
        if (entity == NULL)
                return NULL;
 
-       if (entity->parent->dev &&
-           !try_module_get(entity->parent->dev->driver->owner))
+       if (entity->graph_obj.mdev->dev &&
+           !try_module_get(entity->graph_obj.mdev->dev->driver->owner))
                return NULL;
 
        return entity;
        if (entity == NULL)
                return;
 
-       if (entity->parent->dev)
-               module_put(entity->parent->dev->driver->owner);
+       if (entity->graph_obj.mdev->dev)
+               module_put(entity->graph_obj.mdev->dev->driver->owner);
 }
 EXPORT_SYMBOL_GPL(media_entity_put);
 
        link->flags = flags;
 
        /* Initialize graph object embedded at the new link */
-       media_gobj_init(source->parent, MEDIA_GRAPH_LINK, &link->graph_obj);
+       media_gobj_init(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
+                       &link->graph_obj);
 
        /* Create the backlink. Backlinks are used to help graph traversal and
         * are not reported to userspace.
        backlink->flags = flags;
 
        /* Initialize graph object embedded at the new link */
-       media_gobj_init(sink->parent, MEDIA_GRAPH_LINK, &backlink->graph_obj);
+       media_gobj_init(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
+                       &backlink->graph_obj);
 
        link->reverse = backlink;
        backlink->reverse = link;
 void media_entity_remove_links(struct media_entity *entity)
 {
        /* Do nothing if the entity is not registered. */
-       if (entity->parent == NULL)
+       if (entity->graph_obj.mdev == NULL)
                return;
 
-       mutex_lock(&entity->parent->graph_mutex);
+       mutex_lock(&entity->graph_obj.mdev->graph_mutex);
        __media_entity_remove_links(entity);
-       mutex_unlock(&entity->parent->graph_mutex);
+       mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
 }
 EXPORT_SYMBOL_GPL(media_entity_remove_links);
 
            (source->stream_count || sink->stream_count))
                return -EBUSY;
 
-       mdev = source->parent;
+       mdev = source->graph_obj.mdev;
 
        if (mdev->link_notify) {
                ret = mdev->link_notify(link, flags,
 {
        int ret;
 
-       mutex_lock(&link->source->entity->parent->graph_mutex);
+       mutex_lock(&link->source->entity->graph_obj.mdev->graph_mutex);
        ret = __media_entity_setup_link(link, flags);
-       mutex_unlock(&link->source->entity->parent->graph_mutex);
+       mutex_unlock(&link->source->entity->graph_obj.mdev->graph_mutex);
 
        return ret;
 }
 
                goto rel_fh;
 
        if (v4l2_fh_is_singular_file(file)) {
-               mutex_lock(&me->parent->graph_mutex);
+               mutex_lock(&me->graph_obj.mdev->graph_mutex);
 
                ret = fimc_pipeline_call(ve, open, me, true);
 
                if (ret == 0)
                        me->use_count++;
 
-               mutex_unlock(&me->parent->graph_mutex);
+               mutex_unlock(&me->graph_obj.mdev->graph_mutex);
        }
        if (!ret)
                goto unlock;
        struct fimc_isp *isp = video_drvdata(file);
        struct fimc_is_video *ivc = &isp->video_capture;
        struct media_entity *entity = &ivc->ve.vdev.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
 
        mutex_lock(&isp->video_lock);
 
 
            atomic_read(&fimc->out_path) != FIMC_IO_DMA)
                goto unlock;
 
-       mutex_lock(&me->parent->graph_mutex);
+       mutex_lock(&me->graph_obj.mdev->graph_mutex);
 
        ret = fimc_pipeline_call(&fimc->ve, open, me, true);
 
        if (ret == 0)
                me->use_count++;
 
-       mutex_unlock(&me->parent->graph_mutex);
+       mutex_unlock(&me->graph_obj.mdev->graph_mutex);
 
        if (!ret) {
                fimc_lite_clear_event_counters(fimc);
                fimc_pipeline_call(&fimc->ve, close);
                clear_bit(ST_FLITE_IN_USE, &fimc->state);
 
-               mutex_lock(&entity->parent->graph_mutex);
+               mutex_lock(&entity->graph_obj.mdev->graph_mutex);
                entity->use_count--;
-               mutex_unlock(&entity->parent->graph_mutex);
+               mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
        }
 
        _vb2_fop_release(file, NULL);
 
        return ret;
 }
 
-/* Locking: called with entity->parent->graph_mutex mutex held. */
+/* Locking: called with entity->graph_obj.mdev->graph_mutex mutex held. */
 static int __fimc_md_modify_pipelines(struct media_entity *entity, bool enable)
 {
        struct media_entity *entity_err = entity;
 
 
 static inline struct fimc_md *entity_to_fimc_mdev(struct media_entity *me)
 {
-       return me->parent == NULL ? NULL :
-               container_of(me->parent, struct fimc_md, media_dev);
+       return me->graph_obj.mdev == NULL ? NULL :
+               container_of(me->graph_obj.mdev, struct fimc_md, media_dev);
 }
 
 static inline struct fimc_md *notifier_to_fimc_md(struct v4l2_async_notifier *n)
 
 static inline void fimc_md_graph_lock(struct exynos_video_entity *ve)
 {
-       mutex_lock(&ve->vdev.entity.parent->graph_mutex);
+       mutex_lock(&ve->vdev.entity.graph_obj.mdev->graph_mutex);
 }
 
 static inline void fimc_md_graph_unlock(struct exynos_video_entity *ve)
 {
-       mutex_unlock(&ve->vdev.entity.parent->graph_mutex);
+       mutex_unlock(&ve->vdev.entity.graph_obj.mdev->graph_mutex);
 }
 
 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on);
 
        int change = use ? 1 : -1;
        int ret;
 
-       mutex_lock(&entity->parent->graph_mutex);
+       mutex_lock(&entity->graph_obj.mdev->graph_mutex);
 
        /* Apply use count to node. */
        entity->use_count += change;
        if (ret < 0)
                entity->use_count -= change;
 
-       mutex_unlock(&entity->parent->graph_mutex);
+       mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
 
        return ret;
 }
 
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        struct isp_video *far_end = NULL;
 
        mutex_lock(&mdev->graph_mutex);
 
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        unsigned int i;
        int ret;
 
 
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &start->video.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        unsigned int num_inputs = 0;
        unsigned int num_outputs = 0;
 
 
 static void vpfe_prepare_pipeline(struct vpfe_video_device *video)
 {
        struct media_entity *entity = &video->video_dev.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        struct vpfe_pipeline *pipe = &video->pipe;
        struct vpfe_video_device *far_end = NULL;
        struct media_entity_graph graph;
        else
                entity = &pipe->inputs[0]->video_dev.entity;
 
-       mdev = entity->parent;
+       mdev = entity->graph_obj.mdev;
        mutex_lock(&mdev->graph_mutex);
        media_entity_graph_walk_start(&graph, entity);
        while ((entity = media_entity_graph_walk_next(&graph))) {
        else
                entity = &pipe->inputs[0]->video_dev.entity;
 
-       mdev = entity->parent;
+       mdev = entity->graph_obj.mdev;
        mutex_lock(&mdev->graph_mutex);
        media_entity_graph_walk_start(&graph, entity);
 
 
        int change = use ? 1 : -1;
        int ret;
 
-       mutex_lock(&entity->parent->graph_mutex);
+       mutex_lock(&entity->graph_obj.mdev->graph_mutex);
 
        /* Apply use count to node. */
        entity->use_count += change;
        if (ret < 0)
                entity->use_count -= change;
 
-       mutex_unlock(&entity->parent->graph_mutex);
+       mutex_unlock(&entity->graph_obj.mdev->graph_mutex);
 
        return ret;
 }
 
 {
        struct media_entity_graph graph;
        struct media_entity *entity = &video->video.entity;
-       struct media_device *mdev = entity->parent;
+       struct media_device *mdev = entity->graph_obj.mdev;
        struct iss_video *far_end = NULL;
 
        mutex_lock(&mdev->graph_mutex);