xref: /linux/drivers/gpu/drm/amd/display/dc/link/link_factory.c (revision 2c1ed907520c50326b8f604907a8478b27881a2e)
1 /*
2  * Copyright 2023 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 
26 /* FILE POLICY AND INTENDED USAGE:
27  * This file owns the creation/destruction of link structure.
28  */
29 #include "link_factory.h"
30 #include "link_detection.h"
31 #include "link_resource.h"
32 #include "link_validation.h"
33 #include "link_dpms.h"
34 #include "accessories/link_dp_cts.h"
35 #include "accessories/link_dp_trace.h"
36 #include "protocols/link_ddc.h"
37 #include "protocols/link_dp_capability.h"
38 #include "protocols/link_dp_dpia_bw.h"
39 #include "protocols/link_dp_dpia.h"
40 #include "protocols/link_dp_irq_handler.h"
41 #include "protocols/link_dp_phy.h"
42 #include "protocols/link_dp_training.h"
43 #include "protocols/link_edp_panel_control.h"
44 #include "protocols/link_hpd.h"
45 #include "gpio_service_interface.h"
46 #include "atomfirmware.h"
47 
48 #define DC_LOGGER \
49 	dc_ctx->logger
50 #define DC_LOGGER_INIT(logger)
51 
52 #define LINK_INFO(...) \
53 	DC_LOG_HW_HOTPLUG(  \
54 		__VA_ARGS__)
55 
56 /* link factory owns the creation/destruction of link structures. */
construct_link_service_factory(struct link_service * link_srv)57 static void construct_link_service_factory(struct link_service *link_srv)
58 {
59 
60 	link_srv->create_link = link_create;
61 	link_srv->destroy_link = link_destroy;
62 }
63 
64 /* link_detection manages link detection states and receiver states by using
65  * various link protocols. It also provides helper functions to interpret
66  * certain capabilities or status based on the states it manages or retrieve
67  * them directly from connected receivers.
68  */
construct_link_service_detection(struct link_service * link_srv)69 static void construct_link_service_detection(struct link_service *link_srv)
70 {
71 	link_srv->detect_link = link_detect;
72 	link_srv->detect_connection_type = link_detect_connection_type;
73 	link_srv->add_remote_sink = link_add_remote_sink;
74 	link_srv->remove_remote_sink = link_remove_remote_sink;
75 	link_srv->get_hpd_state = link_get_hpd_state;
76 	link_srv->get_hpd_gpio = link_get_hpd_gpio;
77 	link_srv->enable_hpd = link_enable_hpd;
78 	link_srv->disable_hpd = link_disable_hpd;
79 	link_srv->enable_hpd_filter = link_enable_hpd_filter;
80 	link_srv->reset_cur_dp_mst_topology = link_reset_cur_dp_mst_topology;
81 	link_srv->get_status = link_get_status;
82 	link_srv->is_hdcp1x_supported = link_is_hdcp14;
83 	link_srv->is_hdcp2x_supported = link_is_hdcp22;
84 	link_srv->clear_dprx_states = link_clear_dprx_states;
85 }
86 
87 /* link resource implements accessors to link resource. */
construct_link_service_resource(struct link_service * link_srv)88 static void construct_link_service_resource(struct link_service *link_srv)
89 {
90 	link_srv->get_cur_res_map = link_get_cur_res_map;
91 	link_srv->restore_res_map = link_restore_res_map;
92 	link_srv->get_cur_link_res = link_get_cur_link_res;
93 }
94 
95 /* link validation owns timing validation against various link limitations. (ex.
96  * link bandwidth, receiver capability or our hardware capability) It also
97  * provides helper functions exposing bandwidth formulas used in validation.
98  */
construct_link_service_validation(struct link_service * link_srv)99 static void construct_link_service_validation(struct link_service *link_srv)
100 {
101 	link_srv->validate_mode_timing = link_validate_mode_timing;
102 	link_srv->dp_link_bandwidth_kbps = dp_link_bandwidth_kbps;
103 	link_srv->validate_dpia_bandwidth = link_validate_dpia_bandwidth;
104 	link_srv->dp_required_hblank_size_bytes = dp_required_hblank_size_bytes;
105 }
106 
107 /* link dpms owns the programming sequence of stream's dpms state associated
108  * with the link and link's enable/disable sequences as result of the stream's
109  * dpms state change.
110  */
construct_link_service_dpms(struct link_service * link_srv)111 static void construct_link_service_dpms(struct link_service *link_srv)
112 {
113 	link_srv->set_dpms_on = link_set_dpms_on;
114 	link_srv->set_dpms_off = link_set_dpms_off;
115 	link_srv->resume = link_resume;
116 	link_srv->blank_all_dp_displays = link_blank_all_dp_displays;
117 	link_srv->blank_all_edp_displays = link_blank_all_edp_displays;
118 	link_srv->blank_dp_stream = link_blank_dp_stream;
119 	link_srv->increase_mst_payload = link_increase_mst_payload;
120 	link_srv->reduce_mst_payload = link_reduce_mst_payload;
121 	link_srv->set_dsc_on_stream = link_set_dsc_on_stream;
122 	link_srv->set_dsc_enable = link_set_dsc_enable;
123 	link_srv->update_dsc_config = link_update_dsc_config;
124 }
125 
126 /* link ddc implements generic display communication protocols such as i2c, aux
127  * and scdc. It should not contain any specific applications of these
128  * protocols such as display capability query, detection, or handshaking such as
129  * link training.
130  */
construct_link_service_ddc(struct link_service * link_srv)131 static void construct_link_service_ddc(struct link_service *link_srv)
132 {
133 	link_srv->create_ddc_service = link_create_ddc_service;
134 	link_srv->destroy_ddc_service = link_destroy_ddc_service;
135 	link_srv->query_ddc_data = link_query_ddc_data;
136 	link_srv->aux_transfer_raw = link_aux_transfer_raw;
137 	link_srv->configure_fixed_vs_pe_retimer = link_configure_fixed_vs_pe_retimer;
138 	link_srv->aux_transfer_with_retries_no_mutex =
139 			link_aux_transfer_with_retries_no_mutex;
140 	link_srv->is_in_aux_transaction_mode = link_is_in_aux_transaction_mode;
141 	link_srv->get_aux_defer_delay = link_get_aux_defer_delay;
142 }
143 
144 /* link dp capability implements dp specific link capability retrieval sequence.
145  * It is responsible for retrieving, parsing, overriding, deciding capability
146  * obtained from dp link. Link capability consists of encoders, DPRXs, cables,
147  * retimers, usb and all other possible backend capabilities.
148  */
construct_link_service_dp_capability(struct link_service * link_srv)149 static void construct_link_service_dp_capability(struct link_service *link_srv)
150 {
151 	link_srv->dp_is_sink_present = dp_is_sink_present;
152 	link_srv->dp_is_fec_supported = dp_is_fec_supported;
153 	link_srv->dp_is_128b_132b_signal = dp_is_128b_132b_signal;
154 	link_srv->dp_get_max_link_enc_cap = dp_get_max_link_enc_cap;
155 	link_srv->dp_get_verified_link_cap = dp_get_verified_link_cap;
156 	link_srv->dp_get_encoding_format = link_dp_get_encoding_format;
157 	link_srv->dp_should_enable_fec = dp_should_enable_fec;
158 	link_srv->dp_decide_link_settings = link_decide_link_settings;
159 	link_srv->mst_decide_link_encoding_format =
160 			mst_decide_link_encoding_format;
161 	link_srv->edp_decide_link_settings = edp_decide_link_settings;
162 	link_srv->bw_kbps_from_raw_frl_link_rate_data =
163 			link_bw_kbps_from_raw_frl_link_rate_data;
164 	link_srv->dp_overwrite_extended_receiver_cap =
165 			dp_overwrite_extended_receiver_cap;
166 	link_srv->dp_decide_lttpr_mode = dp_decide_lttpr_mode;
167 }
168 
169 /* link dp phy/dpia implements basic dp phy/dpia functionality such as
170  * enable/disable output and set lane/drive settings. It is responsible for
171  * maintaining and update software state representing current phy/dpia status
172  * such as current link settings.
173  */
construct_link_service_dp_phy_or_dpia(struct link_service * link_srv)174 static void construct_link_service_dp_phy_or_dpia(struct link_service *link_srv)
175 {
176 	link_srv->dpia_handle_usb4_bandwidth_allocation_for_link =
177 			dpia_handle_usb4_bandwidth_allocation_for_link;
178 	link_srv->dpia_handle_bw_alloc_response = dpia_handle_bw_alloc_response;
179 	link_srv->dp_set_drive_settings = dp_set_drive_settings;
180 	link_srv->dpcd_write_rx_power_ctrl = dpcd_write_rx_power_ctrl;
181 }
182 
183 /* link dp irq handler implements DP HPD short pulse handling sequence according
184  * to DP specifications
185  */
construct_link_service_dp_irq_handler(struct link_service * link_srv)186 static void construct_link_service_dp_irq_handler(struct link_service *link_srv)
187 {
188 	link_srv->dp_parse_link_loss_status = dp_parse_link_loss_status;
189 	link_srv->dp_should_allow_hpd_rx_irq = dp_should_allow_hpd_rx_irq;
190 	link_srv->dp_handle_link_loss = dp_handle_link_loss;
191 	link_srv->dp_read_hpd_rx_irq_data = dp_read_hpd_rx_irq_data;
192 	link_srv->dp_handle_hpd_rx_irq = dp_handle_hpd_rx_irq;
193 }
194 
195 /* link edp panel control implements retrieval and configuration of eDP panel
196  * features such as PSR and ABM and it also manages specs defined eDP panel
197  * power sequences.
198  */
construct_link_service_edp_panel_control(struct link_service * link_srv)199 static void construct_link_service_edp_panel_control(struct link_service *link_srv)
200 {
201 	link_srv->edp_panel_backlight_power_on = edp_panel_backlight_power_on;
202 	link_srv->edp_get_backlight_level = edp_get_backlight_level;
203 	link_srv->edp_get_backlight_level_nits = edp_get_backlight_level_nits;
204 	link_srv->edp_set_backlight_level = edp_set_backlight_level;
205 	link_srv->edp_set_backlight_level_nits = edp_set_backlight_level_nits;
206 	link_srv->edp_get_target_backlight_pwm = edp_get_target_backlight_pwm;
207 	link_srv->edp_get_psr_state = edp_get_psr_state;
208 	link_srv->edp_set_psr_allow_active = edp_set_psr_allow_active;
209 	link_srv->edp_setup_psr = edp_setup_psr;
210 	link_srv->edp_set_sink_vtotal_in_psr_active =
211 			edp_set_sink_vtotal_in_psr_active;
212 	link_srv->edp_get_psr_residency = edp_get_psr_residency;
213 
214 	link_srv->edp_get_replay_state = edp_get_replay_state;
215 	link_srv->edp_set_replay_allow_active = edp_set_replay_allow_active;
216 	link_srv->edp_setup_replay = edp_setup_replay;
217 	link_srv->edp_send_replay_cmd = edp_send_replay_cmd;
218 	link_srv->edp_set_coasting_vtotal = edp_set_coasting_vtotal;
219 	link_srv->edp_replay_residency = edp_replay_residency;
220 	link_srv->edp_set_replay_power_opt_and_coasting_vtotal = edp_set_replay_power_opt_and_coasting_vtotal;
221 
222 	link_srv->edp_wait_for_t12 = edp_wait_for_t12;
223 	link_srv->edp_is_ilr_optimization_required =
224 			edp_is_ilr_optimization_required;
225 	link_srv->edp_backlight_enable_aux = edp_backlight_enable_aux;
226 	link_srv->edp_add_delay_for_T9 = edp_add_delay_for_T9;
227 	link_srv->edp_receiver_ready_T9 = edp_receiver_ready_T9;
228 	link_srv->edp_receiver_ready_T7 = edp_receiver_ready_T7;
229 	link_srv->edp_power_alpm_dpcd_enable = edp_power_alpm_dpcd_enable;
230 	link_srv->edp_set_panel_power = edp_set_panel_power;
231 }
232 
233 /* link dp cts implements dp compliance test automation protocols and manual
234  * testing interfaces for debugging and certification purpose.
235  */
construct_link_service_dp_cts(struct link_service * link_srv)236 static void construct_link_service_dp_cts(struct link_service *link_srv)
237 {
238 	link_srv->dp_handle_automated_test = dp_handle_automated_test;
239 	link_srv->dp_set_test_pattern = dp_set_test_pattern;
240 	link_srv->dp_set_preferred_link_settings =
241 			dp_set_preferred_link_settings;
242 	link_srv->dp_set_preferred_training_settings =
243 			dp_set_preferred_training_settings;
244 }
245 
246 /* link dp trace implements tracing interfaces for tracking major dp sequences
247  * including execution status and timestamps
248  */
construct_link_service_dp_trace(struct link_service * link_srv)249 static void construct_link_service_dp_trace(struct link_service *link_srv)
250 {
251 	link_srv->dp_trace_is_initialized = dp_trace_is_initialized;
252 	link_srv->dp_trace_set_is_logged_flag = dp_trace_set_is_logged_flag;
253 	link_srv->dp_trace_is_logged = dp_trace_is_logged;
254 	link_srv->dp_trace_get_lt_end_timestamp = dp_trace_get_lt_end_timestamp;
255 	link_srv->dp_trace_get_lt_counts = dp_trace_get_lt_counts;
256 	link_srv->dp_trace_get_link_loss_count = dp_trace_get_link_loss_count;
257 	link_srv->dp_trace_set_edp_power_timestamp =
258 			dp_trace_set_edp_power_timestamp;
259 	link_srv->dp_trace_get_edp_poweron_timestamp =
260 			dp_trace_get_edp_poweron_timestamp;
261 	link_srv->dp_trace_get_edp_poweroff_timestamp =
262 			dp_trace_get_edp_poweroff_timestamp;
263 	link_srv->dp_trace_source_sequence = dp_trace_source_sequence;
264 }
265 
construct_link_service(struct link_service * link_srv)266 static void construct_link_service(struct link_service *link_srv)
267 {
268 	/* All link service functions should fall under some sub categories.
269 	 * If a new function doesn't perfectly fall under an existing sub
270 	 * category, it must be that you are either adding a whole new aspect of
271 	 * responsibility to link service or something doesn't belong to link
272 	 * service. In that case please contact the arch owner to arrange a
273 	 * design review meeting.
274 	 */
275 	construct_link_service_factory(link_srv);
276 	construct_link_service_detection(link_srv);
277 	construct_link_service_resource(link_srv);
278 	construct_link_service_validation(link_srv);
279 	construct_link_service_dpms(link_srv);
280 	construct_link_service_ddc(link_srv);
281 	construct_link_service_dp_capability(link_srv);
282 	construct_link_service_dp_phy_or_dpia(link_srv);
283 	construct_link_service_dp_irq_handler(link_srv);
284 	construct_link_service_edp_panel_control(link_srv);
285 	construct_link_service_dp_cts(link_srv);
286 	construct_link_service_dp_trace(link_srv);
287 }
288 
link_create_link_service(void)289 struct link_service *link_create_link_service(void)
290 {
291 	struct link_service *link_srv = kzalloc(sizeof(*link_srv), GFP_KERNEL);
292 
293 	if (link_srv == NULL)
294 		goto fail;
295 
296 	construct_link_service(link_srv);
297 
298 	return link_srv;
299 fail:
300 	return NULL;
301 }
302 
link_destroy_link_service(struct link_service ** link_srv)303 void link_destroy_link_service(struct link_service **link_srv)
304 {
305 	kfree(*link_srv);
306 	*link_srv = NULL;
307 }
308 
translate_encoder_to_transmitter(struct graphics_object_id encoder)309 static enum transmitter translate_encoder_to_transmitter(
310 		struct graphics_object_id encoder)
311 {
312 	switch (encoder.id) {
313 	case ENCODER_ID_INTERNAL_UNIPHY:
314 		switch (encoder.enum_id) {
315 		case ENUM_ID_1:
316 			return TRANSMITTER_UNIPHY_A;
317 		case ENUM_ID_2:
318 			return TRANSMITTER_UNIPHY_B;
319 		default:
320 			return TRANSMITTER_UNKNOWN;
321 		}
322 	break;
323 	case ENCODER_ID_INTERNAL_UNIPHY1:
324 		switch (encoder.enum_id) {
325 		case ENUM_ID_1:
326 			return TRANSMITTER_UNIPHY_C;
327 		case ENUM_ID_2:
328 			return TRANSMITTER_UNIPHY_D;
329 		default:
330 			return TRANSMITTER_UNKNOWN;
331 		}
332 	break;
333 	case ENCODER_ID_INTERNAL_UNIPHY2:
334 		switch (encoder.enum_id) {
335 		case ENUM_ID_1:
336 			return TRANSMITTER_UNIPHY_E;
337 		case ENUM_ID_2:
338 			return TRANSMITTER_UNIPHY_F;
339 		default:
340 			return TRANSMITTER_UNKNOWN;
341 		}
342 	break;
343 	case ENCODER_ID_INTERNAL_UNIPHY3:
344 		switch (encoder.enum_id) {
345 		case ENUM_ID_1:
346 			return TRANSMITTER_UNIPHY_G;
347 		default:
348 			return TRANSMITTER_UNKNOWN;
349 		}
350 	break;
351 	case ENCODER_ID_EXTERNAL_NUTMEG:
352 		switch (encoder.enum_id) {
353 		case ENUM_ID_1:
354 			return TRANSMITTER_NUTMEG_CRT;
355 		default:
356 			return TRANSMITTER_UNKNOWN;
357 		}
358 	break;
359 	case ENCODER_ID_EXTERNAL_TRAVIS:
360 		switch (encoder.enum_id) {
361 		case ENUM_ID_1:
362 			return TRANSMITTER_TRAVIS_CRT;
363 		case ENUM_ID_2:
364 			return TRANSMITTER_TRAVIS_LCD;
365 		default:
366 			return TRANSMITTER_UNKNOWN;
367 		}
368 	break;
369 	default:
370 		return TRANSMITTER_UNKNOWN;
371 	}
372 }
373 
link_destruct(struct dc_link * link)374 static void link_destruct(struct dc_link *link)
375 {
376 	int i;
377 
378 	if (link->hpd_gpio) {
379 		dal_gpio_destroy_irq(&link->hpd_gpio);
380 		link->hpd_gpio = NULL;
381 	}
382 
383 	if (link->ddc)
384 		link_destroy_ddc_service(&link->ddc);
385 
386 	if (link->panel_cntl)
387 		link->panel_cntl->funcs->destroy(&link->panel_cntl);
388 
389 	if (link->link_enc && !link->is_dig_mapping_flexible) {
390 		/* Update link encoder resource tracking variables. These are used for
391 		 * the dynamic assignment of link encoders to streams. Virtual links
392 		 * are not assigned encoder resources on creation.
393 		 */
394 		if (link->link_id.id != CONNECTOR_ID_VIRTUAL && link->eng_id != ENGINE_ID_UNKNOWN) {
395 			link->dc->res_pool->link_encoders[link->eng_id - ENGINE_ID_DIGA] = NULL;
396 			link->dc->res_pool->dig_link_enc_count--;
397 		}
398 		link->link_enc->funcs->destroy(&link->link_enc);
399 	}
400 
401 	if (link->local_sink)
402 		dc_sink_release(link->local_sink);
403 
404 	for (i = 0; i < link->sink_count; ++i)
405 		dc_sink_release(link->remote_sinks[i]);
406 }
407 
get_ddc_line(struct dc_link * link)408 static enum channel_id get_ddc_line(struct dc_link *link)
409 {
410 	struct ddc *ddc;
411 	enum channel_id channel;
412 
413 	channel = CHANNEL_ID_UNKNOWN;
414 
415 	ddc = get_ddc_pin(link->ddc);
416 
417 	if (ddc) {
418 		switch (dal_ddc_get_line(ddc)) {
419 		case GPIO_DDC_LINE_DDC1:
420 			channel = CHANNEL_ID_DDC1;
421 			break;
422 		case GPIO_DDC_LINE_DDC2:
423 			channel = CHANNEL_ID_DDC2;
424 			break;
425 		case GPIO_DDC_LINE_DDC3:
426 			channel = CHANNEL_ID_DDC3;
427 			break;
428 		case GPIO_DDC_LINE_DDC4:
429 			channel = CHANNEL_ID_DDC4;
430 			break;
431 		case GPIO_DDC_LINE_DDC5:
432 			channel = CHANNEL_ID_DDC5;
433 			break;
434 		case GPIO_DDC_LINE_DDC6:
435 			channel = CHANNEL_ID_DDC6;
436 			break;
437 		case GPIO_DDC_LINE_DDC_VGA:
438 			channel = CHANNEL_ID_DDC_VGA;
439 			break;
440 		case GPIO_DDC_LINE_I2C_PAD:
441 			channel = CHANNEL_ID_I2C_PAD;
442 			break;
443 		default:
444 			BREAK_TO_DEBUGGER();
445 			break;
446 		}
447 	}
448 
449 	return channel;
450 }
451 
construct_phy(struct dc_link * link,const struct link_init_data * init_params)452 static bool construct_phy(struct dc_link *link,
453 			      const struct link_init_data *init_params)
454 {
455 	uint8_t i;
456 	struct ddc_service_init_data ddc_service_init_data = { 0 };
457 	struct dc_context *dc_ctx = init_params->ctx;
458 	struct encoder_init_data enc_init_data = { 0 };
459 	struct panel_cntl_init_data panel_cntl_init_data = { 0 };
460 	struct dc_bios *bios = init_params->dc->ctx->dc_bios;
461 	const struct dc_vbios_funcs *bp_funcs = bios->funcs;
462 	struct bp_disp_connector_caps_info disp_connect_caps_info = { 0 };
463 
464 	DC_LOGGER_INIT(dc_ctx->logger);
465 
466 	link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
467 	link->irq_source_hpd_rx = DC_IRQ_SOURCE_INVALID;
468 	link->link_status.dpcd_caps = &link->dpcd_caps;
469 
470 	link->dc = init_params->dc;
471 	link->ctx = dc_ctx;
472 	link->link_index = init_params->link_index;
473 
474 	memset(&link->preferred_training_settings, 0,
475 	       sizeof(struct dc_link_training_overrides));
476 	memset(&link->preferred_link_setting, 0,
477 	       sizeof(struct dc_link_settings));
478 
479 	link->link_id =
480 		bios->funcs->get_connector_id(bios, init_params->connector_index);
481 
482 	link->ep_type = DISPLAY_ENDPOINT_PHY;
483 
484 	DC_LOG_DC("BIOS object table - link_id: %d", link->link_id.id);
485 
486 	if (bios->funcs->get_disp_connector_caps_info) {
487 		bios->funcs->get_disp_connector_caps_info(bios, link->link_id, &disp_connect_caps_info);
488 		link->is_internal_display = disp_connect_caps_info.INTERNAL_DISPLAY;
489 		DC_LOG_DC("BIOS object table - is_internal_display: %d", link->is_internal_display);
490 	}
491 
492 	if (link->link_id.type != OBJECT_TYPE_CONNECTOR) {
493 		dm_output_to_console("%s: Invalid Connector ObjectID from Adapter Service for connector index:%d! type %d expected %d\n",
494 				     __func__, init_params->connector_index,
495 				     link->link_id.type, OBJECT_TYPE_CONNECTOR);
496 		goto create_fail;
497 	}
498 
499 	if (link->dc->res_pool->funcs->link_init)
500 		link->dc->res_pool->funcs->link_init(link);
501 
502 	link->hpd_gpio = link_get_hpd_gpio(link->ctx->dc_bios, link->link_id,
503 				      link->ctx->gpio_service);
504 
505 	if (link->hpd_gpio) {
506 		dal_gpio_open(link->hpd_gpio, GPIO_MODE_INTERRUPT);
507 		dal_gpio_unlock_pin(link->hpd_gpio);
508 		link->irq_source_hpd = dal_irq_get_source(link->hpd_gpio);
509 
510 		DC_LOG_DC("BIOS object table - hpd_gpio id: %d", link->hpd_gpio->id);
511 		DC_LOG_DC("BIOS object table - hpd_gpio en: %d", link->hpd_gpio->en);
512 	}
513 
514 	switch (link->link_id.id) {
515 	case CONNECTOR_ID_HDMI_TYPE_A:
516 		link->connector_signal = SIGNAL_TYPE_HDMI_TYPE_A;
517 
518 		break;
519 	case CONNECTOR_ID_SINGLE_LINK_DVID:
520 	case CONNECTOR_ID_SINGLE_LINK_DVII:
521 		link->connector_signal = SIGNAL_TYPE_DVI_SINGLE_LINK;
522 		break;
523 	case CONNECTOR_ID_DUAL_LINK_DVID:
524 	case CONNECTOR_ID_DUAL_LINK_DVII:
525 		link->connector_signal = SIGNAL_TYPE_DVI_DUAL_LINK;
526 		break;
527 	case CONNECTOR_ID_DISPLAY_PORT:
528 	case CONNECTOR_ID_MXM:
529 	case CONNECTOR_ID_USBC:
530 		link->connector_signal = SIGNAL_TYPE_DISPLAY_PORT;
531 
532 		if (link->hpd_gpio)
533 			link->irq_source_hpd_rx =
534 					dal_irq_get_rx_source(link->hpd_gpio);
535 
536 		break;
537 	case CONNECTOR_ID_EDP:
538 		link->connector_signal = SIGNAL_TYPE_EDP;
539 
540 		if (link->hpd_gpio) {
541 			if (!link->dc->config.allow_edp_hotplug_detection)
542 				link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
543 
544 			switch (link->dc->config.allow_edp_hotplug_detection) {
545 			case HPD_EN_FOR_ALL_EDP:
546 				link->irq_source_hpd_rx =
547 						dal_irq_get_rx_source(link->hpd_gpio);
548 				break;
549 			case HPD_EN_FOR_PRIMARY_EDP_ONLY:
550 				if (link->link_index == 0)
551 					link->irq_source_hpd_rx =
552 						dal_irq_get_rx_source(link->hpd_gpio);
553 				else
554 					link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
555 				break;
556 			case HPD_EN_FOR_SECONDARY_EDP_ONLY:
557 				if (link->link_index == 1)
558 					link->irq_source_hpd_rx =
559 						dal_irq_get_rx_source(link->hpd_gpio);
560 				else
561 					link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
562 				break;
563 			default:
564 				link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
565 				break;
566 			}
567 		}
568 
569 		break;
570 	case CONNECTOR_ID_LVDS:
571 		link->connector_signal = SIGNAL_TYPE_LVDS;
572 		break;
573 	default:
574 		DC_LOG_WARNING("Unsupported Connector type:%d!\n",
575 			       link->link_id.id);
576 		goto create_fail;
577 	}
578 
579 	LINK_INFO("Connector[%d] description: signal: %s\n",
580 		  init_params->connector_index,
581 		  signal_type_to_string(link->connector_signal));
582 
583 	ddc_service_init_data.ctx = link->ctx;
584 	ddc_service_init_data.id = link->link_id;
585 	ddc_service_init_data.link = link;
586 	link->ddc = link_create_ddc_service(&ddc_service_init_data);
587 
588 	if (!link->ddc) {
589 		DC_ERROR("Failed to create ddc_service!\n");
590 		goto ddc_create_fail;
591 	}
592 
593 	if (!link->ddc->ddc_pin) {
594 		DC_ERROR("Failed to get I2C info for connector!\n");
595 		goto ddc_create_fail;
596 	}
597 
598 	link->ddc_hw_inst =
599 		dal_ddc_get_line(get_ddc_pin(link->ddc));
600 
601 	enc_init_data.ctx = dc_ctx;
602 	bp_funcs->get_src_obj(dc_ctx->dc_bios, link->link_id, 0,
603 			      &enc_init_data.encoder);
604 	enc_init_data.connector = link->link_id;
605 	enc_init_data.channel = get_ddc_line(link);
606 	enc_init_data.hpd_source = get_hpd_line(link);
607 
608 	link->hpd_src = enc_init_data.hpd_source;
609 
610 	enc_init_data.transmitter =
611 		translate_encoder_to_transmitter(enc_init_data.encoder);
612 	link->link_enc =
613 		link->dc->res_pool->funcs->link_enc_create(dc_ctx, &enc_init_data);
614 
615 	if (!link->link_enc) {
616 		DC_ERROR("Failed to create link encoder!\n");
617 		goto link_enc_create_fail;
618 	}
619 
620 	DC_LOG_DC("BIOS object table - DP_IS_USB_C: %d", link->link_enc->features.flags.bits.DP_IS_USB_C);
621 	DC_LOG_DC("BIOS object table - IS_DP2_CAPABLE: %d", link->link_enc->features.flags.bits.IS_DP2_CAPABLE);
622 
623 	/* Update link encoder tracking variables. These are used for the dynamic
624 	 * assignment of link encoders to streams.
625 	 */
626 	link->eng_id = link->link_enc->preferred_engine;
627 	link->dc->res_pool->link_encoders[link->eng_id - ENGINE_ID_DIGA] = link->link_enc;
628 	link->dc->res_pool->dig_link_enc_count++;
629 
630 	link->link_enc_hw_inst = link->link_enc->transmitter;
631 
632 	if (link->dc->res_pool->funcs->panel_cntl_create &&
633 		(link->link_id.id == CONNECTOR_ID_EDP ||
634 			link->link_id.id == CONNECTOR_ID_LVDS)) {
635 		panel_cntl_init_data.ctx = dc_ctx;
636 		panel_cntl_init_data.inst = panel_cntl_init_data.ctx->dc_edp_id_count;
637 		panel_cntl_init_data.eng_id = link->eng_id;
638 		link->panel_cntl =
639 			link->dc->res_pool->funcs->panel_cntl_create(
640 								&panel_cntl_init_data);
641 		panel_cntl_init_data.ctx->dc_edp_id_count++;
642 
643 		if (link->panel_cntl == NULL) {
644 			DC_ERROR("Failed to create link panel_cntl!\n");
645 			goto panel_cntl_create_fail;
646 		}
647 	}
648 	for (i = 0; i < 4; i++) {
649 		if (bp_funcs->get_device_tag(dc_ctx->dc_bios,
650 					     link->link_id, i,
651 					     &link->device_tag) != BP_RESULT_OK) {
652 			DC_ERROR("Failed to find device tag!\n");
653 			goto device_tag_fail;
654 		}
655 
656 		/* Look for device tag that matches connector signal,
657 		 * CRT for rgb, LCD for other supported signal tyes
658 		 */
659 		if (!bp_funcs->is_device_id_supported(dc_ctx->dc_bios,
660 						      link->device_tag.dev_id))
661 			continue;
662 		if (link->device_tag.dev_id.device_type == DEVICE_TYPE_CRT &&
663 		    link->connector_signal != SIGNAL_TYPE_RGB)
664 			continue;
665 		if (link->device_tag.dev_id.device_type == DEVICE_TYPE_LCD &&
666 		    link->connector_signal == SIGNAL_TYPE_RGB)
667 			continue;
668 
669 		DC_LOG_DC("BIOS object table - device_tag.acpi_device: %d", link->device_tag.acpi_device);
670 		DC_LOG_DC("BIOS object table - device_tag.dev_id.device_type: %d", link->device_tag.dev_id.device_type);
671 		DC_LOG_DC("BIOS object table - device_tag.dev_id.enum_id: %d", link->device_tag.dev_id.enum_id);
672 		break;
673 	}
674 
675 	if (bios->integrated_info) {
676 		/* Look for channel mapping corresponding to connector and device tag */
677 		for (i = 0; i < MAX_NUMBER_OF_EXT_DISPLAY_PATH; i++) {
678 			struct external_display_path *path =
679 				&bios->integrated_info->ext_disp_conn_info.path[i];
680 
681 			if (path->device_connector_id.enum_id == link->link_id.enum_id &&
682 			    path->device_connector_id.id == link->link_id.id &&
683 			    path->device_connector_id.type == link->link_id.type) {
684 				if (link->device_tag.acpi_device != 0 &&
685 				    path->device_acpi_enum == link->device_tag.acpi_device) {
686 					link->ddi_channel_mapping = path->channel_mapping;
687 					link->chip_caps = path->caps;
688 					DC_LOG_DC("BIOS object table - ddi_channel_mapping: 0x%04X",
689 						  link->ddi_channel_mapping.raw);
690 					DC_LOG_DC("BIOS object table - chip_caps: %d",
691 						  link->chip_caps);
692 				} else if (path->device_tag ==
693 					   link->device_tag.dev_id.raw_device_tag) {
694 					link->ddi_channel_mapping = path->channel_mapping;
695 					link->chip_caps = path->caps;
696 					DC_LOG_DC("BIOS object table - ddi_channel_mapping: 0x%04X",
697 						  link->ddi_channel_mapping.raw);
698 					DC_LOG_DC("BIOS object table - chip_caps: %d",
699 						  link->chip_caps);
700 				}
701 
702 				if ((link->chip_caps & AMD_EXT_DISPLAY_PATH_CAPS__EXT_CHIP_MASK) == AMD_EXT_DISPLAY_PATH_CAPS__DP_FIXED_VS_EN) {
703 					link->bios_forced_drive_settings.VOLTAGE_SWING =
704 						(bios->integrated_info->ext_disp_conn_info.fixdpvoltageswing & 0x3);
705 					link->bios_forced_drive_settings.PRE_EMPHASIS =
706 						((bios->integrated_info->ext_disp_conn_info.fixdpvoltageswing >> 2) & 0x3);
707 				}
708 
709 				break;
710 			}
711 		}
712 	}
713 	if (bios->funcs->get_atom_dc_golden_table)
714 		bios->funcs->get_atom_dc_golden_table(bios);
715 
716 	/*
717 	 * TODO check if GPIO programmed correctly
718 	 *
719 	 * If GPIO isn't programmed correctly HPD might not rise or drain
720 	 * fast enough, leading to bounces.
721 	 */
722 	program_hpd_filter(link);
723 
724 	link->psr_settings.psr_vtotal_control_support = false;
725 	link->psr_settings.psr_version = DC_PSR_VERSION_UNSUPPORTED;
726 
727 	DC_LOG_DC("BIOS object table - %s finished successfully.\n", __func__);
728 	return true;
729 device_tag_fail:
730 	link->link_enc->funcs->destroy(&link->link_enc);
731 link_enc_create_fail:
732 	if (link->panel_cntl != NULL)
733 		link->panel_cntl->funcs->destroy(&link->panel_cntl);
734 panel_cntl_create_fail:
735 	link_destroy_ddc_service(&link->ddc);
736 ddc_create_fail:
737 create_fail:
738 
739 	if (link->hpd_gpio) {
740 		dal_gpio_destroy_irq(&link->hpd_gpio);
741 		link->hpd_gpio = NULL;
742 	}
743 
744 	DC_LOG_DC("BIOS object table - %s failed.\n", __func__);
745 	return false;
746 }
747 
construct_dpia(struct dc_link * link,const struct link_init_data * init_params)748 static bool construct_dpia(struct dc_link *link,
749 			      const struct link_init_data *init_params)
750 {
751 	struct ddc_service_init_data ddc_service_init_data = { 0 };
752 	struct dc_context *dc_ctx = init_params->ctx;
753 
754 	DC_LOGGER_INIT(dc_ctx->logger);
755 
756 	/* Initialized irq source for hpd and hpd rx */
757 	link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
758 	link->irq_source_hpd_rx = DC_IRQ_SOURCE_INVALID;
759 	link->link_status.dpcd_caps = &link->dpcd_caps;
760 
761 	link->dc = init_params->dc;
762 	link->ctx = dc_ctx;
763 	link->link_index = init_params->link_index;
764 
765 	memset(&link->preferred_training_settings, 0,
766 	       sizeof(struct dc_link_training_overrides));
767 	memset(&link->preferred_link_setting, 0,
768 	       sizeof(struct dc_link_settings));
769 
770 	/* Dummy Init for linkid */
771 	link->link_id.type = OBJECT_TYPE_CONNECTOR;
772 	link->link_id.id = CONNECTOR_ID_DISPLAY_PORT;
773 	link->link_id.enum_id = ENUM_ID_1 + init_params->connector_index;
774 	link->is_internal_display = false;
775 	link->connector_signal = SIGNAL_TYPE_DISPLAY_PORT;
776 	LINK_INFO("Connector[%d] description:signal %d\n",
777 		  init_params->connector_index,
778 		  link->connector_signal);
779 
780 	link->ep_type = DISPLAY_ENDPOINT_USB4_DPIA;
781 	link->is_dig_mapping_flexible = true;
782 
783 	/* TODO: Initialize link : funcs->link_init */
784 
785 	ddc_service_init_data.ctx = link->ctx;
786 	ddc_service_init_data.id = link->link_id;
787 	ddc_service_init_data.link = link;
788 	/* Set indicator for dpia link so that ddc wont be created */
789 	ddc_service_init_data.is_dpia_link = true;
790 
791 	link->ddc = link_create_ddc_service(&ddc_service_init_data);
792 	if (!link->ddc) {
793 		DC_ERROR("Failed to create ddc_service!\n");
794 		goto ddc_create_fail;
795 	}
796 
797 	/* Set dpia port index : 0 to number of dpia ports */
798 	link->ddc_hw_inst = init_params->connector_index;
799 
800 	// Assign Dpia preferred eng_id
801 	if (link->dc->res_pool->funcs->get_preferred_eng_id_dpia)
802 		link->dpia_preferred_eng_id = link->dc->res_pool->funcs->get_preferred_eng_id_dpia(link->ddc_hw_inst);
803 
804 	/* TODO: Create link encoder */
805 
806 	link->psr_settings.psr_version = DC_PSR_VERSION_UNSUPPORTED;
807 
808 	/* Some docks seem to NAK I2C writes to segment pointer with mot=0. */
809 	link->wa_flags.dp_mot_reset_segment = true;
810 
811 	return true;
812 
813 ddc_create_fail:
814 	return false;
815 }
816 
link_construct(struct dc_link * link,const struct link_init_data * init_params)817 static bool link_construct(struct dc_link *link,
818 			      const struct link_init_data *init_params)
819 {
820 	/* Handle dpia case */
821 	if (init_params->is_dpia_link == true)
822 		return construct_dpia(link, init_params);
823 	else
824 		return construct_phy(link, init_params);
825 }
826 
link_create(const struct link_init_data * init_params)827 struct dc_link *link_create(const struct link_init_data *init_params)
828 {
829 	struct dc_link *link =
830 			kzalloc(sizeof(*link), GFP_KERNEL);
831 
832 	if (NULL == link)
833 		goto alloc_fail;
834 
835 	if (false == link_construct(link, init_params))
836 		goto construct_fail;
837 
838 	return link;
839 
840 construct_fail:
841 	kfree(link);
842 
843 alloc_fail:
844 	return NULL;
845 }
846 
link_destroy(struct dc_link ** link)847 void link_destroy(struct dc_link **link)
848 {
849 	link_destruct(*link);
850 	kfree(*link);
851 	*link = NULL;
852 }
853