EXPORT_SYMBOL(drm_dp_find_vcpi_slots);
 
 static int drm_dp_init_vcpi(struct drm_dp_mst_topology_mgr *mgr,
-                           struct drm_dp_vcpi *vcpi, int pbn)
+                           struct drm_dp_vcpi *vcpi, int pbn, int slots)
 {
-       int num_slots;
        int ret;
 
-       num_slots = DIV_ROUND_UP(pbn, mgr->pbn_div);
-
        /* max. time slots - one slot for MTP header */
-       if (num_slots > 63)
+       if (slots > 63)
                return -ENOSPC;
 
        vcpi->pbn = pbn;
-       vcpi->aligned_pbn = num_slots * mgr->pbn_div;
-       vcpi->num_slots = num_slots;
+       vcpi->aligned_pbn = slots * mgr->pbn_div;
+       vcpi->num_slots = slots;
 
        ret = drm_dp_mst_assign_payload_id(mgr, vcpi);
        if (ret < 0)
  * @pbn: payload bandwidth number to request
  * @slots: returned number of slots for this PBN.
  */
-bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, int pbn, int *slots)
+bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr,
+                             struct drm_dp_mst_port *port, int pbn, int slots)
 {
        int ret;
 
        if (!port)
                return false;
 
+       if (slots < 0)
+               return false;
+
        if (port->vcpi.vcpi > 0) {
                DRM_DEBUG_KMS("payload: vcpi %d already allocated for pbn %d - requested pbn %d\n", port->vcpi.vcpi, port->vcpi.pbn, pbn);
                if (pbn == port->vcpi.pbn) {
-                       *slots = port->vcpi.num_slots;
                        drm_dp_put_port(port);
                        return true;
                }
        }
 
-       ret = drm_dp_init_vcpi(mgr, &port->vcpi, pbn);
+       ret = drm_dp_init_vcpi(mgr, &port->vcpi, pbn, slots);
        if (ret) {
                DRM_DEBUG_KMS("failed to init vcpi slots=%d max=63 ret=%d\n",
                                DIV_ROUND_UP(pbn, mgr->pbn_div), ret);
        }
        DRM_DEBUG_KMS("initing vcpi for pbn=%d slots=%d\n",
                        pbn, port->vcpi.num_slots);
-       *slots = port->vcpi.num_slots;
 
        drm_dp_put_port(port);
        return true;
 
                to_intel_connector(conn_state->connector);
        int ret;
        uint32_t temp;
-       int slots;
 
        /* MST encoders are bound to a crtc, not to a connector,
         * force the mapping here for get_hw_state.
 
        ret = drm_dp_mst_allocate_vcpi(&intel_dp->mst_mgr,
                                       connector->port,
-                                      pipe_config->pbn, &slots);
+                                      pipe_config->pbn,
+                                      pipe_config->dp_m_n.tu);
        if (ret == false) {
                DRM_ERROR("failed to allocate vcpi\n");
                return;
 
                DRM_DEBUG_KMS("dig encoder is %d %d %d\n", dig_enc->dig_encoder,
                              dig_enc->linkb, radeon_crtc->crtc_id);
 
+               slots = drm_dp_find_vcpi_slots(&radeon_connector->mst_port->mst_mgr,
+                                              mst_enc->pbn);
                ret = drm_dp_mst_allocate_vcpi(&radeon_connector->mst_port->mst_mgr,
                                               radeon_connector->port,
-                                              mst_enc->pbn, &slots);
+                                              mst_enc->pbn, slots);
                ret = drm_dp_update_payload_part1(&radeon_connector->mst_port->mst_mgr);
 
                radeon_dp_mst_set_be_cntl(primary, mst_enc,
 
 int drm_dp_calc_pbn_mode(int clock, int bpp);
 
 
-bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, int pbn, int *slots);
+bool drm_dp_mst_allocate_vcpi(struct drm_dp_mst_topology_mgr *mgr,
+                             struct drm_dp_mst_port *port, int pbn, int slots);
 
 int drm_dp_mst_get_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port);