cdn_dp_set_firmware_active(dp, false);
        cdn_dp_clk_disable(dp);
        dp->active = false;
-       dp->link.rate = 0;
-       dp->link.num_lanes = 0;
+       dp->max_lanes = 0;
+       dp->max_rate = 0;
        if (!dp->connected) {
                kfree(dp->edid);
                dp->edid = NULL;
        struct cdn_dp_port *port = cdn_dp_connected_port(dp);
        u8 sink_lanes = drm_dp_max_lane_count(dp->dpcd);
 
-       if (!port || !dp->link.rate || !dp->link.num_lanes)
+       if (!port || !dp->max_rate || !dp->max_lanes)
                return false;
 
        if (cdn_dp_dpcd_read(dp, DP_LANE0_1_STATUS, link_status,
 
        /* Enabled and connected with a sink, re-train if requested */
        } else if (!cdn_dp_check_link_status(dp)) {
-               unsigned int rate = dp->link.rate;
-               unsigned int lanes = dp->link.num_lanes;
+               unsigned int rate = dp->max_rate;
+               unsigned int lanes = dp->max_lanes;
                struct drm_display_mode *mode = &dp->mode;
 
                DRM_DEV_INFO(dp->dev, "Connected with sink. Re-train link\n");
 
                /* If training result is changed, update the video config */
                if (mode->clock &&
-                   (rate != dp->link.rate || lanes != dp->link.num_lanes)) {
+                   (rate != dp->max_rate || lanes != dp->max_lanes)) {
                        ret = cdn_dp_config_video(dp);
                        if (ret) {
                                dp->connected = false;
 
        if (ret)
                goto err_get_training_status;
 
-       dp->link.rate = drm_dp_bw_code_to_link_rate(status[0]);
-       dp->link.num_lanes = status[1];
+       dp->max_rate = drm_dp_bw_code_to_link_rate(status[0]);
+       dp->max_lanes = status[1];
 
 err_get_training_status:
        if (ret)
                return ret;
        }
 
-       DRM_DEV_DEBUG_KMS(dp->dev, "rate:0x%x, lanes:%d\n", dp->link.rate,
-                         dp->link.num_lanes);
+       DRM_DEV_DEBUG_KMS(dp->dev, "rate:0x%x, lanes:%d\n", dp->max_rate,
+                         dp->max_lanes);
        return ret;
 }
 
        bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ?
                      (video->color_depth * 2) : (video->color_depth * 3);
 
-       link_rate = dp->link.rate / 1000;
+       link_rate = dp->max_rate / 1000;
 
        ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, VIF_BYPASS_INTERLACE);
        if (ret)
        do {
                tu_size_reg += 2;
                symbol = tu_size_reg * mode->clock * bit_per_pix;
-               do_div(symbol, dp->link.num_lanes * link_rate * 8);
+               do_div(symbol, dp->max_lanes * link_rate * 8);
                rem = do_div(symbol, 1000);
                if (tu_size_reg > 64) {
                        ret = -EINVAL;
                        DRM_DEV_ERROR(dp->dev,
                                      "tu error, clk:%d, lanes:%d, rate:%d\n",
-                                     mode->clock, dp->link.num_lanes,
-                                     link_rate);
+                                     mode->clock, dp->max_lanes, link_rate);
                        goto err_config_video;
                }
        } while ((symbol <= 1) || (tu_size_reg - symbol < 4) ||
 
        /* set the FIFO Buffer size */
        val = div_u64(mode->clock * (symbol + 1), 1000) + link_rate;
-       val /= (dp->link.num_lanes * link_rate);
+       val /= (dp->max_lanes * link_rate);
        val = div_u64(8 * (symbol + 1), bit_per_pix) - val;
        val += 2;
        ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val);
        u32 val;
 
        if (audio->channels == 2) {
-               if (dp->link.num_lanes == 1)
+               if (dp->max_lanes == 1)
                        sub_pckt_num = 2;
                else
                        sub_pckt_num = 4;