media_entity_find_link(struct media_pad *source,
                               struct media_pad *sink);
 
-       media_entity_remote_source(struct media_pad *pad);
+       media_entity_remote_pad(struct media_pad *pad);
 
 Refer to the kerneldoc documentation for more information.
 
 
 EXPORT_SYMBOL_GPL(media_entity_find_link);
 
 /**
- * media_entity_remote_source - Find the source pad at the remote end of a link
- * @pad: Sink pad at the local end of the link
+ * media_entity_remote_pad - Find the pad at the remote end of a link
+ * @pad: Pad at the local end of the link
  *
- * Search for a remote source pad connected to the given sink pad by iterating
- * over all links originating or terminating at that pad until an enabled link
- * is found.
+ * Search for a remote pad connected to the given pad by iterating over all
+ * links originating or terminating at that pad until an enabled link is found.
  *
  * Return a pointer to the pad at the remote end of the first found enabled
  * link, or NULL if no enabled link has been found.
  */
-struct media_pad *media_entity_remote_source(struct media_pad *pad)
+struct media_pad *media_entity_remote_pad(struct media_pad *pad)
 {
        unsigned int i;
 
        return NULL;
 
 }
-EXPORT_SYMBOL_GPL(media_entity_remote_source);
+EXPORT_SYMBOL_GPL(media_entity_remote_pad);
 
        struct media_pad *pad = &me->pads[0];
 
        while (!(pad->flags & MEDIA_PAD_FL_SOURCE)) {
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (!pad)
                        break;
                me = pad->entity;
                                        return ret;
                        }
 
-                       pad = media_entity_remote_source(&me->pads[sfmt.pad]);
+                       pad = media_entity_remote_pad(&me->pads[sfmt.pad]);
                        if (!pad)
                                return -EINVAL;
                        me = pad->entity;
 
                        if (p->flags & MEDIA_PAD_FL_SINK) {
                                sink_pad = p;
-                               src_pad = media_entity_remote_source(sink_pad);
+                               src_pad = media_entity_remote_pad(sink_pad);
                                if (src_pad)
                                        break;
                        }
 
 
        while (pad->flags & MEDIA_PAD_FL_SINK) {
                /* source pad */
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL ||
                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                                return -EPIPE;
                }
                /* Retrieve format at the source pad */
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL ||
                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
 
                        struct media_pad *spad = &me->pads[i];
                        if (!(spad->flags & MEDIA_PAD_FL_SINK))
                                continue;
-                       pad = media_entity_remote_source(spad);
+                       pad = media_entity_remote_pad(spad);
                        if (pad)
                                break;
                }
 
                if (!(pad->flags & MEDIA_PAD_FL_SINK))
                        break;
 
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL ||
                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                if (!(pad->flags & MEDIA_PAD_FL_SINK))
                        break;
 
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL ||
                    media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
        pipe = to_isp_pipeline(me);
        if (pipe->stream_state == ISP_PIPELINE_STREAM_STOPPED)
                return 0;
-       pad = media_entity_remote_source(&pipe->output->pad);
+       pad = media_entity_remote_pad(&pipe->output->pad);
        return pad->entity == me;
 }
 
 
        u32 syn_mode;
        u32 ccdc_pattern;
 
-       pad = media_entity_remote_source(&ccdc->pads[CCDC_PAD_SINK]);
+       pad = media_entity_remote_pad(&ccdc->pads[CCDC_PAD_SINK]);
        sensor = media_entity_to_v4l2_subdev(pad->entity);
        if (ccdc->input == CCDC_INPUT_PARALLEL)
                pdata = &((struct isp_v4l2_subdevs_group *)sensor->host_priv)
 
 
        ccp2_pwr_cfg(ccp2);
 
-       pad = media_entity_remote_source(&ccp2->pads[CCP2_PAD_SINK]);
+       pad = media_entity_remote_pad(&ccp2->pads[CCP2_PAD_SINK]);
        sensor = media_entity_to_v4l2_subdev(pad->entity);
        pdata = sensor->host_priv;
 
 
        if (csi2->contexts[0].enabled || csi2->ctrl.if_enable)
                return -EBUSY;
 
-       pad = media_entity_remote_source(&csi2->pads[CSI2_PAD_SINK]);
+       pad = media_entity_remote_pad(&csi2->pads[CSI2_PAD_SINK]);
        sensor = media_entity_to_v4l2_subdev(pad->entity);
        pdata = sensor->host_priv;
 
 
 {
        struct media_pad *remote;
 
-       remote = media_entity_remote_source(&video->pad);
+       remote = media_entity_remote_pad(&video->pad);
 
        if (remote == NULL ||
            media_entity_type(remote->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                 * entity can be found, and stop checking the pipeline if the
                 * source entity isn't a subdev.
                 */
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL)
                        return -EPIPE;
 
                        continue;
 
                /* ISP entities have always sink pad == 0. Find source. */
-               source_pad = media_entity_remote_source(&ents[i]->pads[0]);
+               source_pad = media_entity_remote_pad(&ents[i]->pads[0]);
                if (source_pad == NULL)
                        continue;
 
 
        int ret;
 
        /* Retrieve format at the sensor subdev source pad */
-       pad = media_entity_remote_source(&camif->pads[0]);
+       pad = media_entity_remote_pad(&camif->pads[0]);
        if (!pad || media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
                return -EPIPE;
 
 
        struct vpfe_device *vpfe_dev = video->vpfe_dev;
        struct media_pad *remote;
 
-       remote = media_entity_remote_source(&vpfe_dev->vpfe_isif.pads[0]);
+       remote = media_entity_remote_pad(&vpfe_dev->vpfe_isif.pads[0]);
        if (remote == NULL) {
                pr_err("Invalid media connection to isif/ccdc\n");
                return NULL;
        struct media_pad *remote;
        int i;
 
-       remote = media_entity_remote_source(&vpfe_dev->vpfe_isif.pads[0]);
+       remote = media_entity_remote_pad(&vpfe_dev->vpfe_isif.pads[0]);
        if (remote == NULL) {
                pr_err("Invalid media connection to isif/ccdc\n");
                return -EINVAL;
 static struct v4l2_subdev *
 vpfe_video_remote_subdev(struct vpfe_video_device *video, u32 *pad)
 {
-       struct media_pad *remote = media_entity_remote_source(&video->pad);
+       struct media_pad *remote = media_entity_remote_pad(&video->pad);
 
        if (remote == NULL || remote->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
                return NULL;
                return -EINVAL;
 
        fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
-       remote = media_entity_remote_source(&video->pad);
+       remote = media_entity_remote_pad(&video->pad);
        fmt.pad = remote->index;
 
        ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &fmt);
                        return -EPIPE;
 
                /* Retrieve the source format */
-               pad = media_entity_remote_source(pad);
+               pad = media_entity_remote_pad(pad);
                if (pad == NULL ||
                        pad->entity->type != MEDIA_ENT_T_V4L2_SUBDEV)
                        break;
                return -EINVAL;
        }
        /* get the remote pad */
-       remote = media_entity_remote_source(&video->pad);
+       remote = media_entity_remote_pad(&video->pad);
        if (remote == NULL) {
                v4l2_err(&vpfe_dev->v4l2_dev,
                         "invalid remote pad for video node\n");
 
 int media_entity_setup_link(struct media_link *link, u32 flags);
 struct media_link *media_entity_find_link(struct media_pad *source,
                struct media_pad *sink);
-struct media_pad *media_entity_remote_source(struct media_pad *pad);
+struct media_pad *media_entity_remote_pad(struct media_pad *pad);
 
 struct media_entity *media_entity_get(struct media_entity *entity);
 void media_entity_put(struct media_entity *entity);