1 // SPDX-License-Identifier: MIT 2 /* 3 * Copyright © 2023 Intel Corporation 4 */ 5 6 #include "i915_drv.h" 7 8 #include "intel_atomic.h" 9 #include "intel_display_types.h" 10 #include "intel_fdi.h" 11 #include "intel_link_bw.h" 12 13 /** 14 * intel_link_bw_init_limits - initialize BW limits 15 * @i915: device instance 16 * @limits: link BW limits 17 * 18 * Initialize @limits. 19 */ 20 void intel_link_bw_init_limits(struct drm_i915_private *i915, struct intel_link_bw_limits *limits) 21 { 22 enum pipe pipe; 23 24 limits->bpp_limit_reached_pipes = 0; 25 for_each_pipe(i915, pipe) 26 limits->max_bpp_x16[pipe] = INT_MAX; 27 } 28 29 /** 30 * intel_link_bw_reduce_bpp - reduce maximum link bpp for a selected pipe 31 * @state: atomic state 32 * @limits: link BW limits 33 * @pipe_mask: mask of pipes to select from 34 * @reason: explanation of why bpp reduction is needed 35 * 36 * Select the pipe from @pipe_mask with the biggest link bpp value and set the 37 * maximum of link bpp in @limits below this value. Modeset the selected pipe, 38 * so that its state will get recomputed. 39 * 40 * This function can be called to resolve a link's BW overallocation by reducing 41 * the link bpp of one pipe on the link and hence reducing the total link BW. 42 * 43 * Returns 44 * - 0 in case of success 45 * - %-ENOSPC if no pipe can further reduce its link bpp 46 * - Other negative error, if modesetting the selected pipe failed 47 */ 48 int intel_link_bw_reduce_bpp(struct intel_atomic_state *state, 49 struct intel_link_bw_limits *limits, 50 u8 pipe_mask, 51 const char *reason) 52 { 53 struct drm_i915_private *i915 = to_i915(state->base.dev); 54 enum pipe max_bpp_pipe = INVALID_PIPE; 55 struct intel_crtc *crtc; 56 int max_bpp = 0; 57 58 for_each_intel_crtc_in_pipe_mask(&i915->drm, crtc, pipe_mask) { 59 struct intel_crtc_state *crtc_state; 60 int link_bpp; 61 62 if (limits->bpp_limit_reached_pipes & BIT(crtc->pipe)) 63 continue; 64 65 crtc_state = intel_atomic_get_crtc_state(&state->base, 66 crtc); 67 if (IS_ERR(crtc_state)) 68 return PTR_ERR(crtc_state); 69 70 if (crtc_state->dsc.compression_enable) 71 link_bpp = crtc_state->dsc.compressed_bpp; 72 else 73 /* 74 * TODO: for YUV420 the actual link bpp is only half 75 * of the pipe bpp value. The MST encoder's BW allocation 76 * is based on the pipe bpp value, set the actual link bpp 77 * limit here once the MST BW allocation is fixed. 78 */ 79 link_bpp = crtc_state->pipe_bpp; 80 81 if (link_bpp > max_bpp) { 82 max_bpp = link_bpp; 83 max_bpp_pipe = crtc->pipe; 84 } 85 } 86 87 if (max_bpp_pipe == INVALID_PIPE) 88 return -ENOSPC; 89 90 limits->max_bpp_x16[max_bpp_pipe] = to_bpp_x16(max_bpp) - 1; 91 92 return intel_modeset_pipes_in_mask_early(state, reason, 93 BIT(max_bpp_pipe)); 94 } 95 96 /** 97 * intel_link_bw_set_bpp_limit_for_pipe - set link bpp limit for a pipe to its minimum 98 * @state: atomic state 99 * @old_limits: link BW limits 100 * @new_limits: link BW limits 101 * @pipe: pipe 102 * 103 * Set the link bpp limit for @pipe in @new_limits to its value in 104 * @old_limits and mark this limit as the minimum. This function must be 105 * called after a pipe's compute config function failed, @old_limits 106 * containing the bpp limit with which compute config previously passed. 107 * 108 * The function will fail if setting a minimum is not possible, either 109 * because the old and new limits match (and so would lead to a pipe compute 110 * config failure) or the limit is already at the minimum. 111 * 112 * Returns %true in case of success. 113 */ 114 bool 115 intel_link_bw_set_bpp_limit_for_pipe(struct intel_atomic_state *state, 116 const struct intel_link_bw_limits *old_limits, 117 struct intel_link_bw_limits *new_limits, 118 enum pipe pipe) 119 { 120 struct drm_i915_private *i915 = to_i915(state->base.dev); 121 122 if (pipe == INVALID_PIPE) 123 return false; 124 125 if (new_limits->max_bpp_x16[pipe] == 126 old_limits->max_bpp_x16[pipe]) 127 return false; 128 129 if (drm_WARN_ON(&i915->drm, 130 new_limits->bpp_limit_reached_pipes & BIT(pipe))) 131 return false; 132 133 new_limits->max_bpp_x16[pipe] = 134 old_limits->max_bpp_x16[pipe]; 135 new_limits->bpp_limit_reached_pipes |= BIT(pipe); 136 137 return true; 138 } 139 140 static int check_all_link_config(struct intel_atomic_state *state, 141 struct intel_link_bw_limits *limits) 142 { 143 /* TODO: Check additional shared display link configurations like MST */ 144 int ret; 145 146 ret = intel_fdi_atomic_check_link(state, limits); 147 if (ret) 148 return ret; 149 150 return 0; 151 } 152 153 static bool 154 assert_link_limit_change_valid(struct drm_i915_private *i915, 155 const struct intel_link_bw_limits *old_limits, 156 const struct intel_link_bw_limits *new_limits) 157 { 158 bool bpps_changed = false; 159 enum pipe pipe; 160 161 for_each_pipe(i915, pipe) { 162 /* The bpp limit can only decrease. */ 163 if (drm_WARN_ON(&i915->drm, 164 new_limits->max_bpp_x16[pipe] > 165 old_limits->max_bpp_x16[pipe])) 166 return false; 167 168 if (new_limits->max_bpp_x16[pipe] < 169 old_limits->max_bpp_x16[pipe]) 170 bpps_changed = true; 171 } 172 173 /* At least one limit must change. */ 174 if (drm_WARN_ON(&i915->drm, 175 !bpps_changed)) 176 return false; 177 178 return true; 179 } 180 181 /** 182 * intel_link_bw_atomic_check - check display link states and set a fallback config if needed 183 * @state: atomic state 184 * @new_limits: link BW limits 185 * 186 * Check the configuration of all shared display links in @state and set new BW 187 * limits in @new_limits if there is a BW limitation. 188 * 189 * Returns: 190 * - 0 if the confugration is valid 191 * - %-EAGAIN, if the configuration is invalid and @new_limits got updated 192 * with fallback values with which the configuration of all CRTCs 193 * in @state must be recomputed 194 * - Other negative error, if the configuration is invalid without a 195 * fallback possibility, or the check failed for another reason 196 */ 197 int intel_link_bw_atomic_check(struct intel_atomic_state *state, 198 struct intel_link_bw_limits *new_limits) 199 { 200 struct drm_i915_private *i915 = to_i915(state->base.dev); 201 struct intel_link_bw_limits old_limits = *new_limits; 202 int ret; 203 204 ret = check_all_link_config(state, new_limits); 205 if (ret != -EAGAIN) 206 return ret; 207 208 if (!assert_link_limit_change_valid(i915, &old_limits, new_limits)) 209 return -EINVAL; 210 211 return -EAGAIN; 212 } 213