static int dsi_display_init_dispc(struct dsi_data *dsi);
 static void dsi_display_uninit_dispc(struct dsi_data *dsi);
 
-static int dsi_vc_send_null(struct dsi_data *dsi, int vc);
+static int dsi_vc_send_null(struct dsi_data *dsi, int vc, int channel);
 
-static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi,
+static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi, int vc,
                                       const struct mipi_dsi_msg *msg);
 
 static void dsi_display_disable(struct omap_dss_device *dssdev);
 
        /* start the DDR clock by sending a NULL packet */
        if (dsi->vm_timings.ddr_clk_always_on && enable)
-               dsi_vc_send_null(dsi, vc);
+               dsi_vc_send_null(dsi, vc, dsi->dsidev->channel);
 
        dsi->in_lp_mode = !enable;
 }
 }
 
 static inline void dsi_vc_write_long_header(struct dsi_data *dsi, int vc,
-                                           u8 data_type, u16 len, u8 ecc)
+                                           int channel, u8 data_type, u16 len,
+                                           u8 ecc)
 {
        u32 val;
        u8 data_id;
        dsi_write_reg(dsi, DSI_VC_LONG_PACKET_PAYLOAD(vc), val);
 }
 
-static int dsi_vc_send_long(struct dsi_data *dsi,
+static int dsi_vc_send_long(struct dsi_data *dsi, int vc,
                            const struct mipi_dsi_msg *msg)
 {
        /*u32 val; */
 
        dsi_vc_config_source(dsi, msg->channel, DSI_VC_SOURCE_L4);
 
-       dsi_vc_write_long_header(dsi, msg->channel, msg->type, msg->tx_len, 0);
+       dsi_vc_write_long_header(dsi, vc, msg->channel, msg->type, msg->tx_len, 0);
 
        p = msg->tx_buf;
        for (i = 0; i < msg->tx_len >> 2; i++) {
        return r;
 }
 
-static int dsi_vc_send_short(struct dsi_data *dsi,
+static int dsi_vc_send_short(struct dsi_data *dsi, int vc,
                             const struct mipi_dsi_msg *msg)
 {
        struct mipi_dsi_packet pkt;
        return 0;
 }
 
-static int dsi_vc_send_null(struct dsi_data *dsi, int vc)
+static int dsi_vc_send_null(struct dsi_data *dsi, int vc, int channel)
 {
        const struct mipi_dsi_msg msg = {
                .channel = vc,
                .type = MIPI_DSI_NULL_PACKET,
        };
 
-       return dsi_vc_send_long(dsi, &msg);
+       return dsi_vc_send_long(dsi, vc, &msg);
 }
 
-static int dsi_vc_write_common(struct omap_dss_device *dssdev,
+static int dsi_vc_write_common(struct omap_dss_device *dssdev, int vc,
                               const struct mipi_dsi_msg *msg)
 {
        struct dsi_data *dsi = to_dsi_data(dssdev);
        int r;
 
        if (mipi_dsi_packet_format_is_short(msg->type))
-               r = dsi_vc_send_short(dsi, msg);
+               r = dsi_vc_send_short(dsi, vc, msg);
        else
-               r = dsi_vc_send_long(dsi, msg);
+               r = dsi_vc_send_long(dsi, vc, msg);
 
        if (r < 0)
                return r;
        return r;
 }
 
-static int dsi_vc_dcs_read(struct omap_dss_device *dssdev,
+static int dsi_vc_dcs_read(struct omap_dss_device *dssdev, int vc,
                           const struct mipi_dsi_msg *msg)
 {
        struct dsi_data *dsi = to_dsi_data(dssdev);
        if (dsi->debug_read)
                DSSDBG("%s(ch %d, cmd %x)\n", __func__, channel, cmd);
 
-       r = dsi_vc_send_short(dsi, msg);
+       r = dsi_vc_send_short(dsi, vc, msg);
        if (r)
                goto err;
 
        return r;
 }
 
-static int dsi_vc_generic_read(struct omap_dss_device *dssdev,
+static int dsi_vc_generic_read(struct omap_dss_device *dssdev, int vc,
                               const struct mipi_dsi_msg *msg)
 {
        struct dsi_data *dsi = to_dsi_data(dssdev);
        int r;
 
-       r = dsi_vc_send_short(dsi, msg);
+       r = dsi_vc_send_short(dsi, vc, msg);
        if (r)
                goto err;
 
 
                word_count = DIV_ROUND_UP(dsi->vm.hactive * bpp, 8);
 
-               dsi_vc_write_long_header(dsi, vc, data_type,
+               dsi_vc_write_long_header(dsi, vc, dsi->dsidev->channel, data_type,
                                word_count, 0);
 
                dsi_vc_enable(dsi, vc, true);
        l = FLD_VAL(total_len, 23, 0); /* TE_SIZE */
        dsi_write_reg(dsi, DSI_VC_TE(vc), l);
 
-       dsi_vc_write_long_header(dsi, vc, MIPI_DSI_DCS_LONG_WRITE,
+       dsi_vc_write_long_header(dsi, vc, dsi->dsidev->channel, MIPI_DSI_DCS_LONG_WRITE,
                packet_len, 0);
 
        if (dsi->te_enabled)
        return 0;
 }
 
-static int _dsi_send_nop(struct dsi_data *dsi, int channel)
+static int _dsi_send_nop(struct dsi_data *dsi, int vc, int channel)
 {
        const u8 payload[] = { MIPI_DCS_NOP };
        const struct mipi_dsi_msg msg = {
 
        WARN_ON(!dsi_bus_is_locked(dsi));
 
-       return _omap_dsi_host_transfer(dsi, &msg);
+       return _omap_dsi_host_transfer(dsi, vc, &msg);
 }
 
 static int dsi_update_channel(struct omap_dss_device *dssdev, int vc)
         * updates stop working. This is probably related to DSI spec stating
         * that the DSI host should transition to LP at least once per frame.
         */
-       r = _dsi_send_nop(dsi, vc);
+       r = _dsi_send_nop(dsi, vc, dsi->dsidev->channel);
        if (r < 0) {
                DSSWARN("failed to send nop between frames: %d\n", r);
                goto err;
        }
 }
 
-static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi,
+static ssize_t _omap_dsi_host_transfer(struct dsi_data *dsi, int vc,
                                       const struct mipi_dsi_msg *msg)
 {
        struct omap_dss_device *dssdev = &dsi->output;
        case MIPI_DSI_DCS_LONG_WRITE:
        case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
        case MIPI_DSI_NULL_PACKET:
-               r = dsi_vc_write_common(dssdev, msg);
+               r = dsi_vc_write_common(dssdev, vc, msg);
                break;
        case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
        case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
        case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
-               r = dsi_vc_generic_read(dssdev, msg);
+               r = dsi_vc_generic_read(dssdev, vc, msg);
                break;
        case MIPI_DSI_DCS_READ:
-               r = dsi_vc_dcs_read(dssdev, msg);
+               r = dsi_vc_dcs_read(dssdev, vc, msg);
                break;
        default:
                r = -EINVAL;
 {
        struct dsi_data *dsi = host_to_omap(host);
        int r;
+       int vc = VC_DEFAULT;
 
        dsi_bus_lock(dsi);
 
        if (dsi->video_enabled) {
                dsi_set_ulps_auto(dsi, false);
-               r = _omap_dsi_host_transfer(dsi, msg);
+               r = _omap_dsi_host_transfer(dsi, vc, msg);
                dsi_set_ulps_auto(dsi, true);
        } else {
                r = -EIO;