dp_drm.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
  4. */
  5. #include <drm/drm_atomic_helper.h>
  6. #include <drm/drm_atomic.h>
  7. #include <drm/drm_crtc.h>
  8. #include "msm_drv.h"
  9. #include "msm_kms.h"
  10. #include "sde_connector.h"
  11. #include "dp_drm.h"
  12. #include "dp_mst_drm.h"
  13. #include "dp_debug.h"
  14. #define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
  15. #define to_dp_bridge(x) container_of((x), struct dp_bridge, base)
  16. void convert_to_drm_mode(const struct dp_display_mode *dp_mode,
  17. struct drm_display_mode *drm_mode)
  18. {
  19. u32 flags = 0;
  20. memset(drm_mode, 0, sizeof(*drm_mode));
  21. drm_mode->hdisplay = dp_mode->timing.h_active;
  22. drm_mode->hsync_start = drm_mode->hdisplay +
  23. dp_mode->timing.h_front_porch;
  24. drm_mode->hsync_end = drm_mode->hsync_start +
  25. dp_mode->timing.h_sync_width;
  26. drm_mode->htotal = drm_mode->hsync_end + dp_mode->timing.h_back_porch;
  27. drm_mode->hskew = dp_mode->timing.h_skew;
  28. drm_mode->vdisplay = dp_mode->timing.v_active;
  29. drm_mode->vsync_start = drm_mode->vdisplay +
  30. dp_mode->timing.v_front_porch;
  31. drm_mode->vsync_end = drm_mode->vsync_start +
  32. dp_mode->timing.v_sync_width;
  33. drm_mode->vtotal = drm_mode->vsync_end + dp_mode->timing.v_back_porch;
  34. drm_mode->vrefresh = dp_mode->timing.refresh_rate;
  35. drm_mode->clock = dp_mode->timing.pixel_clk_khz;
  36. if (dp_mode->timing.h_active_low)
  37. flags |= DRM_MODE_FLAG_NHSYNC;
  38. else
  39. flags |= DRM_MODE_FLAG_PHSYNC;
  40. if (dp_mode->timing.v_active_low)
  41. flags |= DRM_MODE_FLAG_NVSYNC;
  42. else
  43. flags |= DRM_MODE_FLAG_PVSYNC;
  44. drm_mode->flags = flags;
  45. drm_mode->type = 0x48;
  46. drm_mode_set_name(drm_mode);
  47. }
  48. static int dp_bridge_attach(struct drm_bridge *dp_bridge)
  49. {
  50. struct dp_bridge *bridge = to_dp_bridge(dp_bridge);
  51. if (!dp_bridge) {
  52. DP_ERR("Invalid params\n");
  53. return -EINVAL;
  54. }
  55. DP_DEBUG("[%d] attached\n", bridge->id);
  56. return 0;
  57. }
  58. static void dp_bridge_pre_enable(struct drm_bridge *drm_bridge)
  59. {
  60. int rc = 0;
  61. struct dp_bridge *bridge;
  62. struct dp_display *dp;
  63. if (!drm_bridge) {
  64. DP_ERR("Invalid params\n");
  65. return;
  66. }
  67. bridge = to_dp_bridge(drm_bridge);
  68. dp = bridge->display;
  69. if (!bridge->connector) {
  70. DP_ERR("Invalid connector\n");
  71. return;
  72. }
  73. if (!bridge->dp_panel) {
  74. DP_ERR("Invalid dp_panel\n");
  75. return;
  76. }
  77. /* By this point mode should have been validated through mode_fixup */
  78. rc = dp->set_mode(dp, bridge->dp_panel, &bridge->dp_mode);
  79. if (rc) {
  80. DP_ERR("[%d] failed to perform a mode set, rc=%d\n",
  81. bridge->id, rc);
  82. return;
  83. }
  84. rc = dp->prepare(dp, bridge->dp_panel);
  85. if (rc) {
  86. DP_ERR("[%d] DP display prepare failed, rc=%d\n",
  87. bridge->id, rc);
  88. return;
  89. }
  90. /* for SST force stream id, start slot and total slots to 0 */
  91. dp->set_stream_info(dp, bridge->dp_panel, 0, 0, 0, 0, 0);
  92. rc = dp->enable(dp, bridge->dp_panel);
  93. if (rc)
  94. DP_ERR("[%d] DP display enable failed, rc=%d\n",
  95. bridge->id, rc);
  96. }
  97. static void dp_bridge_enable(struct drm_bridge *drm_bridge)
  98. {
  99. int rc = 0;
  100. struct dp_bridge *bridge;
  101. struct dp_display *dp;
  102. if (!drm_bridge) {
  103. DP_ERR("Invalid params\n");
  104. return;
  105. }
  106. bridge = to_dp_bridge(drm_bridge);
  107. if (!bridge->connector) {
  108. DP_ERR("Invalid connector\n");
  109. return;
  110. }
  111. if (!bridge->dp_panel) {
  112. DP_ERR("Invalid dp_panel\n");
  113. return;
  114. }
  115. dp = bridge->display;
  116. rc = dp->post_enable(dp, bridge->dp_panel);
  117. if (rc)
  118. DP_ERR("[%d] DP display post enable failed, rc=%d\n",
  119. bridge->id, rc);
  120. }
  121. static void dp_bridge_disable(struct drm_bridge *drm_bridge)
  122. {
  123. int rc = 0;
  124. struct dp_bridge *bridge;
  125. struct dp_display *dp;
  126. if (!drm_bridge) {
  127. DP_ERR("Invalid params\n");
  128. return;
  129. }
  130. bridge = to_dp_bridge(drm_bridge);
  131. if (!bridge->connector) {
  132. DP_ERR("Invalid connector\n");
  133. return;
  134. }
  135. if (!bridge->dp_panel) {
  136. DP_ERR("Invalid dp_panel\n");
  137. return;
  138. }
  139. dp = bridge->display;
  140. if (!dp) {
  141. DP_ERR("dp is null\n");
  142. return;
  143. }
  144. if (dp)
  145. sde_connector_helper_bridge_disable(bridge->connector);
  146. rc = dp->pre_disable(dp, bridge->dp_panel);
  147. if (rc) {
  148. DP_ERR("[%d] DP display pre disable failed, rc=%d\n",
  149. bridge->id, rc);
  150. }
  151. }
  152. static void dp_bridge_post_disable(struct drm_bridge *drm_bridge)
  153. {
  154. int rc = 0;
  155. struct dp_bridge *bridge;
  156. struct dp_display *dp;
  157. if (!drm_bridge) {
  158. DP_ERR("Invalid params\n");
  159. return;
  160. }
  161. bridge = to_dp_bridge(drm_bridge);
  162. if (!bridge->connector) {
  163. DP_ERR("Invalid connector\n");
  164. return;
  165. }
  166. if (!bridge->dp_panel) {
  167. DP_ERR("Invalid dp_panel\n");
  168. return;
  169. }
  170. dp = bridge->display;
  171. rc = dp->disable(dp, bridge->dp_panel);
  172. if (rc) {
  173. DP_ERR("[%d] DP display disable failed, rc=%d\n",
  174. bridge->id, rc);
  175. return;
  176. }
  177. rc = dp->unprepare(dp, bridge->dp_panel);
  178. if (rc) {
  179. DP_ERR("[%d] DP display unprepare failed, rc=%d\n",
  180. bridge->id, rc);
  181. return;
  182. }
  183. }
  184. static void dp_bridge_mode_set(struct drm_bridge *drm_bridge,
  185. const struct drm_display_mode *mode,
  186. const struct drm_display_mode *adjusted_mode)
  187. {
  188. struct dp_bridge *bridge;
  189. struct dp_display *dp;
  190. if (!drm_bridge || !mode || !adjusted_mode) {
  191. DP_ERR("Invalid params\n");
  192. return;
  193. }
  194. bridge = to_dp_bridge(drm_bridge);
  195. if (!bridge->connector) {
  196. DP_ERR("Invalid connector\n");
  197. return;
  198. }
  199. if (!bridge->dp_panel) {
  200. DP_ERR("Invalid dp_panel\n");
  201. return;
  202. }
  203. dp = bridge->display;
  204. dp->convert_to_dp_mode(dp, bridge->dp_panel, adjusted_mode,
  205. &bridge->dp_mode);
  206. }
  207. static bool dp_bridge_mode_fixup(struct drm_bridge *drm_bridge,
  208. const struct drm_display_mode *mode,
  209. struct drm_display_mode *adjusted_mode)
  210. {
  211. bool ret = true;
  212. struct dp_display_mode dp_mode;
  213. struct dp_bridge *bridge;
  214. struct dp_display *dp;
  215. if (!drm_bridge || !mode || !adjusted_mode) {
  216. DP_ERR("Invalid params\n");
  217. ret = false;
  218. goto end;
  219. }
  220. bridge = to_dp_bridge(drm_bridge);
  221. if (!bridge->connector) {
  222. DP_ERR("Invalid connector\n");
  223. ret = false;
  224. goto end;
  225. }
  226. if (!bridge->dp_panel) {
  227. DP_ERR("Invalid dp_panel\n");
  228. ret = false;
  229. goto end;
  230. }
  231. dp = bridge->display;
  232. dp->convert_to_dp_mode(dp, bridge->dp_panel, mode, &dp_mode);
  233. convert_to_drm_mode(&dp_mode, adjusted_mode);
  234. end:
  235. return ret;
  236. }
  237. static const struct drm_bridge_funcs dp_bridge_ops = {
  238. .attach = dp_bridge_attach,
  239. .mode_fixup = dp_bridge_mode_fixup,
  240. .pre_enable = dp_bridge_pre_enable,
  241. .enable = dp_bridge_enable,
  242. .disable = dp_bridge_disable,
  243. .post_disable = dp_bridge_post_disable,
  244. .mode_set = dp_bridge_mode_set,
  245. };
  246. int dp_connector_config_hdr(struct drm_connector *connector, void *display,
  247. struct sde_connector_state *c_state)
  248. {
  249. struct dp_display *dp = display;
  250. struct sde_connector *sde_conn;
  251. if (!display || !c_state || !connector) {
  252. DP_ERR("invalid params\n");
  253. return -EINVAL;
  254. }
  255. sde_conn = to_sde_connector(connector);
  256. if (!sde_conn->drv_panel) {
  257. DP_ERR("invalid dp panel\n");
  258. return -EINVAL;
  259. }
  260. return dp->config_hdr(dp, sde_conn->drv_panel, &c_state->hdr_meta,
  261. c_state->dyn_hdr_meta.dynamic_hdr_update);
  262. }
  263. int dp_connector_set_colorspace(struct drm_connector *connector,
  264. void *display)
  265. {
  266. struct dp_display *dp_display = display;
  267. struct sde_connector *sde_conn;
  268. if (!dp_display || !connector)
  269. return -EINVAL;
  270. sde_conn = to_sde_connector(connector);
  271. if (!sde_conn->drv_panel) {
  272. pr_err("invalid dp panel\n");
  273. return -EINVAL;
  274. }
  275. return dp_display->set_colorspace(dp_display,
  276. sde_conn->drv_panel, connector->state->colorspace);
  277. }
  278. int dp_connector_post_init(struct drm_connector *connector, void *display)
  279. {
  280. int rc;
  281. struct dp_display *dp_display = display;
  282. struct sde_connector *sde_conn;
  283. if (!dp_display || !connector)
  284. return -EINVAL;
  285. dp_display->base_connector = connector;
  286. dp_display->bridge->connector = connector;
  287. if (dp_display->post_init) {
  288. rc = dp_display->post_init(dp_display);
  289. if (rc)
  290. goto end;
  291. }
  292. sde_conn = to_sde_connector(connector);
  293. dp_display->bridge->dp_panel = sde_conn->drv_panel;
  294. rc = dp_mst_init(dp_display);
  295. end:
  296. return rc;
  297. }
  298. int dp_connector_get_mode_info(struct drm_connector *connector,
  299. const struct drm_display_mode *drm_mode,
  300. struct msm_mode_info *mode_info,
  301. void *display, const struct msm_resource_caps_info *avail_res)
  302. {
  303. const u32 single_intf = 1;
  304. const u32 no_enc = 0;
  305. struct msm_display_topology *topology;
  306. struct sde_connector *sde_conn;
  307. struct dp_panel *dp_panel;
  308. struct dp_display_mode dp_mode;
  309. struct dp_display *dp_disp = display;
  310. struct msm_drm_private *priv;
  311. struct msm_resource_caps_info avail_dp_res;
  312. int rc = 0;
  313. if (!drm_mode || !mode_info || !avail_res ||
  314. !avail_res->max_mixer_width || !connector || !display ||
  315. !connector->dev || !connector->dev->dev_private) {
  316. DP_ERR("invalid params\n");
  317. return -EINVAL;
  318. }
  319. memset(mode_info, 0, sizeof(*mode_info));
  320. sde_conn = to_sde_connector(connector);
  321. dp_panel = sde_conn->drv_panel;
  322. priv = connector->dev->dev_private;
  323. topology = &mode_info->topology;
  324. rc = dp_disp->get_available_dp_resources(dp_disp, avail_res,
  325. &avail_dp_res);
  326. if (rc) {
  327. DP_ERR("error getting max dp resources. rc:%d\n", rc);
  328. return rc;
  329. }
  330. rc = msm_get_mixer_count(priv, drm_mode, &avail_dp_res,
  331. &topology->num_lm);
  332. if (rc) {
  333. DP_ERR("error getting mixer count. rc:%d\n", rc);
  334. return rc;
  335. }
  336. topology->num_enc = no_enc;
  337. topology->num_intf = single_intf;
  338. mode_info->frame_rate = drm_mode->vrefresh;
  339. mode_info->vtotal = drm_mode->vtotal;
  340. mode_info->wide_bus_en = dp_panel->widebus_en;
  341. dp_disp->convert_to_dp_mode(dp_disp, dp_panel, drm_mode, &dp_mode);
  342. if (dp_mode.timing.comp_info.comp_ratio > 1) {
  343. memcpy(&mode_info->comp_info,
  344. &dp_mode.timing.comp_info,
  345. sizeof(mode_info->comp_info));
  346. topology->num_enc = topology->num_lm;
  347. topology->comp_type = mode_info->comp_info.comp_type;
  348. }
  349. return 0;
  350. }
  351. int dp_connector_get_info(struct drm_connector *connector,
  352. struct msm_display_info *info, void *data)
  353. {
  354. struct dp_display *display = data;
  355. if (!info || !display || !display->drm_dev) {
  356. DP_ERR("invalid params\n");
  357. return -EINVAL;
  358. }
  359. info->intf_type = DRM_MODE_CONNECTOR_DisplayPort;
  360. info->num_of_h_tiles = 1;
  361. info->h_tile_instance[0] = 0;
  362. info->is_connected = display->is_sst_connected;
  363. info->capabilities = MSM_DISPLAY_CAP_VID_MODE | MSM_DISPLAY_CAP_EDID |
  364. MSM_DISPLAY_CAP_HOT_PLUG;
  365. return 0;
  366. }
  367. enum drm_connector_status dp_connector_detect(struct drm_connector *conn,
  368. bool force,
  369. void *display)
  370. {
  371. enum drm_connector_status status = connector_status_unknown;
  372. struct msm_display_info info;
  373. int rc;
  374. if (!conn || !display)
  375. return status;
  376. /* get display dp_info */
  377. memset(&info, 0x0, sizeof(info));
  378. rc = dp_connector_get_info(conn, &info, display);
  379. if (rc) {
  380. DP_ERR("failed to get display info, rc=%d\n", rc);
  381. return connector_status_disconnected;
  382. }
  383. if (info.capabilities & MSM_DISPLAY_CAP_HOT_PLUG)
  384. status = (info.is_connected ? connector_status_connected :
  385. connector_status_disconnected);
  386. else
  387. status = connector_status_connected;
  388. conn->display_info.width_mm = info.width_mm;
  389. conn->display_info.height_mm = info.height_mm;
  390. return status;
  391. }
  392. void dp_connector_post_open(struct drm_connector *connector, void *display)
  393. {
  394. struct dp_display *dp;
  395. if (!display) {
  396. DP_ERR("invalid input\n");
  397. return;
  398. }
  399. dp = display;
  400. if (dp->post_open)
  401. dp->post_open(dp);
  402. }
  403. int dp_connector_atomic_check(struct drm_connector *connector,
  404. void *display,
  405. struct drm_atomic_state *a_state)
  406. {
  407. struct sde_connector *sde_conn;
  408. struct drm_connector_state *old_state;
  409. struct drm_connector_state *c_state;
  410. if (!connector || !display || !a_state)
  411. return -EINVAL;
  412. c_state = drm_atomic_get_new_connector_state(a_state, connector);
  413. old_state =
  414. drm_atomic_get_old_connector_state(a_state, connector);
  415. if (!old_state || !c_state)
  416. return -EINVAL;
  417. sde_conn = to_sde_connector(connector);
  418. /*
  419. * Marking the colorspace has been changed
  420. * the flag shall be checked in the pre_kickoff
  421. * to configure the new colorspace in HW
  422. */
  423. if (c_state->colorspace != old_state->colorspace) {
  424. DP_DEBUG("colorspace has been updated\n");
  425. sde_conn->colorspace_updated = true;
  426. }
  427. return 0;
  428. }
  429. int dp_connector_get_modes(struct drm_connector *connector,
  430. void *display, const struct msm_resource_caps_info *avail_res)
  431. {
  432. int rc = 0;
  433. struct dp_display *dp;
  434. struct dp_display_mode *dp_mode = NULL;
  435. struct drm_display_mode *m, drm_mode;
  436. struct sde_connector *sde_conn;
  437. if (!connector || !display)
  438. return 0;
  439. sde_conn = to_sde_connector(connector);
  440. if (!sde_conn->drv_panel) {
  441. DP_ERR("invalid dp panel\n");
  442. return 0;
  443. }
  444. dp = display;
  445. dp_mode = kzalloc(sizeof(*dp_mode), GFP_KERNEL);
  446. if (!dp_mode)
  447. return 0;
  448. /* pluggable case assumes EDID is read when HPD */
  449. if (dp->is_sst_connected) {
  450. rc = dp->get_modes(dp, sde_conn->drv_panel, dp_mode);
  451. if (!rc)
  452. DP_ERR("failed to get DP sink modes, rc=%d\n", rc);
  453. if (dp_mode->timing.pixel_clk_khz) { /* valid DP mode */
  454. memset(&drm_mode, 0x0, sizeof(drm_mode));
  455. convert_to_drm_mode(dp_mode, &drm_mode);
  456. m = drm_mode_duplicate(connector->dev, &drm_mode);
  457. if (!m) {
  458. DP_ERR("failed to add mode %ux%u\n",
  459. drm_mode.hdisplay,
  460. drm_mode.vdisplay);
  461. kfree(dp_mode);
  462. return 0;
  463. }
  464. m->width_mm = connector->display_info.width_mm;
  465. m->height_mm = connector->display_info.height_mm;
  466. drm_mode_probed_add(connector, m);
  467. }
  468. } else {
  469. DP_ERR("No sink connected\n");
  470. }
  471. kfree(dp_mode);
  472. return rc;
  473. }
  474. int dp_drm_bridge_init(void *data, struct drm_encoder *encoder,
  475. u32 max_mixer_count, u32 max_dsc_count)
  476. {
  477. int rc = 0;
  478. struct dp_bridge *bridge;
  479. struct drm_device *dev;
  480. struct dp_display *display = data;
  481. struct msm_drm_private *priv = NULL;
  482. bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
  483. if (!bridge) {
  484. rc = -ENOMEM;
  485. goto error;
  486. }
  487. dev = display->drm_dev;
  488. bridge->display = display;
  489. bridge->base.funcs = &dp_bridge_ops;
  490. bridge->base.encoder = encoder;
  491. priv = dev->dev_private;
  492. rc = drm_bridge_attach(encoder, &bridge->base, NULL);
  493. if (rc) {
  494. DP_ERR("failed to attach bridge, rc=%d\n", rc);
  495. goto error_free_bridge;
  496. }
  497. rc = display->request_irq(display);
  498. if (rc) {
  499. DP_ERR("request_irq failed, rc=%d\n", rc);
  500. goto error_free_bridge;
  501. }
  502. encoder->bridge = &bridge->base;
  503. priv->bridges[priv->num_bridges++] = &bridge->base;
  504. display->bridge = bridge;
  505. display->max_mixer_count = max_mixer_count;
  506. display->max_dsc_count = max_dsc_count;
  507. return 0;
  508. error_free_bridge:
  509. kfree(bridge);
  510. error:
  511. return rc;
  512. }
  513. void dp_drm_bridge_deinit(void *data)
  514. {
  515. struct dp_display *display = data;
  516. struct dp_bridge *bridge = display->bridge;
  517. if (bridge && bridge->base.encoder)
  518. bridge->base.encoder->bridge = NULL;
  519. kfree(bridge);
  520. }
  521. enum drm_mode_status dp_connector_mode_valid(struct drm_connector *connector,
  522. struct drm_display_mode *mode, void *display,
  523. const struct msm_resource_caps_info *avail_res)
  524. {
  525. int rc = 0;
  526. struct dp_display *dp_disp;
  527. struct sde_connector *sde_conn;
  528. struct msm_resource_caps_info avail_dp_res;
  529. if (!mode || !display || !connector) {
  530. DP_ERR("invalid params\n");
  531. return MODE_ERROR;
  532. }
  533. sde_conn = to_sde_connector(connector);
  534. if (!sde_conn->drv_panel) {
  535. DP_ERR("invalid dp panel\n");
  536. return MODE_ERROR;
  537. }
  538. dp_disp = display;
  539. mode->vrefresh = drm_mode_vrefresh(mode);
  540. rc = dp_disp->get_available_dp_resources(dp_disp, avail_res,
  541. &avail_dp_res);
  542. if (rc) {
  543. DP_ERR("error getting max dp resources. rc:%d\n", rc);
  544. return MODE_ERROR;
  545. }
  546. return dp_disp->validate_mode(dp_disp, sde_conn->drv_panel,
  547. mode, &avail_dp_res);
  548. }
  549. int dp_connector_update_pps(struct drm_connector *connector,
  550. char *pps_cmd, void *display)
  551. {
  552. struct dp_display *dp_disp;
  553. struct sde_connector *sde_conn;
  554. if (!display || !connector) {
  555. DP_ERR("invalid params\n");
  556. return -EINVAL;
  557. }
  558. sde_conn = to_sde_connector(connector);
  559. if (!sde_conn->drv_panel) {
  560. DP_ERR("invalid dp panel\n");
  561. return MODE_ERROR;
  562. }
  563. dp_disp = display;
  564. return dp_disp->update_pps(dp_disp, connector, pps_cmd);
  565. }
  566. int dp_connector_install_properties(void *display, struct drm_connector *conn)
  567. {
  568. struct dp_display *dp_display = display;
  569. struct drm_connector *base_conn;
  570. int rc;
  571. if (!display || !conn) {
  572. DP_ERR("invalid params\n");
  573. return -EINVAL;
  574. }
  575. base_conn = dp_display->base_connector;
  576. /*
  577. * Create the property on the base connector during probe time and then
  578. * attach the same property onto new connector objects created for MST
  579. */
  580. if (!base_conn->colorspace_property) {
  581. /* This is the base connector. create the drm property */
  582. rc = drm_mode_create_dp_colorspace_property(base_conn);
  583. if (rc)
  584. return rc;
  585. } else {
  586. conn->colorspace_property = base_conn->colorspace_property;
  587. }
  588. drm_object_attach_property(&conn->base, conn->colorspace_property, 0);
  589. return 0;
  590. }