1 | /* |
2 | * Copyright 2016 Advanced Micro Devices, Inc. |
3 | * |
4 | * Permission is hereby granted, free of charge, to any person obtaining a |
5 | * copy of this software and associated documentation files (the "Software"), |
6 | * to deal in the Software without restriction, including without limitation |
7 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
8 | * and/or sell copies of the Software, and to permit persons to whom the |
9 | * Software is furnished to do so, subject to the following conditions: |
10 | * |
11 | * The above copyright notice and this permission notice shall be included in |
12 | * all copies or substantial portions of the Software. |
13 | * |
14 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
15 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
16 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
17 | * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR |
18 | * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
19 | * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
20 | * OTHER DEALINGS IN THE SOFTWARE. |
21 | * |
22 | * Authors: AMD |
23 | * |
24 | */ |
25 | #include "dc.h" |
26 | #include "reg_helper.h" |
27 | #include "dcn10_dpp.h" |
28 | |
29 | #include "dcn10_cm_common.h" |
30 | #include "custom_float.h" |
31 | |
32 | #define REG(reg) reg |
33 | |
34 | #define CTX \ |
35 | ctx |
36 | |
37 | #undef FN |
38 | #define FN(reg_name, field_name) \ |
39 | reg->shifts.field_name, reg->masks.field_name |
40 | |
41 | void cm_helper_program_color_matrices( |
42 | struct dc_context *ctx, |
43 | const uint16_t *regval, |
44 | const struct color_matrices_reg *reg) |
45 | { |
46 | uint32_t cur_csc_reg; |
47 | unsigned int i = 0; |
48 | |
49 | for (cur_csc_reg = reg->csc_c11_c12; |
50 | cur_csc_reg <= reg->csc_c33_c34; |
51 | cur_csc_reg++) { |
52 | |
53 | const uint16_t *regval0 = &(regval[2 * i]); |
54 | const uint16_t *regval1 = &(regval[(2 * i) + 1]); |
55 | |
56 | REG_SET_2(cur_csc_reg, 0, |
57 | csc_c11, *regval0, |
58 | csc_c12, *regval1); |
59 | |
60 | i++; |
61 | } |
62 | |
63 | } |
64 | |
65 | void cm_helper_read_color_matrices(struct dc_context *ctx, |
66 | uint16_t *regval, |
67 | const struct color_matrices_reg *reg) |
68 | { |
69 | uint32_t cur_csc_reg, regval0, regval1; |
70 | unsigned int i = 0; |
71 | |
72 | for (cur_csc_reg = reg->csc_c11_c12; |
73 | cur_csc_reg <= reg->csc_c33_c34; cur_csc_reg++) { |
74 | REG_GET_2(cur_csc_reg, |
75 | csc_c11, ®val0, |
76 | csc_c12, ®val1); |
77 | |
78 | regval[2 * i] = regval0; |
79 | regval[(2 * i) + 1] = regval1; |
80 | |
81 | i++; |
82 | } |
83 | } |
84 | |
85 | void cm_helper_program_xfer_func( |
86 | struct dc_context *ctx, |
87 | const struct pwl_params *params, |
88 | const struct xfer_func_reg *reg) |
89 | { |
90 | uint32_t reg_region_cur; |
91 | unsigned int i = 0; |
92 | |
93 | REG_SET_2(reg->start_cntl_b, 0, |
94 | exp_region_start, params->corner_points[0].blue.custom_float_x, |
95 | exp_resion_start_segment, 0); |
96 | REG_SET_2(reg->start_cntl_g, 0, |
97 | exp_region_start, params->corner_points[0].green.custom_float_x, |
98 | exp_resion_start_segment, 0); |
99 | REG_SET_2(reg->start_cntl_r, 0, |
100 | exp_region_start, params->corner_points[0].red.custom_float_x, |
101 | exp_resion_start_segment, 0); |
102 | |
103 | REG_SET(reg->start_slope_cntl_b, 0, |
104 | field_region_linear_slope, params->corner_points[0].blue.custom_float_slope); |
105 | REG_SET(reg->start_slope_cntl_g, 0, |
106 | field_region_linear_slope, params->corner_points[0].green.custom_float_slope); |
107 | REG_SET(reg->start_slope_cntl_r, 0, |
108 | field_region_linear_slope, params->corner_points[0].red.custom_float_slope); |
109 | |
110 | REG_SET(reg->start_end_cntl1_b, 0, |
111 | field_region_end, params->corner_points[1].blue.custom_float_x); |
112 | REG_SET_2(reg->start_end_cntl2_b, 0, |
113 | field_region_end_slope, params->corner_points[1].blue.custom_float_slope, |
114 | field_region_end_base, params->corner_points[1].blue.custom_float_y); |
115 | |
116 | REG_SET(reg->start_end_cntl1_g, 0, |
117 | field_region_end, params->corner_points[1].green.custom_float_x); |
118 | REG_SET_2(reg->start_end_cntl2_g, 0, |
119 | field_region_end_slope, params->corner_points[1].green.custom_float_slope, |
120 | field_region_end_base, params->corner_points[1].green.custom_float_y); |
121 | |
122 | REG_SET(reg->start_end_cntl1_r, 0, |
123 | field_region_end, params->corner_points[1].red.custom_float_x); |
124 | REG_SET_2(reg->start_end_cntl2_r, 0, |
125 | field_region_end_slope, params->corner_points[1].red.custom_float_slope, |
126 | field_region_end_base, params->corner_points[1].red.custom_float_y); |
127 | |
128 | for (reg_region_cur = reg->region_start; |
129 | reg_region_cur <= reg->region_end; |
130 | reg_region_cur++) { |
131 | |
132 | const struct gamma_curve *curve0 = &(params->arr_curve_points[2 * i]); |
133 | const struct gamma_curve *curve1 = &(params->arr_curve_points[(2 * i) + 1]); |
134 | |
135 | REG_SET_4(reg_region_cur, 0, |
136 | exp_region0_lut_offset, curve0->offset, |
137 | exp_region0_num_segments, curve0->segments_num, |
138 | exp_region1_lut_offset, curve1->offset, |
139 | exp_region1_num_segments, curve1->segments_num); |
140 | |
141 | i++; |
142 | } |
143 | |
144 | } |
145 | |
146 | |
147 | |
148 | bool cm_helper_convert_to_custom_float( |
149 | struct pwl_result_data *rgb_resulted, |
150 | struct curve_points3 *corner_points, |
151 | uint32_t hw_points_num, |
152 | bool fixpoint) |
153 | { |
154 | struct custom_float_format fmt; |
155 | |
156 | struct pwl_result_data *rgb = rgb_resulted; |
157 | |
158 | uint32_t i = 0; |
159 | |
160 | fmt.exponenta_bits = 6; |
161 | fmt.mantissa_bits = 12; |
162 | fmt.sign = false; |
163 | |
164 | /* corner_points[0] - beginning base, slope offset for R,G,B |
165 | * corner_points[1] - end base, slope offset for R,G,B |
166 | */ |
167 | if (!convert_to_custom_float_format(value: corner_points[0].red.x, format: &fmt, |
168 | result: &corner_points[0].red.custom_float_x)) { |
169 | BREAK_TO_DEBUGGER(); |
170 | return false; |
171 | } |
172 | if (!convert_to_custom_float_format(value: corner_points[0].green.x, format: &fmt, |
173 | result: &corner_points[0].green.custom_float_x)) { |
174 | BREAK_TO_DEBUGGER(); |
175 | return false; |
176 | } |
177 | if (!convert_to_custom_float_format(value: corner_points[0].blue.x, format: &fmt, |
178 | result: &corner_points[0].blue.custom_float_x)) { |
179 | BREAK_TO_DEBUGGER(); |
180 | return false; |
181 | } |
182 | |
183 | if (!convert_to_custom_float_format(value: corner_points[0].red.offset, format: &fmt, |
184 | result: &corner_points[0].red.custom_float_offset)) { |
185 | BREAK_TO_DEBUGGER(); |
186 | return false; |
187 | } |
188 | if (!convert_to_custom_float_format(value: corner_points[0].green.offset, format: &fmt, |
189 | result: &corner_points[0].green.custom_float_offset)) { |
190 | BREAK_TO_DEBUGGER(); |
191 | return false; |
192 | } |
193 | if (!convert_to_custom_float_format(value: corner_points[0].blue.offset, format: &fmt, |
194 | result: &corner_points[0].blue.custom_float_offset)) { |
195 | BREAK_TO_DEBUGGER(); |
196 | return false; |
197 | } |
198 | |
199 | if (!convert_to_custom_float_format(value: corner_points[0].red.slope, format: &fmt, |
200 | result: &corner_points[0].red.custom_float_slope)) { |
201 | BREAK_TO_DEBUGGER(); |
202 | return false; |
203 | } |
204 | if (!convert_to_custom_float_format(value: corner_points[0].green.slope, format: &fmt, |
205 | result: &corner_points[0].green.custom_float_slope)) { |
206 | BREAK_TO_DEBUGGER(); |
207 | return false; |
208 | } |
209 | if (!convert_to_custom_float_format(value: corner_points[0].blue.slope, format: &fmt, |
210 | result: &corner_points[0].blue.custom_float_slope)) { |
211 | BREAK_TO_DEBUGGER(); |
212 | return false; |
213 | } |
214 | |
215 | fmt.mantissa_bits = 10; |
216 | fmt.sign = false; |
217 | |
218 | if (!convert_to_custom_float_format(value: corner_points[1].red.x, format: &fmt, |
219 | result: &corner_points[1].red.custom_float_x)) { |
220 | BREAK_TO_DEBUGGER(); |
221 | return false; |
222 | } |
223 | if (!convert_to_custom_float_format(value: corner_points[1].green.x, format: &fmt, |
224 | result: &corner_points[1].green.custom_float_x)) { |
225 | BREAK_TO_DEBUGGER(); |
226 | return false; |
227 | } |
228 | if (!convert_to_custom_float_format(value: corner_points[1].blue.x, format: &fmt, |
229 | result: &corner_points[1].blue.custom_float_x)) { |
230 | BREAK_TO_DEBUGGER(); |
231 | return false; |
232 | } |
233 | |
234 | if (fixpoint == true) { |
235 | corner_points[1].red.custom_float_y = |
236 | dc_fixpt_clamp_u0d14(arg: corner_points[1].red.y); |
237 | corner_points[1].green.custom_float_y = |
238 | dc_fixpt_clamp_u0d14(arg: corner_points[1].green.y); |
239 | corner_points[1].blue.custom_float_y = |
240 | dc_fixpt_clamp_u0d14(arg: corner_points[1].blue.y); |
241 | } else { |
242 | if (!convert_to_custom_float_format(value: corner_points[1].red.y, |
243 | format: &fmt, result: &corner_points[1].red.custom_float_y)) { |
244 | BREAK_TO_DEBUGGER(); |
245 | return false; |
246 | } |
247 | if (!convert_to_custom_float_format(value: corner_points[1].green.y, |
248 | format: &fmt, result: &corner_points[1].green.custom_float_y)) { |
249 | BREAK_TO_DEBUGGER(); |
250 | return false; |
251 | } |
252 | if (!convert_to_custom_float_format(value: corner_points[1].blue.y, |
253 | format: &fmt, result: &corner_points[1].blue.custom_float_y)) { |
254 | BREAK_TO_DEBUGGER(); |
255 | return false; |
256 | } |
257 | } |
258 | |
259 | if (!convert_to_custom_float_format(value: corner_points[1].red.slope, format: &fmt, |
260 | result: &corner_points[1].red.custom_float_slope)) { |
261 | BREAK_TO_DEBUGGER(); |
262 | return false; |
263 | } |
264 | if (!convert_to_custom_float_format(value: corner_points[1].green.slope, format: &fmt, |
265 | result: &corner_points[1].green.custom_float_slope)) { |
266 | BREAK_TO_DEBUGGER(); |
267 | return false; |
268 | } |
269 | if (!convert_to_custom_float_format(value: corner_points[1].blue.slope, format: &fmt, |
270 | result: &corner_points[1].blue.custom_float_slope)) { |
271 | BREAK_TO_DEBUGGER(); |
272 | return false; |
273 | } |
274 | |
275 | if (hw_points_num == 0 || rgb_resulted == NULL || fixpoint == true) |
276 | return true; |
277 | |
278 | fmt.mantissa_bits = 12; |
279 | fmt.sign = true; |
280 | |
281 | while (i != hw_points_num) { |
282 | if (!convert_to_custom_float_format(value: rgb->red, format: &fmt, |
283 | result: &rgb->red_reg)) { |
284 | BREAK_TO_DEBUGGER(); |
285 | return false; |
286 | } |
287 | |
288 | if (!convert_to_custom_float_format(value: rgb->green, format: &fmt, |
289 | result: &rgb->green_reg)) { |
290 | BREAK_TO_DEBUGGER(); |
291 | return false; |
292 | } |
293 | |
294 | if (!convert_to_custom_float_format(value: rgb->blue, format: &fmt, |
295 | result: &rgb->blue_reg)) { |
296 | BREAK_TO_DEBUGGER(); |
297 | return false; |
298 | } |
299 | |
300 | if (!convert_to_custom_float_format(value: rgb->delta_red, format: &fmt, |
301 | result: &rgb->delta_red_reg)) { |
302 | BREAK_TO_DEBUGGER(); |
303 | return false; |
304 | } |
305 | |
306 | if (!convert_to_custom_float_format(value: rgb->delta_green, format: &fmt, |
307 | result: &rgb->delta_green_reg)) { |
308 | BREAK_TO_DEBUGGER(); |
309 | return false; |
310 | } |
311 | |
312 | if (!convert_to_custom_float_format(value: rgb->delta_blue, format: &fmt, |
313 | result: &rgb->delta_blue_reg)) { |
314 | BREAK_TO_DEBUGGER(); |
315 | return false; |
316 | } |
317 | |
318 | ++rgb; |
319 | ++i; |
320 | } |
321 | |
322 | return true; |
323 | } |
324 | |
325 | /* driver uses 32 regions or less, but DCN HW has 34, extra 2 are set to 0 */ |
326 | #define MAX_REGIONS_NUMBER 34 |
327 | #define MAX_LOW_POINT 25 |
328 | #define NUMBER_REGIONS 32 |
329 | #define NUMBER_SW_SEGMENTS 16 |
330 | |
331 | #define DC_LOGGER \ |
332 | ctx->logger |
333 | |
334 | bool cm_helper_translate_curve_to_hw_format(struct dc_context *ctx, |
335 | const struct dc_transfer_func *output_tf, |
336 | struct pwl_params *lut_params, bool fixpoint) |
337 | { |
338 | struct curve_points3 *corner_points; |
339 | struct pwl_result_data *rgb_resulted; |
340 | struct pwl_result_data *rgb; |
341 | struct pwl_result_data *rgb_plus_1; |
342 | struct pwl_result_data *rgb_minus_1; |
343 | |
344 | int32_t region_start, region_end; |
345 | int32_t i; |
346 | uint32_t j, k, seg_distr[MAX_REGIONS_NUMBER], increment, start_index, hw_points; |
347 | |
348 | if (output_tf == NULL || lut_params == NULL || output_tf->type == TF_TYPE_BYPASS) |
349 | return false; |
350 | |
351 | corner_points = lut_params->corner_points; |
352 | rgb_resulted = lut_params->rgb_resulted; |
353 | hw_points = 0; |
354 | |
355 | memset(lut_params, 0, sizeof(struct pwl_params)); |
356 | memset(seg_distr, 0, sizeof(seg_distr)); |
357 | |
358 | if (output_tf->tf == TRANSFER_FUNCTION_PQ || output_tf->tf == TRANSFER_FUNCTION_GAMMA22) { |
359 | /* 32 segments |
360 | * segments are from 2^-25 to 2^7 |
361 | */ |
362 | for (i = 0; i < NUMBER_REGIONS ; i++) |
363 | seg_distr[i] = 3; |
364 | |
365 | region_start = -MAX_LOW_POINT; |
366 | region_end = NUMBER_REGIONS - MAX_LOW_POINT; |
367 | } else { |
368 | /* 11 segments |
369 | * segment is from 2^-10 to 2^1 |
370 | * There are less than 256 points, for optimization |
371 | */ |
372 | seg_distr[0] = 3; |
373 | seg_distr[1] = 4; |
374 | seg_distr[2] = 4; |
375 | seg_distr[3] = 4; |
376 | seg_distr[4] = 4; |
377 | seg_distr[5] = 4; |
378 | seg_distr[6] = 4; |
379 | seg_distr[7] = 4; |
380 | seg_distr[8] = 4; |
381 | seg_distr[9] = 4; |
382 | seg_distr[10] = 1; |
383 | |
384 | region_start = -10; |
385 | region_end = 1; |
386 | } |
387 | |
388 | for (i = region_end - region_start; i < MAX_REGIONS_NUMBER ; i++) |
389 | seg_distr[i] = -1; |
390 | |
391 | for (k = 0; k < MAX_REGIONS_NUMBER; k++) { |
392 | if (seg_distr[k] != -1) |
393 | hw_points += (1 << seg_distr[k]); |
394 | } |
395 | |
396 | j = 0; |
397 | for (k = 0; k < (region_end - region_start); k++) { |
398 | increment = NUMBER_SW_SEGMENTS / (1 << seg_distr[k]); |
399 | start_index = (region_start + k + MAX_LOW_POINT) * |
400 | NUMBER_SW_SEGMENTS; |
401 | for (i = start_index; i < start_index + NUMBER_SW_SEGMENTS; |
402 | i += increment) { |
403 | if (j == hw_points - 1) |
404 | break; |
405 | rgb_resulted[j].red = output_tf->tf_pts.red[i]; |
406 | rgb_resulted[j].green = output_tf->tf_pts.green[i]; |
407 | rgb_resulted[j].blue = output_tf->tf_pts.blue[i]; |
408 | j++; |
409 | } |
410 | } |
411 | |
412 | /* last point */ |
413 | start_index = (region_end + MAX_LOW_POINT) * NUMBER_SW_SEGMENTS; |
414 | rgb_resulted[hw_points - 1].red = output_tf->tf_pts.red[start_index]; |
415 | rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index]; |
416 | rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index]; |
417 | |
418 | rgb_resulted[hw_points].red = rgb_resulted[hw_points - 1].red; |
419 | rgb_resulted[hw_points].green = rgb_resulted[hw_points - 1].green; |
420 | rgb_resulted[hw_points].blue = rgb_resulted[hw_points - 1].blue; |
421 | |
422 | // All 3 color channels have same x |
423 | corner_points[0].red.x = dc_fixpt_pow(arg1: dc_fixpt_from_int(arg: 2), |
424 | arg2: dc_fixpt_from_int(arg: region_start)); |
425 | corner_points[0].green.x = corner_points[0].red.x; |
426 | corner_points[0].blue.x = corner_points[0].red.x; |
427 | |
428 | corner_points[1].red.x = dc_fixpt_pow(arg1: dc_fixpt_from_int(arg: 2), |
429 | arg2: dc_fixpt_from_int(arg: region_end)); |
430 | corner_points[1].green.x = corner_points[1].red.x; |
431 | corner_points[1].blue.x = corner_points[1].red.x; |
432 | |
433 | corner_points[0].red.y = rgb_resulted[0].red; |
434 | corner_points[0].green.y = rgb_resulted[0].green; |
435 | corner_points[0].blue.y = rgb_resulted[0].blue; |
436 | |
437 | corner_points[0].red.slope = dc_fixpt_div(arg1: corner_points[0].red.y, |
438 | arg2: corner_points[0].red.x); |
439 | corner_points[0].green.slope = dc_fixpt_div(arg1: corner_points[0].green.y, |
440 | arg2: corner_points[0].green.x); |
441 | corner_points[0].blue.slope = dc_fixpt_div(arg1: corner_points[0].blue.y, |
442 | arg2: corner_points[0].blue.x); |
443 | |
444 | /* see comment above, m_arrPoints[1].y should be the Y value for the |
445 | * region end (m_numOfHwPoints), not last HW point(m_numOfHwPoints - 1) |
446 | */ |
447 | corner_points[1].red.y = rgb_resulted[hw_points - 1].red; |
448 | corner_points[1].green.y = rgb_resulted[hw_points - 1].green; |
449 | corner_points[1].blue.y = rgb_resulted[hw_points - 1].blue; |
450 | corner_points[1].red.slope = dc_fixpt_zero; |
451 | corner_points[1].green.slope = dc_fixpt_zero; |
452 | corner_points[1].blue.slope = dc_fixpt_zero; |
453 | |
454 | if (output_tf->tf == TRANSFER_FUNCTION_PQ) { |
455 | /* for PQ, we want to have a straight line from last HW X point, |
456 | * and the slope to be such that we hit 1.0 at 10000 nits. |
457 | */ |
458 | const struct fixed31_32 end_value = |
459 | dc_fixpt_from_int(arg: 125); |
460 | |
461 | corner_points[1].red.slope = dc_fixpt_div( |
462 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].red.y), |
463 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].red.x)); |
464 | corner_points[1].green.slope = dc_fixpt_div( |
465 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].green.y), |
466 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].green.x)); |
467 | corner_points[1].blue.slope = dc_fixpt_div( |
468 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].blue.y), |
469 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].blue.x)); |
470 | } |
471 | |
472 | lut_params->hw_points_num = hw_points; |
473 | |
474 | k = 0; |
475 | for (i = 1; i < MAX_REGIONS_NUMBER; i++) { |
476 | if (seg_distr[k] != -1) { |
477 | lut_params->arr_curve_points[k].segments_num = |
478 | seg_distr[k]; |
479 | lut_params->arr_curve_points[i].offset = |
480 | lut_params->arr_curve_points[k].offset + (1 << seg_distr[k]); |
481 | } |
482 | k++; |
483 | } |
484 | |
485 | if (seg_distr[k] != -1) |
486 | lut_params->arr_curve_points[k].segments_num = seg_distr[k]; |
487 | |
488 | rgb = rgb_resulted; |
489 | rgb_plus_1 = rgb_resulted + 1; |
490 | rgb_minus_1 = rgb; |
491 | |
492 | i = 1; |
493 | while (i != hw_points + 1) { |
494 | |
495 | if (i >= hw_points - 1) { |
496 | if (dc_fixpt_lt(arg1: rgb_plus_1->red, arg2: rgb->red)) |
497 | rgb_plus_1->red = dc_fixpt_add(arg1: rgb->red, arg2: rgb_minus_1->delta_red); |
498 | if (dc_fixpt_lt(arg1: rgb_plus_1->green, arg2: rgb->green)) |
499 | rgb_plus_1->green = dc_fixpt_add(arg1: rgb->green, arg2: rgb_minus_1->delta_green); |
500 | if (dc_fixpt_lt(arg1: rgb_plus_1->blue, arg2: rgb->blue)) |
501 | rgb_plus_1->blue = dc_fixpt_add(arg1: rgb->blue, arg2: rgb_minus_1->delta_blue); |
502 | } |
503 | |
504 | rgb->delta_red = dc_fixpt_sub(arg1: rgb_plus_1->red, arg2: rgb->red); |
505 | rgb->delta_green = dc_fixpt_sub(arg1: rgb_plus_1->green, arg2: rgb->green); |
506 | rgb->delta_blue = dc_fixpt_sub(arg1: rgb_plus_1->blue, arg2: rgb->blue); |
507 | |
508 | |
509 | if (fixpoint == true) { |
510 | uint32_t red_clamp = dc_fixpt_clamp_u0d14(arg: rgb->delta_red); |
511 | uint32_t green_clamp = dc_fixpt_clamp_u0d14(arg: rgb->delta_green); |
512 | uint32_t blue_clamp = dc_fixpt_clamp_u0d14(arg: rgb->delta_blue); |
513 | |
514 | if (red_clamp >> 10 || green_clamp >> 10 || blue_clamp >> 10) |
515 | DC_LOG_WARNING("Losing delta precision while programming shaper LUT." ); |
516 | |
517 | rgb->delta_red_reg = red_clamp & 0x3ff; |
518 | rgb->delta_green_reg = green_clamp & 0x3ff; |
519 | rgb->delta_blue_reg = blue_clamp & 0x3ff; |
520 | rgb->red_reg = dc_fixpt_clamp_u0d14(arg: rgb->red); |
521 | rgb->green_reg = dc_fixpt_clamp_u0d14(arg: rgb->green); |
522 | rgb->blue_reg = dc_fixpt_clamp_u0d14(arg: rgb->blue); |
523 | } |
524 | |
525 | ++rgb_plus_1; |
526 | rgb_minus_1 = rgb; |
527 | ++rgb; |
528 | ++i; |
529 | } |
530 | cm_helper_convert_to_custom_float(rgb_resulted, |
531 | corner_points: lut_params->corner_points, |
532 | hw_points_num: hw_points, fixpoint); |
533 | |
534 | return true; |
535 | } |
536 | |
537 | #define NUM_DEGAMMA_REGIONS 12 |
538 | |
539 | |
540 | bool cm_helper_translate_curve_to_degamma_hw_format( |
541 | const struct dc_transfer_func *output_tf, |
542 | struct pwl_params *lut_params) |
543 | { |
544 | struct curve_points3 *corner_points; |
545 | struct pwl_result_data *rgb_resulted; |
546 | struct pwl_result_data *rgb; |
547 | struct pwl_result_data *rgb_plus_1; |
548 | |
549 | int32_t region_start, region_end; |
550 | int32_t i; |
551 | uint32_t j, k, seg_distr[MAX_REGIONS_NUMBER], increment, start_index, hw_points; |
552 | |
553 | if (output_tf == NULL || lut_params == NULL || output_tf->type == TF_TYPE_BYPASS) |
554 | return false; |
555 | |
556 | corner_points = lut_params->corner_points; |
557 | rgb_resulted = lut_params->rgb_resulted; |
558 | hw_points = 0; |
559 | |
560 | memset(lut_params, 0, sizeof(struct pwl_params)); |
561 | memset(seg_distr, 0, sizeof(seg_distr)); |
562 | |
563 | region_start = -NUM_DEGAMMA_REGIONS; |
564 | region_end = 0; |
565 | |
566 | |
567 | for (i = region_end - region_start; i < MAX_REGIONS_NUMBER ; i++) |
568 | seg_distr[i] = -1; |
569 | /* 12 segments |
570 | * segments are from 2^-12 to 0 |
571 | */ |
572 | for (i = 0; i < NUM_DEGAMMA_REGIONS ; i++) |
573 | seg_distr[i] = 4; |
574 | |
575 | for (k = 0; k < MAX_REGIONS_NUMBER; k++) { |
576 | if (seg_distr[k] != -1) |
577 | hw_points += (1 << seg_distr[k]); |
578 | } |
579 | |
580 | j = 0; |
581 | for (k = 0; k < (region_end - region_start); k++) { |
582 | increment = NUMBER_SW_SEGMENTS / (1 << seg_distr[k]); |
583 | start_index = (region_start + k + MAX_LOW_POINT) * |
584 | NUMBER_SW_SEGMENTS; |
585 | for (i = start_index; i < start_index + NUMBER_SW_SEGMENTS; |
586 | i += increment) { |
587 | if (j == hw_points - 1) |
588 | break; |
589 | rgb_resulted[j].red = output_tf->tf_pts.red[i]; |
590 | rgb_resulted[j].green = output_tf->tf_pts.green[i]; |
591 | rgb_resulted[j].blue = output_tf->tf_pts.blue[i]; |
592 | j++; |
593 | } |
594 | } |
595 | |
596 | /* last point */ |
597 | start_index = (region_end + MAX_LOW_POINT) * NUMBER_SW_SEGMENTS; |
598 | rgb_resulted[hw_points - 1].red = output_tf->tf_pts.red[start_index]; |
599 | rgb_resulted[hw_points - 1].green = output_tf->tf_pts.green[start_index]; |
600 | rgb_resulted[hw_points - 1].blue = output_tf->tf_pts.blue[start_index]; |
601 | |
602 | rgb_resulted[hw_points].red = rgb_resulted[hw_points - 1].red; |
603 | rgb_resulted[hw_points].green = rgb_resulted[hw_points - 1].green; |
604 | rgb_resulted[hw_points].blue = rgb_resulted[hw_points - 1].blue; |
605 | |
606 | corner_points[0].red.x = dc_fixpt_pow(arg1: dc_fixpt_from_int(arg: 2), |
607 | arg2: dc_fixpt_from_int(arg: region_start)); |
608 | corner_points[0].green.x = corner_points[0].red.x; |
609 | corner_points[0].blue.x = corner_points[0].red.x; |
610 | corner_points[1].red.x = dc_fixpt_pow(arg1: dc_fixpt_from_int(arg: 2), |
611 | arg2: dc_fixpt_from_int(arg: region_end)); |
612 | corner_points[1].green.x = corner_points[1].red.x; |
613 | corner_points[1].blue.x = corner_points[1].red.x; |
614 | |
615 | corner_points[0].red.y = rgb_resulted[0].red; |
616 | corner_points[0].green.y = rgb_resulted[0].green; |
617 | corner_points[0].blue.y = rgb_resulted[0].blue; |
618 | |
619 | /* see comment above, m_arrPoints[1].y should be the Y value for the |
620 | * region end (m_numOfHwPoints), not last HW point(m_numOfHwPoints - 1) |
621 | */ |
622 | corner_points[1].red.y = rgb_resulted[hw_points - 1].red; |
623 | corner_points[1].green.y = rgb_resulted[hw_points - 1].green; |
624 | corner_points[1].blue.y = rgb_resulted[hw_points - 1].blue; |
625 | corner_points[1].red.slope = dc_fixpt_zero; |
626 | corner_points[1].green.slope = dc_fixpt_zero; |
627 | corner_points[1].blue.slope = dc_fixpt_zero; |
628 | |
629 | if (output_tf->tf == TRANSFER_FUNCTION_PQ) { |
630 | /* for PQ, we want to have a straight line from last HW X point, |
631 | * and the slope to be such that we hit 1.0 at 10000 nits. |
632 | */ |
633 | const struct fixed31_32 end_value = |
634 | dc_fixpt_from_int(arg: 125); |
635 | |
636 | corner_points[1].red.slope = dc_fixpt_div( |
637 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].red.y), |
638 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].red.x)); |
639 | corner_points[1].green.slope = dc_fixpt_div( |
640 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].green.y), |
641 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].green.x)); |
642 | corner_points[1].blue.slope = dc_fixpt_div( |
643 | arg1: dc_fixpt_sub(arg1: dc_fixpt_one, arg2: corner_points[1].blue.y), |
644 | arg2: dc_fixpt_sub(arg1: end_value, arg2: corner_points[1].blue.x)); |
645 | } |
646 | |
647 | lut_params->hw_points_num = hw_points; |
648 | |
649 | k = 0; |
650 | for (i = 1; i < MAX_REGIONS_NUMBER; i++) { |
651 | if (seg_distr[k] != -1) { |
652 | lut_params->arr_curve_points[k].segments_num = |
653 | seg_distr[k]; |
654 | lut_params->arr_curve_points[i].offset = |
655 | lut_params->arr_curve_points[k].offset + (1 << seg_distr[k]); |
656 | } |
657 | k++; |
658 | } |
659 | |
660 | if (seg_distr[k] != -1) |
661 | lut_params->arr_curve_points[k].segments_num = seg_distr[k]; |
662 | |
663 | rgb = rgb_resulted; |
664 | rgb_plus_1 = rgb_resulted + 1; |
665 | |
666 | i = 1; |
667 | while (i != hw_points + 1) { |
668 | rgb->delta_red = dc_fixpt_sub(arg1: rgb_plus_1->red, arg2: rgb->red); |
669 | rgb->delta_green = dc_fixpt_sub(arg1: rgb_plus_1->green, arg2: rgb->green); |
670 | rgb->delta_blue = dc_fixpt_sub(arg1: rgb_plus_1->blue, arg2: rgb->blue); |
671 | |
672 | ++rgb_plus_1; |
673 | ++rgb; |
674 | ++i; |
675 | } |
676 | cm_helper_convert_to_custom_float(rgb_resulted, |
677 | corner_points: lut_params->corner_points, |
678 | hw_points_num: hw_points, fixpoint: false); |
679 | |
680 | return true; |
681 | } |
682 | |