dp_drm.c 15 KB

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