dsi_drm.c 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
  4. * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
  5. */
  6. #include <drm/drm_atomic_helper.h>
  7. #include <drm/drm_atomic.h>
  8. #include "msm_kms.h"
  9. #include "sde_connector.h"
  10. #include "dsi_drm.h"
  11. #include "sde_trace.h"
  12. #include "sde_dbg.h"
  13. #include "msm_drv.h"
  14. #include "sde_encoder.h"
  15. #define to_dsi_bridge(x) container_of((x), struct dsi_bridge, base)
  16. #define to_dsi_state(x) container_of((x), struct dsi_connector_state, base)
  17. #define DEFAULT_PANEL_JITTER_NUMERATOR 2
  18. #define DEFAULT_PANEL_JITTER_DENOMINATOR 1
  19. #define DEFAULT_PANEL_JITTER_ARRAY_SIZE 2
  20. #define DEFAULT_PANEL_PREFILL_LINES 25
  21. static struct dsi_display_mode_priv_info default_priv_info = {
  22. .panel_jitter_numer = DEFAULT_PANEL_JITTER_NUMERATOR,
  23. .panel_jitter_denom = DEFAULT_PANEL_JITTER_DENOMINATOR,
  24. .panel_prefill_lines = DEFAULT_PANEL_PREFILL_LINES,
  25. .dsc_enabled = false,
  26. };
  27. static void convert_to_dsi_mode(const struct drm_display_mode *drm_mode,
  28. struct dsi_display_mode *dsi_mode)
  29. {
  30. memset(dsi_mode, 0, sizeof(*dsi_mode));
  31. dsi_mode->timing.h_active = drm_mode->hdisplay;
  32. dsi_mode->timing.h_back_porch = drm_mode->htotal - drm_mode->hsync_end;
  33. dsi_mode->timing.h_sync_width = drm_mode->htotal -
  34. (drm_mode->hsync_start + dsi_mode->timing.h_back_porch);
  35. dsi_mode->timing.h_front_porch = drm_mode->hsync_start -
  36. drm_mode->hdisplay;
  37. dsi_mode->timing.h_skew = drm_mode->hskew;
  38. dsi_mode->timing.v_active = drm_mode->vdisplay;
  39. dsi_mode->timing.v_back_porch = drm_mode->vtotal - drm_mode->vsync_end;
  40. dsi_mode->timing.v_sync_width = drm_mode->vtotal -
  41. (drm_mode->vsync_start + dsi_mode->timing.v_back_porch);
  42. dsi_mode->timing.v_front_porch = drm_mode->vsync_start -
  43. drm_mode->vdisplay;
  44. dsi_mode->timing.refresh_rate = drm_mode_vrefresh(drm_mode);
  45. dsi_mode->timing.h_sync_polarity =
  46. !!(drm_mode->flags & DRM_MODE_FLAG_PHSYNC);
  47. dsi_mode->timing.v_sync_polarity =
  48. !!(drm_mode->flags & DRM_MODE_FLAG_PVSYNC);
  49. }
  50. static void msm_parse_mode_priv_info(const struct msm_display_mode *msm_mode,
  51. struct dsi_display_mode *dsi_mode)
  52. {
  53. dsi_mode->priv_info =
  54. (struct dsi_display_mode_priv_info *)msm_mode->private;
  55. if (dsi_mode->priv_info) {
  56. dsi_mode->timing.dsc_enabled = dsi_mode->priv_info->dsc_enabled;
  57. dsi_mode->timing.dsc = &dsi_mode->priv_info->dsc;
  58. dsi_mode->timing.vdc_enabled = dsi_mode->priv_info->vdc_enabled;
  59. dsi_mode->timing.vdc = &dsi_mode->priv_info->vdc;
  60. dsi_mode->timing.pclk_scale = dsi_mode->priv_info->pclk_scale;
  61. dsi_mode->timing.clk_rate_hz = dsi_mode->priv_info->clk_rate_hz;
  62. }
  63. if (msm_is_mode_seamless(msm_mode))
  64. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_SEAMLESS;
  65. if (msm_is_mode_dynamic_fps(msm_mode))
  66. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_DFPS;
  67. if (msm_needs_vblank_pre_modeset(msm_mode))
  68. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_VBLANK_PRE_MODESET;
  69. if (msm_is_mode_seamless_dms(msm_mode))
  70. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_DMS;
  71. if (msm_is_mode_seamless_vrr(msm_mode))
  72. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_VRR;
  73. if (msm_is_mode_seamless_poms_to_vid(msm_mode))
  74. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_POMS_TO_VID;
  75. if (msm_is_mode_seamless_poms_to_cmd(msm_mode))
  76. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_POMS_TO_CMD;
  77. if (msm_is_mode_seamless_dyn_clk(msm_mode))
  78. dsi_mode->dsi_mode_flags |= DSI_MODE_FLAG_DYN_CLK;
  79. }
  80. void dsi_convert_to_drm_mode(const struct dsi_display_mode *dsi_mode,
  81. struct drm_display_mode *drm_mode)
  82. {
  83. char *panel_caps = "vid";
  84. if ((dsi_mode->panel_mode_caps & DSI_OP_VIDEO_MODE) &&
  85. (dsi_mode->panel_mode_caps & DSI_OP_CMD_MODE))
  86. panel_caps = "vid_cmd";
  87. else if (dsi_mode->panel_mode_caps & DSI_OP_VIDEO_MODE)
  88. panel_caps = "vid";
  89. else if (dsi_mode->panel_mode_caps & DSI_OP_CMD_MODE)
  90. panel_caps = "cmd";
  91. memset(drm_mode, 0, sizeof(*drm_mode));
  92. drm_mode->hdisplay = dsi_mode->timing.h_active;
  93. drm_mode->hsync_start = drm_mode->hdisplay +
  94. dsi_mode->timing.h_front_porch;
  95. drm_mode->hsync_end = drm_mode->hsync_start +
  96. dsi_mode->timing.h_sync_width;
  97. drm_mode->htotal = drm_mode->hsync_end + dsi_mode->timing.h_back_porch;
  98. drm_mode->hskew = dsi_mode->timing.h_skew;
  99. drm_mode->vdisplay = dsi_mode->timing.v_active;
  100. drm_mode->vsync_start = drm_mode->vdisplay +
  101. dsi_mode->timing.v_front_porch;
  102. drm_mode->vsync_end = drm_mode->vsync_start +
  103. dsi_mode->timing.v_sync_width;
  104. drm_mode->vtotal = drm_mode->vsync_end + dsi_mode->timing.v_back_porch;
  105. drm_mode->clock = drm_mode->htotal * drm_mode->vtotal * dsi_mode->timing.refresh_rate;
  106. drm_mode->clock /= 1000;
  107. if (dsi_mode->timing.h_sync_polarity)
  108. drm_mode->flags |= DRM_MODE_FLAG_PHSYNC;
  109. if (dsi_mode->timing.v_sync_polarity)
  110. drm_mode->flags |= DRM_MODE_FLAG_PVSYNC;
  111. /* set mode name */
  112. snprintf(drm_mode->name, DRM_DISPLAY_MODE_LEN, "%dx%dx%d%s",
  113. drm_mode->hdisplay, drm_mode->vdisplay,
  114. drm_mode_vrefresh(drm_mode), panel_caps);
  115. }
  116. static void dsi_convert_to_msm_mode(const struct dsi_display_mode *dsi_mode,
  117. struct msm_display_mode *msm_mode)
  118. {
  119. msm_mode->private_flags = 0;
  120. msm_mode->private = (int *)dsi_mode->priv_info;
  121. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_SEAMLESS)
  122. msm_mode->private_flags |= DRM_MODE_FLAG_SEAMLESS;
  123. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_DFPS)
  124. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_DYNAMIC_FPS;
  125. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_VBLANK_PRE_MODESET)
  126. msm_mode->private_flags |= MSM_MODE_FLAG_VBLANK_PRE_MODESET;
  127. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_DMS)
  128. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_DMS;
  129. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_VRR)
  130. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_VRR;
  131. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_VID)
  132. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_POMS_VID;
  133. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_CMD)
  134. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_POMS_CMD;
  135. if (dsi_mode->dsi_mode_flags & DSI_MODE_FLAG_DYN_CLK)
  136. msm_mode->private_flags |= MSM_MODE_FLAG_SEAMLESS_DYN_CLK;
  137. }
  138. static int dsi_bridge_attach(struct drm_bridge *bridge,
  139. enum drm_bridge_attach_flags flags)
  140. {
  141. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  142. if (!bridge) {
  143. DSI_ERR("Invalid params\n");
  144. return -EINVAL;
  145. }
  146. DSI_DEBUG("[%d] attached\n", c_bridge->id);
  147. return 0;
  148. }
  149. static void dsi_bridge_pre_enable(struct drm_bridge *bridge)
  150. {
  151. int rc = 0;
  152. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  153. if (!bridge) {
  154. DSI_ERR("Invalid params\n");
  155. return;
  156. }
  157. if (!c_bridge || !c_bridge->display || !c_bridge->display->panel) {
  158. DSI_ERR("Incorrect bridge details\n");
  159. return;
  160. }
  161. atomic_set(&c_bridge->display->panel->esd_recovery_pending, 0);
  162. /* By this point mode should have been validated through mode_fixup */
  163. rc = dsi_display_set_mode(c_bridge->display,
  164. &(c_bridge->dsi_mode), 0x0);
  165. if (rc) {
  166. DSI_ERR("[%d] failed to perform a mode set, rc=%d\n",
  167. c_bridge->id, rc);
  168. return;
  169. }
  170. if (c_bridge->dsi_mode.dsi_mode_flags &
  171. (DSI_MODE_FLAG_SEAMLESS | DSI_MODE_FLAG_VRR |
  172. DSI_MODE_FLAG_DYN_CLK)) {
  173. DSI_DEBUG("[%d] seamless pre-enable\n", c_bridge->id);
  174. return;
  175. }
  176. SDE_ATRACE_BEGIN("dsi_display_prepare");
  177. rc = dsi_display_prepare(c_bridge->display);
  178. if (rc) {
  179. DSI_ERR("[%d] DSI display prepare failed, rc=%d\n",
  180. c_bridge->id, rc);
  181. SDE_ATRACE_END("dsi_display_prepare");
  182. return;
  183. }
  184. SDE_ATRACE_END("dsi_display_prepare");
  185. SDE_ATRACE_BEGIN("dsi_display_enable");
  186. rc = dsi_display_enable(c_bridge->display);
  187. if (rc) {
  188. DSI_ERR("[%d] DSI display enable failed, rc=%d\n",
  189. c_bridge->id, rc);
  190. (void)dsi_display_unprepare(c_bridge->display);
  191. }
  192. SDE_ATRACE_END("dsi_display_enable");
  193. rc = dsi_display_splash_res_cleanup(c_bridge->display);
  194. if (rc)
  195. DSI_ERR("Continuous splash pipeline cleanup failed, rc=%d\n",
  196. rc);
  197. }
  198. static void dsi_bridge_enable(struct drm_bridge *bridge)
  199. {
  200. int rc = 0;
  201. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  202. struct dsi_display *display;
  203. if (!bridge) {
  204. DSI_ERR("Invalid params\n");
  205. return;
  206. }
  207. if (c_bridge->dsi_mode.dsi_mode_flags &
  208. (DSI_MODE_FLAG_SEAMLESS | DSI_MODE_FLAG_VRR |
  209. DSI_MODE_FLAG_DYN_CLK)) {
  210. DSI_DEBUG("[%d] seamless enable\n", c_bridge->id);
  211. return;
  212. }
  213. display = c_bridge->display;
  214. rc = dsi_display_post_enable(display);
  215. if (rc)
  216. DSI_ERR("[%d] DSI display post enabled failed, rc=%d\n",
  217. c_bridge->id, rc);
  218. if (display)
  219. display->enabled = true;
  220. if (display && display->drm_conn) {
  221. sde_connector_helper_bridge_enable(display->drm_conn);
  222. if (display->poms_pending) {
  223. display->poms_pending = false;
  224. sde_connector_schedule_status_work(display->drm_conn,
  225. true);
  226. }
  227. }
  228. }
  229. static void dsi_bridge_disable(struct drm_bridge *bridge)
  230. {
  231. int rc = 0;
  232. struct dsi_display *display;
  233. struct sde_connector_state *conn_state;
  234. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  235. if (!bridge) {
  236. DSI_ERR("Invalid params\n");
  237. return;
  238. }
  239. display = c_bridge->display;
  240. if (display)
  241. display->enabled = false;
  242. if (display && display->drm_conn) {
  243. conn_state = to_sde_connector_state(display->drm_conn->state);
  244. if (!conn_state) {
  245. DSI_ERR("invalid params\n");
  246. return;
  247. }
  248. display->poms_pending = msm_is_mode_seamless_poms(
  249. &conn_state->msm_mode);
  250. sde_connector_helper_bridge_disable(display->drm_conn);
  251. }
  252. rc = dsi_display_pre_disable(c_bridge->display);
  253. if (rc) {
  254. DSI_ERR("[%d] DSI display pre disable failed, rc=%d\n",
  255. c_bridge->id, rc);
  256. }
  257. }
  258. static void dsi_bridge_post_disable(struct drm_bridge *bridge)
  259. {
  260. int rc = 0;
  261. struct dsi_display *display;
  262. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  263. if (!bridge) {
  264. DSI_ERR("Invalid params\n");
  265. return;
  266. }
  267. display = c_bridge->display;
  268. SDE_ATRACE_BEGIN("dsi_bridge_post_disable");
  269. SDE_ATRACE_BEGIN("dsi_display_disable");
  270. rc = dsi_display_disable(c_bridge->display);
  271. if (rc) {
  272. DSI_ERR("[%d] DSI display disable failed, rc=%d\n",
  273. c_bridge->id, rc);
  274. SDE_ATRACE_END("dsi_display_disable");
  275. return;
  276. }
  277. SDE_ATRACE_END("dsi_display_disable");
  278. if (display && display->drm_conn)
  279. sde_connector_helper_bridge_post_disable(display->drm_conn);
  280. rc = dsi_display_unprepare(c_bridge->display);
  281. if (rc) {
  282. DSI_ERR("[%d] DSI display unprepare failed, rc=%d\n",
  283. c_bridge->id, rc);
  284. SDE_ATRACE_END("dsi_bridge_post_disable");
  285. return;
  286. }
  287. SDE_ATRACE_END("dsi_bridge_post_disable");
  288. }
  289. static void dsi_bridge_mode_set(struct drm_bridge *bridge,
  290. const struct drm_display_mode *mode,
  291. const struct drm_display_mode *adjusted_mode)
  292. {
  293. int rc = 0;
  294. struct dsi_bridge *c_bridge = NULL;
  295. struct dsi_display *display;
  296. struct drm_connector *conn;
  297. struct sde_connector_state *conn_state;
  298. if (!bridge || !mode || !adjusted_mode) {
  299. DSI_ERR("Invalid params\n");
  300. return;
  301. }
  302. c_bridge = to_dsi_bridge(bridge);
  303. if (!c_bridge) {
  304. DSI_ERR("invalid dsi bridge\n");
  305. return;
  306. }
  307. display = c_bridge->display;
  308. if (!display || !display->drm_conn || !display->drm_conn->state) {
  309. DSI_ERR("invalid display\n");
  310. return;
  311. }
  312. memset(&(c_bridge->dsi_mode), 0x0, sizeof(struct dsi_display_mode));
  313. convert_to_dsi_mode(adjusted_mode, &(c_bridge->dsi_mode));
  314. conn = sde_encoder_get_connector(bridge->dev, bridge->encoder);
  315. if (!conn)
  316. return;
  317. conn_state = to_sde_connector_state(conn->state);
  318. if (!conn_state) {
  319. DSI_ERR("invalid connector state\n");
  320. return;
  321. }
  322. msm_parse_mode_priv_info(&conn_state->msm_mode,
  323. &(c_bridge->dsi_mode));
  324. rc = dsi_display_restore_bit_clk(display, &c_bridge->dsi_mode);
  325. if (rc) {
  326. DSI_ERR("[%s] bit clk rate cannot be restored\n", display->name);
  327. return;
  328. }
  329. DSI_DEBUG("clk_rate: %llu\n", c_bridge->dsi_mode.timing.clk_rate_hz);
  330. }
  331. static bool _dsi_bridge_mode_validate_and_fixup(struct drm_bridge *bridge,
  332. struct drm_crtc_state *crtc_state, struct dsi_display *display,
  333. struct dsi_display_mode *adj_mode)
  334. {
  335. int rc = 0;
  336. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  337. struct dsi_display_mode cur_dsi_mode;
  338. struct sde_connector_state *old_conn_state;
  339. struct drm_display_mode *cur_mode;
  340. if (!bridge->encoder || !bridge->encoder->crtc || !crtc_state->crtc)
  341. return 0;
  342. cur_mode = &crtc_state->crtc->state->mode;
  343. old_conn_state = to_sde_connector_state(display->drm_conn->state);
  344. convert_to_dsi_mode(cur_mode, &cur_dsi_mode);
  345. msm_parse_mode_priv_info(&old_conn_state->msm_mode, &cur_dsi_mode);
  346. rc = dsi_display_validate_mode_change(c_bridge->display, &cur_dsi_mode, adj_mode);
  347. if (rc) {
  348. DSI_ERR("[%s] seamless mode mismatch failure rc=%d\n", c_bridge->display->name, rc);
  349. return rc;
  350. }
  351. /*
  352. * DMS Flag if set during active changed condition cannot be
  353. * treated as seamless. Hence, removing DMS flag in such cases.
  354. */
  355. if ((adj_mode->dsi_mode_flags & DSI_MODE_FLAG_DMS) &&
  356. crtc_state->active_changed)
  357. adj_mode->dsi_mode_flags &= ~DSI_MODE_FLAG_DMS;
  358. /* No DMS/VRR when drm pipeline is changing */
  359. if (!dsi_display_mode_match(&cur_dsi_mode, adj_mode,
  360. DSI_MODE_MATCH_FULL_TIMINGS) &&
  361. (!(adj_mode->dsi_mode_flags & DSI_MODE_FLAG_VRR)) &&
  362. (!(adj_mode->dsi_mode_flags & DSI_MODE_FLAG_DYN_CLK)) &&
  363. (!(adj_mode->dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_VID)) &&
  364. (!(adj_mode->dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_CMD)) &&
  365. (!crtc_state->active_changed ||
  366. display->is_cont_splash_enabled)) {
  367. adj_mode->dsi_mode_flags |= DSI_MODE_FLAG_DMS;
  368. SDE_EVT32(SDE_EVTLOG_FUNC_CASE2,
  369. adj_mode->timing.h_active,
  370. adj_mode->timing.v_active,
  371. adj_mode->timing.refresh_rate,
  372. adj_mode->pixel_clk_khz,
  373. adj_mode->panel_mode_caps);
  374. }
  375. return rc;
  376. }
  377. static bool dsi_bridge_mode_fixup(struct drm_bridge *bridge,
  378. const struct drm_display_mode *mode,
  379. struct drm_display_mode *adjusted_mode)
  380. {
  381. int rc = 0;
  382. struct dsi_bridge *c_bridge = to_dsi_bridge(bridge);
  383. struct dsi_display *display;
  384. struct dsi_display_mode dsi_mode, *panel_dsi_mode;
  385. struct drm_crtc_state *crtc_state;
  386. struct drm_connector_state *drm_conn_state;
  387. struct sde_connector_state *conn_state;
  388. struct msm_sub_mode new_sub_mode;
  389. crtc_state = container_of(mode, struct drm_crtc_state, mode);
  390. if (!bridge || !mode || !adjusted_mode) {
  391. DSI_ERR("invalid params\n");
  392. return false;
  393. }
  394. display = c_bridge->display;
  395. if (!display || !display->drm_conn || !display->drm_conn->state) {
  396. DSI_ERR("invalid params\n");
  397. return false;
  398. }
  399. drm_conn_state = drm_atomic_get_new_connector_state(crtc_state->state,
  400. display->drm_conn);
  401. conn_state = to_sde_connector_state(drm_conn_state);
  402. if (!conn_state) {
  403. DSI_ERR("invalid params\n");
  404. return false;
  405. }
  406. /*
  407. * if no timing defined in panel, it must be external mode
  408. * and we'll use empty priv info to populate the mode
  409. */
  410. if (display->panel && !display->panel->num_timing_nodes) {
  411. *adjusted_mode = *mode;
  412. conn_state->msm_mode.base = adjusted_mode;
  413. conn_state->msm_mode.private = (int *)&default_priv_info;
  414. conn_state->msm_mode.private_flags = 0;
  415. return true;
  416. }
  417. convert_to_dsi_mode(mode, &dsi_mode);
  418. msm_parse_mode_priv_info(&conn_state->msm_mode, &dsi_mode);
  419. new_sub_mode.dsc_mode = sde_connector_get_property(drm_conn_state,
  420. CONNECTOR_PROP_DSC_MODE);
  421. /*
  422. * retrieve dsi mode from dsi driver's cache since not safe to take
  423. * the drm mode config mutex in all paths
  424. */
  425. rc = dsi_display_find_mode(display, &dsi_mode, &new_sub_mode,
  426. &panel_dsi_mode);
  427. if (rc)
  428. return rc;
  429. /* propagate the private info to the adjusted_mode derived dsi mode */
  430. dsi_mode.priv_info = panel_dsi_mode->priv_info;
  431. dsi_mode.dsi_mode_flags = panel_dsi_mode->dsi_mode_flags;
  432. dsi_mode.panel_mode_caps = panel_dsi_mode->panel_mode_caps;
  433. dsi_mode.timing.dsc_enabled = dsi_mode.priv_info->dsc_enabled;
  434. dsi_mode.timing.dsc = &dsi_mode.priv_info->dsc;
  435. rc = dsi_display_restore_bit_clk(display, &dsi_mode);
  436. if (rc) {
  437. DSI_ERR("[%s] bit clk rate cannot be restored\n", display->name);
  438. return false;
  439. }
  440. rc = dsi_display_update_dyn_bit_clk(display, &dsi_mode);
  441. if (rc) {
  442. DSI_ERR("[%s] failed to update bit clock\n", display->name);
  443. return false;
  444. }
  445. rc = dsi_display_validate_mode(c_bridge->display, &dsi_mode,
  446. DSI_VALIDATE_FLAG_ALLOW_ADJUST);
  447. if (rc) {
  448. DSI_ERR("[%d] mode is not valid, rc=%d\n", c_bridge->id, rc);
  449. return false;
  450. }
  451. rc = _dsi_bridge_mode_validate_and_fixup(bridge, crtc_state, display, &dsi_mode);
  452. if (rc) {
  453. DSI_ERR("[%s] failed to validate dsi bridge mode.\n", display->name);
  454. return false;
  455. }
  456. /* Reject seamless transition when active changed */
  457. if (crtc_state->active_changed &&
  458. ((dsi_mode.dsi_mode_flags & DSI_MODE_FLAG_VRR) ||
  459. (dsi_mode.dsi_mode_flags & DSI_MODE_FLAG_DYN_CLK) ||
  460. (dsi_mode.dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_VID) ||
  461. (dsi_mode.dsi_mode_flags & DSI_MODE_FLAG_POMS_TO_CMD))) {
  462. DSI_INFO("seamless upon active changed 0x%x %d\n",
  463. dsi_mode.dsi_mode_flags, crtc_state->active_changed);
  464. return false;
  465. }
  466. /* convert back to drm mode, propagating the private info & flags */
  467. dsi_convert_to_drm_mode(&dsi_mode, adjusted_mode);
  468. dsi_convert_to_msm_mode(&dsi_mode, &conn_state->msm_mode);
  469. return true;
  470. }
  471. u32 dsi_drm_get_dfps_maxfps(void *display)
  472. {
  473. u32 dfps_maxfps = 0;
  474. struct dsi_display *dsi_display = display;
  475. /*
  476. * The time of SDE transmitting one frame active data
  477. * will not be changed, if frame rate is adjusted with
  478. * VFP method.
  479. * So only return max fps of DFPS for UIDLE update, if DFPS
  480. * is enabled with VFP.
  481. */
  482. if (dsi_display && dsi_display->panel &&
  483. dsi_display->panel->panel_mode == DSI_OP_VIDEO_MODE &&
  484. dsi_display->panel->dfps_caps.type ==
  485. DSI_DFPS_IMMEDIATE_VFP)
  486. dfps_maxfps =
  487. dsi_display->panel->dfps_caps.max_refresh_rate;
  488. return dfps_maxfps;
  489. }
  490. int dsi_conn_get_lm_from_mode(void *display, const struct drm_display_mode *drm_mode)
  491. {
  492. struct dsi_display *dsi_display = display;
  493. struct dsi_display_mode dsi_mode, *panel_dsi_mode;
  494. int rc = -EINVAL;
  495. if (!dsi_display || !drm_mode) {
  496. DSI_ERR("Invalid params %d %d\n", !display, !drm_mode);
  497. return rc;
  498. }
  499. convert_to_dsi_mode(drm_mode, &dsi_mode);
  500. rc = dsi_display_find_mode(dsi_display, &dsi_mode, NULL, &panel_dsi_mode);
  501. if (rc) {
  502. DSI_ERR("mode not found %d\n", rc);
  503. drm_mode_debug_printmodeline(drm_mode);
  504. return rc;
  505. }
  506. return panel_dsi_mode->priv_info->topology.num_lm;
  507. }
  508. int dsi_conn_get_mode_info(struct drm_connector *connector,
  509. const struct drm_display_mode *drm_mode,
  510. struct msm_sub_mode *sub_mode,
  511. struct msm_mode_info *mode_info,
  512. void *display, const struct msm_resource_caps_info *avail_res)
  513. {
  514. struct dsi_display_mode partial_dsi_mode, *dsi_mode = NULL;
  515. struct dsi_mode_info *timing;
  516. int src_bpp, tar_bpp, rc = 0;
  517. struct dsi_display *dsi_display = (struct dsi_display *) display;
  518. if (!drm_mode || !mode_info)
  519. return -EINVAL;
  520. convert_to_dsi_mode(drm_mode, &partial_dsi_mode);
  521. rc = dsi_display_find_mode(dsi_display, &partial_dsi_mode, sub_mode, &dsi_mode);
  522. if (rc || !dsi_mode->priv_info || !dsi_display || !dsi_display->panel)
  523. return -EINVAL;
  524. memset(mode_info, 0, sizeof(*mode_info));
  525. timing = &dsi_mode->timing;
  526. mode_info->frame_rate = dsi_mode->timing.refresh_rate;
  527. mode_info->vtotal = DSI_V_TOTAL(timing);
  528. mode_info->prefill_lines = dsi_mode->priv_info->panel_prefill_lines;
  529. mode_info->jitter_numer = dsi_mode->priv_info->panel_jitter_numer;
  530. mode_info->jitter_denom = dsi_mode->priv_info->panel_jitter_denom;
  531. mode_info->dfps_maxfps = dsi_drm_get_dfps_maxfps(display);
  532. mode_info->panel_mode_caps = dsi_mode->panel_mode_caps;
  533. mode_info->mdp_transfer_time_us = dsi_mode->priv_info->mdp_transfer_time_us;
  534. mode_info->mdp_transfer_time_us_min = dsi_mode->priv_info->mdp_transfer_time_us_min;
  535. mode_info->mdp_transfer_time_us_max = dsi_mode->priv_info->mdp_transfer_time_us_max;
  536. mode_info->disable_rsc_solver = dsi_mode->priv_info->disable_rsc_solver;
  537. mode_info->qsync_min_fps = dsi_mode->timing.qsync_min_fps;
  538. mode_info->wd_jitter = dsi_mode->priv_info->wd_jitter;
  539. mode_info->vpadding = dsi_display->panel->host_config.vpadding;
  540. if (mode_info->vpadding < drm_mode->vdisplay) {
  541. mode_info->vpadding = 0;
  542. dsi_display->panel->host_config.line_insertion_enable = 0;
  543. }
  544. memcpy(&mode_info->topology, &dsi_mode->priv_info->topology,
  545. sizeof(struct msm_display_topology));
  546. if (dsi_mode->priv_info->bit_clk_list.count) {
  547. struct msm_dyn_clk_list *dyn_clk_list = &mode_info->dyn_clk_list;
  548. dyn_clk_list->rates = dsi_mode->priv_info->bit_clk_list.rates;
  549. dyn_clk_list->count = dsi_mode->priv_info->bit_clk_list.count;
  550. dyn_clk_list->type = dsi_display->panel->dyn_clk_caps.type;
  551. dyn_clk_list->front_porches = dsi_mode->priv_info->bit_clk_list.front_porches;
  552. dyn_clk_list->pixel_clks_khz = dsi_mode->priv_info->bit_clk_list.pixel_clks_khz;
  553. rc = dsi_display_restore_bit_clk(dsi_display, dsi_mode);
  554. if (rc) {
  555. DSI_ERR("[%s] bit clk rate cannot be restored\n", dsi_display->name);
  556. return rc;
  557. }
  558. }
  559. mode_info->clk_rate = dsi_mode->timing.clk_rate_hz;
  560. if (dsi_mode->priv_info->dsc_enabled) {
  561. mode_info->comp_info.comp_type = MSM_DISPLAY_COMPRESSION_DSC;
  562. mode_info->topology.comp_type = MSM_DISPLAY_COMPRESSION_DSC;
  563. memcpy(&mode_info->comp_info.dsc_info, &dsi_mode->priv_info->dsc,
  564. sizeof(dsi_mode->priv_info->dsc));
  565. } else if (dsi_mode->priv_info->vdc_enabled) {
  566. mode_info->comp_info.comp_type = MSM_DISPLAY_COMPRESSION_VDC;
  567. mode_info->topology.comp_type = MSM_DISPLAY_COMPRESSION_VDC;
  568. memcpy(&mode_info->comp_info.vdc_info, &dsi_mode->priv_info->vdc,
  569. sizeof(dsi_mode->priv_info->vdc));
  570. }
  571. if (mode_info->comp_info.comp_type) {
  572. tar_bpp = dsi_mode->priv_info->pclk_scale.numer;
  573. src_bpp = dsi_mode->priv_info->pclk_scale.denom;
  574. mode_info->comp_info.comp_ratio = mult_frac(1, src_bpp,
  575. tar_bpp);
  576. mode_info->wide_bus_en = dsi_mode->priv_info->widebus_support;
  577. }
  578. if (dsi_mode->priv_info->roi_caps.enabled) {
  579. memcpy(&mode_info->roi_caps, &dsi_mode->priv_info->roi_caps,
  580. sizeof(dsi_mode->priv_info->roi_caps));
  581. }
  582. mode_info->allowed_mode_switches =
  583. dsi_mode->priv_info->allowed_mode_switch;
  584. return 0;
  585. }
  586. static const struct drm_bridge_funcs dsi_bridge_ops = {
  587. .attach = dsi_bridge_attach,
  588. .mode_fixup = dsi_bridge_mode_fixup,
  589. .pre_enable = dsi_bridge_pre_enable,
  590. .enable = dsi_bridge_enable,
  591. .disable = dsi_bridge_disable,
  592. .post_disable = dsi_bridge_post_disable,
  593. .mode_set = dsi_bridge_mode_set,
  594. };
  595. int dsi_conn_set_avr_step_info(struct dsi_panel *panel, void *info)
  596. {
  597. u32 i;
  598. int idx = 0;
  599. size_t buff_sz = PAGE_SIZE;
  600. char *buff;
  601. buff = kzalloc(buff_sz, GFP_KERNEL);
  602. if (!buff)
  603. return -ENOMEM;
  604. for (i = 0; i < panel->avr_caps.avr_step_fps_list_len && (idx < (buff_sz - 1)); i++)
  605. idx += scnprintf(&buff[idx], buff_sz - idx, "%u@%u ",
  606. panel->avr_caps.avr_step_fps_list[i],
  607. panel->dfps_caps.dfps_list[i]);
  608. sde_kms_info_add_keystr(info, "avr step requirement", buff);
  609. kfree(buff);
  610. return 0;
  611. }
  612. int dsi_conn_get_qsync_min_fps(struct drm_connector_state *conn_state)
  613. {
  614. struct sde_connector_state *sde_conn_state = to_sde_connector_state(conn_state);
  615. struct msm_display_mode *msm_mode;
  616. struct dsi_display_mode_priv_info *priv_info;
  617. if (!sde_conn_state)
  618. return -EINVAL;
  619. msm_mode = &sde_conn_state->msm_mode;
  620. if (!msm_mode || !msm_mode->private)
  621. return -EINVAL;
  622. priv_info = (struct dsi_display_mode_priv_info *)(msm_mode->private);
  623. return priv_info->qsync_min_fps;
  624. }
  625. int dsi_conn_set_info_blob(struct drm_connector *connector,
  626. void *info, void *display, struct msm_mode_info *mode_info)
  627. {
  628. struct dsi_display *dsi_display = display;
  629. struct dsi_panel *panel;
  630. enum dsi_pixel_format fmt;
  631. u32 bpp;
  632. if (!info || !dsi_display)
  633. return -EINVAL;
  634. dsi_display->drm_conn = connector;
  635. sde_kms_info_add_keystr(info,
  636. "display type", dsi_display->display_type);
  637. switch (dsi_display->type) {
  638. case DSI_DISPLAY_SINGLE:
  639. sde_kms_info_add_keystr(info, "display config",
  640. "single display");
  641. break;
  642. case DSI_DISPLAY_EXT_BRIDGE:
  643. sde_kms_info_add_keystr(info, "display config", "ext bridge");
  644. break;
  645. case DSI_DISPLAY_SPLIT:
  646. sde_kms_info_add_keystr(info, "display config",
  647. "split display");
  648. break;
  649. case DSI_DISPLAY_SPLIT_EXT_BRIDGE:
  650. sde_kms_info_add_keystr(info, "display config",
  651. "split ext bridge");
  652. break;
  653. default:
  654. DSI_DEBUG("invalid display type:%d\n", dsi_display->type);
  655. break;
  656. }
  657. if (!dsi_display->panel) {
  658. DSI_DEBUG("invalid panel data\n");
  659. goto end;
  660. }
  661. panel = dsi_display->panel;
  662. sde_kms_info_add_keystr(info, "panel name", panel->name);
  663. switch (panel->panel_mode) {
  664. case DSI_OP_VIDEO_MODE:
  665. sde_kms_info_add_keystr(info, "panel mode", "video");
  666. if (panel->avr_caps.avr_step_fps_list_len)
  667. dsi_conn_set_avr_step_info(panel, info);
  668. break;
  669. case DSI_OP_CMD_MODE:
  670. sde_kms_info_add_keystr(info, "panel mode", "command");
  671. sde_kms_info_add_keyint(info, "mdp_transfer_time_us",
  672. mode_info->mdp_transfer_time_us);
  673. break;
  674. default:
  675. DSI_DEBUG("invalid panel type:%d\n", panel->panel_mode);
  676. break;
  677. }
  678. sde_kms_info_add_keystr(info, "qsync support",
  679. panel->qsync_caps.qsync_support ?
  680. "true" : "false");
  681. if (panel->qsync_caps.qsync_min_fps)
  682. sde_kms_info_add_keyint(info, "qsync_fps",
  683. panel->qsync_caps.qsync_min_fps);
  684. sde_kms_info_add_keystr(info, "dfps support",
  685. panel->dfps_caps.dfps_support ? "true" : "false");
  686. if (panel->dfps_caps.dfps_support) {
  687. sde_kms_info_add_keyint(info, "min_fps",
  688. panel->dfps_caps.min_refresh_rate);
  689. sde_kms_info_add_keyint(info, "max_fps",
  690. panel->dfps_caps.max_refresh_rate);
  691. }
  692. sde_kms_info_add_keystr(info, "dyn bitclk support",
  693. panel->dyn_clk_caps.dyn_clk_support ? "true" : "false");
  694. switch (panel->phy_props.rotation) {
  695. case DSI_PANEL_ROTATE_NONE:
  696. sde_kms_info_add_keystr(info, "panel orientation", "none");
  697. break;
  698. case DSI_PANEL_ROTATE_H_FLIP:
  699. sde_kms_info_add_keystr(info, "panel orientation", "horz flip");
  700. break;
  701. case DSI_PANEL_ROTATE_V_FLIP:
  702. sde_kms_info_add_keystr(info, "panel orientation", "vert flip");
  703. break;
  704. case DSI_PANEL_ROTATE_HV_FLIP:
  705. sde_kms_info_add_keystr(info, "panel orientation",
  706. "horz & vert flip");
  707. break;
  708. default:
  709. DSI_DEBUG("invalid panel rotation:%d\n",
  710. panel->phy_props.rotation);
  711. break;
  712. }
  713. switch (panel->bl_config.type) {
  714. case DSI_BACKLIGHT_PWM:
  715. sde_kms_info_add_keystr(info, "backlight type", "pwm");
  716. break;
  717. case DSI_BACKLIGHT_WLED:
  718. sde_kms_info_add_keystr(info, "backlight type", "wled");
  719. break;
  720. case DSI_BACKLIGHT_DCS:
  721. sde_kms_info_add_keystr(info, "backlight type", "dcs");
  722. break;
  723. default:
  724. DSI_DEBUG("invalid panel backlight type:%d\n",
  725. panel->bl_config.type);
  726. break;
  727. }
  728. sde_kms_info_add_keyint(info, "max os brightness", panel->bl_config.brightness_max_level);
  729. sde_kms_info_add_keyint(info, "max panel backlight", panel->bl_config.bl_max_level);
  730. if (panel->spr_info.enable)
  731. sde_kms_info_add_keystr(info, "spr_pack_type",
  732. msm_spr_pack_type_str[panel->spr_info.pack_type]);
  733. if (mode_info && mode_info->roi_caps.enabled) {
  734. sde_kms_info_add_keyint(info, "partial_update_num_roi",
  735. mode_info->roi_caps.num_roi);
  736. sde_kms_info_add_keyint(info, "partial_update_xstart",
  737. mode_info->roi_caps.align.xstart_pix_align);
  738. sde_kms_info_add_keyint(info, "partial_update_walign",
  739. mode_info->roi_caps.align.width_pix_align);
  740. sde_kms_info_add_keyint(info, "partial_update_wmin",
  741. mode_info->roi_caps.align.min_width);
  742. sde_kms_info_add_keyint(info, "partial_update_ystart",
  743. mode_info->roi_caps.align.ystart_pix_align);
  744. sde_kms_info_add_keyint(info, "partial_update_halign",
  745. mode_info->roi_caps.align.height_pix_align);
  746. sde_kms_info_add_keyint(info, "partial_update_hmin",
  747. mode_info->roi_caps.align.min_height);
  748. sde_kms_info_add_keyint(info, "partial_update_roimerge",
  749. mode_info->roi_caps.merge_rois);
  750. }
  751. fmt = dsi_display->config.common_config.dst_format;
  752. bpp = dsi_ctrl_pixel_format_to_bpp(fmt);
  753. sde_kms_info_add_keyint(info, "bit_depth", bpp);
  754. end:
  755. return 0;
  756. }
  757. void dsi_conn_set_submode_blob_info(struct drm_connector *conn,
  758. void *info, void *display, struct drm_display_mode *drm_mode)
  759. {
  760. struct dsi_display *dsi_display = display;
  761. struct dsi_display_mode partial_dsi_mode;
  762. int count, i;
  763. int preferred_submode_idx = -EINVAL;
  764. enum dsi_dyn_clk_feature_type dyn_clk_type;
  765. char *dyn_clk_types[DSI_DYN_CLK_TYPE_MAX] = {
  766. [DSI_DYN_CLK_TYPE_LEGACY] = "none",
  767. [DSI_DYN_CLK_TYPE_CONST_FPS_ADJUST_HFP] = "hfp",
  768. [DSI_DYN_CLK_TYPE_CONST_FPS_ADJUST_VFP] = "vfp",
  769. };
  770. if (!conn || !display || !drm_mode) {
  771. DSI_ERR("Invalid params\n");
  772. return;
  773. }
  774. convert_to_dsi_mode(drm_mode, &partial_dsi_mode);
  775. mutex_lock(&dsi_display->display_lock);
  776. count = dsi_display->panel->num_display_modes;
  777. for (i = 0; i < count; i++) {
  778. struct dsi_display_mode *dsi_mode = &dsi_display->modes[i];
  779. u32 panel_mode_caps = 0;
  780. const char *topo_name = NULL;
  781. if (!dsi_display_mode_match(&partial_dsi_mode, dsi_mode,
  782. DSI_MODE_MATCH_FULL_TIMINGS))
  783. continue;
  784. sde_kms_info_add_keyint(info, "submode_idx", i);
  785. if (dsi_mode->is_preferred)
  786. preferred_submode_idx = i;
  787. if (dsi_mode->panel_mode_caps & DSI_OP_CMD_MODE)
  788. panel_mode_caps |= DRM_MODE_FLAG_CMD_MODE_PANEL;
  789. if (dsi_mode->panel_mode_caps & DSI_OP_VIDEO_MODE)
  790. panel_mode_caps |= DRM_MODE_FLAG_VID_MODE_PANEL;
  791. sde_kms_info_add_keyint(info, "panel_mode_capabilities",
  792. panel_mode_caps);
  793. sde_kms_info_add_keyint(info, "dsc_mode",
  794. dsi_mode->priv_info->dsc_enabled ? MSM_DISPLAY_DSC_MODE_ENABLED :
  795. MSM_DISPLAY_DSC_MODE_DISABLED);
  796. topo_name = sde_conn_get_topology_name(conn,
  797. dsi_mode->priv_info->topology);
  798. if (topo_name)
  799. sde_kms_info_add_keystr(info, "topology", topo_name);
  800. if (!dsi_mode->priv_info->bit_clk_list.count)
  801. continue;
  802. dyn_clk_type = dsi_display->panel->dyn_clk_caps.type;
  803. sde_kms_info_add_list(info, "dyn_bitclk_list",
  804. dsi_mode->priv_info->bit_clk_list.rates,
  805. dsi_mode->priv_info->bit_clk_list.count);
  806. sde_kms_info_add_keystr(info, "dyn_fp_type",
  807. dyn_clk_types[dyn_clk_type]);
  808. sde_kms_info_add_list(info, "dyn_fp_list",
  809. dsi_mode->priv_info->bit_clk_list.front_porches,
  810. dsi_mode->priv_info->bit_clk_list.count);
  811. sde_kms_info_add_list(info, "dyn_pclk_list",
  812. dsi_mode->priv_info->bit_clk_list.pixel_clks_khz,
  813. dsi_mode->priv_info->bit_clk_list.count);
  814. }
  815. if (preferred_submode_idx >= 0)
  816. sde_kms_info_add_keyint(info, "preferred_submode_idx",
  817. preferred_submode_idx);
  818. mutex_unlock(&dsi_display->display_lock);
  819. }
  820. enum drm_connector_status dsi_conn_detect(struct drm_connector *conn,
  821. bool force,
  822. void *display)
  823. {
  824. enum drm_connector_status status = connector_status_unknown;
  825. struct msm_display_info info;
  826. int rc;
  827. if (!conn || !display)
  828. return status;
  829. /* get display dsi_info */
  830. memset(&info, 0x0, sizeof(info));
  831. rc = dsi_display_get_info(conn, &info, display);
  832. if (rc) {
  833. DSI_ERR("failed to get display info, rc=%d\n", rc);
  834. return connector_status_disconnected;
  835. }
  836. if (info.capabilities & MSM_DISPLAY_CAP_HOT_PLUG)
  837. status = (info.is_connected ? connector_status_connected :
  838. connector_status_disconnected);
  839. else
  840. status = connector_status_connected;
  841. conn->display_info.width_mm = info.width_mm;
  842. conn->display_info.height_mm = info.height_mm;
  843. return status;
  844. }
  845. void dsi_connector_put_modes(struct drm_connector *connector,
  846. void *display)
  847. {
  848. struct dsi_display *dsi_display;
  849. int count, i;
  850. if (!connector || !display)
  851. return;
  852. dsi_display = display;
  853. count = dsi_display->panel->num_display_modes;
  854. for (i = 0; i < count; i++) {
  855. struct dsi_display_mode *dsi_mode = &dsi_display->modes[i];
  856. dsi_display_put_mode(dsi_display, dsi_mode);
  857. }
  858. /* free the display structure modes also */
  859. kfree(dsi_display->modes);
  860. dsi_display->modes = NULL;
  861. }
  862. static int dsi_drm_update_edid_name(struct edid *edid, const char *name)
  863. {
  864. u8 *dtd = (u8 *)&edid->detailed_timings[3];
  865. u8 standard_header[] = {0x00, 0x00, 0x00, 0xFE, 0x00};
  866. u32 dtd_size = 18;
  867. u32 header_size = sizeof(standard_header);
  868. if (!name)
  869. return -EINVAL;
  870. /* Fill standard header */
  871. memcpy(dtd, standard_header, header_size);
  872. dtd_size -= header_size;
  873. dtd_size = min_t(u32, dtd_size, strlen(name));
  874. memcpy(dtd + header_size, name, dtd_size);
  875. return 0;
  876. }
  877. static void dsi_drm_update_dtd(struct edid *edid,
  878. struct dsi_display_mode *modes, u32 modes_count)
  879. {
  880. u32 i;
  881. u32 count = min_t(u32, modes_count, 3);
  882. for (i = 0; i < count; i++) {
  883. struct detailed_timing *dtd = &edid->detailed_timings[i];
  884. struct dsi_display_mode *mode = &modes[i];
  885. struct dsi_mode_info *timing = &mode->timing;
  886. struct detailed_pixel_timing *pd = &dtd->data.pixel_data;
  887. u32 h_blank = timing->h_front_porch + timing->h_sync_width +
  888. timing->h_back_porch;
  889. u32 v_blank = timing->v_front_porch + timing->v_sync_width +
  890. timing->v_back_porch;
  891. u32 h_img = 0, v_img = 0;
  892. dtd->pixel_clock = mode->pixel_clk_khz / 10;
  893. pd->hactive_lo = timing->h_active & 0xFF;
  894. pd->hblank_lo = h_blank & 0xFF;
  895. pd->hactive_hblank_hi = ((h_blank >> 8) & 0xF) |
  896. ((timing->h_active >> 8) & 0xF) << 4;
  897. pd->vactive_lo = timing->v_active & 0xFF;
  898. pd->vblank_lo = v_blank & 0xFF;
  899. pd->vactive_vblank_hi = ((v_blank >> 8) & 0xF) |
  900. ((timing->v_active >> 8) & 0xF) << 4;
  901. pd->hsync_offset_lo = timing->h_front_porch & 0xFF;
  902. pd->hsync_pulse_width_lo = timing->h_sync_width & 0xFF;
  903. pd->vsync_offset_pulse_width_lo =
  904. ((timing->v_front_porch & 0xF) << 4) |
  905. (timing->v_sync_width & 0xF);
  906. pd->hsync_vsync_offset_pulse_width_hi =
  907. (((timing->h_front_porch >> 8) & 0x3) << 6) |
  908. (((timing->h_sync_width >> 8) & 0x3) << 4) |
  909. (((timing->v_front_porch >> 4) & 0x3) << 2) |
  910. (((timing->v_sync_width >> 4) & 0x3) << 0);
  911. pd->width_mm_lo = h_img & 0xFF;
  912. pd->height_mm_lo = v_img & 0xFF;
  913. pd->width_height_mm_hi = (((h_img >> 8) & 0xF) << 4) |
  914. ((v_img >> 8) & 0xF);
  915. pd->hborder = 0;
  916. pd->vborder = 0;
  917. pd->misc = 0;
  918. }
  919. }
  920. static void dsi_drm_update_checksum(struct edid *edid)
  921. {
  922. u8 *data = (u8 *)edid;
  923. u32 i, sum = 0;
  924. for (i = 0; i < EDID_LENGTH - 1; i++)
  925. sum += data[i];
  926. edid->checksum = 0x100 - (sum & 0xFF);
  927. }
  928. int dsi_connector_get_modes(struct drm_connector *connector, void *data,
  929. const struct msm_resource_caps_info *avail_res)
  930. {
  931. int rc, i;
  932. u32 count = 0, edid_size;
  933. struct dsi_display_mode *modes = NULL;
  934. struct drm_display_mode drm_mode;
  935. struct dsi_display *display = data;
  936. struct edid edid;
  937. unsigned int width_mm = connector->display_info.width_mm;
  938. unsigned int height_mm = connector->display_info.height_mm;
  939. const u8 edid_buf[EDID_LENGTH] = {
  940. 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x44, 0x6D,
  941. 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1B, 0x10, 0x01, 0x03,
  942. 0x80, 0x00, 0x00, 0x78, 0x0A, 0x0D, 0xC9, 0xA0, 0x57, 0x47,
  943. 0x98, 0x27, 0x12, 0x48, 0x4C, 0x00, 0x00, 0x00, 0x01, 0x01,
  944. 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
  945. 0x01, 0x01, 0x01, 0x01,
  946. };
  947. edid_size = min_t(u32, sizeof(edid), EDID_LENGTH);
  948. memcpy(&edid, edid_buf, edid_size);
  949. rc = dsi_display_get_mode_count(display, &count);
  950. if (rc) {
  951. DSI_ERR("failed to get num of modes, rc=%d\n", rc);
  952. goto end;
  953. }
  954. rc = dsi_display_get_modes(display, &modes);
  955. if (rc) {
  956. DSI_ERR("failed to get modes, rc=%d\n", rc);
  957. count = 0;
  958. goto end;
  959. }
  960. for (i = 0; i < count; i++) {
  961. struct drm_display_mode *m;
  962. memset(&drm_mode, 0x0, sizeof(drm_mode));
  963. dsi_convert_to_drm_mode(&modes[i], &drm_mode);
  964. m = drm_mode_duplicate(connector->dev, &drm_mode);
  965. if (!m) {
  966. DSI_ERR("failed to add mode %ux%u\n",
  967. drm_mode.hdisplay,
  968. drm_mode.vdisplay);
  969. count = -ENOMEM;
  970. goto end;
  971. }
  972. m->width_mm = connector->display_info.width_mm;
  973. m->height_mm = connector->display_info.height_mm;
  974. if (display->cmdline_timing != NO_OVERRIDE) {
  975. /* get the preferred mode from dsi display mode */
  976. if (modes[i].is_preferred)
  977. m->type |= DRM_MODE_TYPE_PREFERRED;
  978. } else if (modes[i].mode_idx == 0) {
  979. /* set the first mode in device tree list as preferred */
  980. m->type |= DRM_MODE_TYPE_PREFERRED;
  981. }
  982. drm_mode_probed_add(connector, m);
  983. }
  984. rc = dsi_drm_update_edid_name(&edid, display->panel->name);
  985. if (rc) {
  986. count = 0;
  987. goto end;
  988. }
  989. edid.width_cm = (connector->display_info.width_mm) / 10;
  990. edid.height_cm = (connector->display_info.height_mm) / 10;
  991. dsi_drm_update_dtd(&edid, modes, count);
  992. dsi_drm_update_checksum(&edid);
  993. rc = drm_connector_update_edid_property(connector, &edid);
  994. if (rc)
  995. count = 0;
  996. /*
  997. * DRM EDID structure maintains panel physical dimensions in
  998. * centimeters, we will be losing the precision anything below cm.
  999. * Changing DRM framework will effect other clients at this
  1000. * moment, overriding the values back to millimeter.
  1001. */
  1002. connector->display_info.width_mm = width_mm;
  1003. connector->display_info.height_mm = height_mm;
  1004. end:
  1005. DSI_DEBUG("MODE COUNT =%d\n\n", count);
  1006. return count;
  1007. }
  1008. enum drm_mode_status dsi_conn_mode_valid(struct drm_connector *connector,
  1009. struct drm_display_mode *mode,
  1010. void *display, const struct msm_resource_caps_info *avail_res)
  1011. {
  1012. struct dsi_display_mode dsi_mode;
  1013. struct dsi_display_mode *full_dsi_mode = NULL;
  1014. struct sde_connector_state *conn_state;
  1015. int rc;
  1016. if (!connector || !mode) {
  1017. DSI_ERR("Invalid params\n");
  1018. return MODE_ERROR;
  1019. }
  1020. convert_to_dsi_mode(mode, &dsi_mode);
  1021. conn_state = to_sde_connector_state(connector->state);
  1022. if (conn_state)
  1023. msm_parse_mode_priv_info(&conn_state->msm_mode, &dsi_mode);
  1024. rc = dsi_display_find_mode(display, &dsi_mode, NULL, &full_dsi_mode);
  1025. if (rc) {
  1026. DSI_ERR("could not find mode %s\n", mode->name);
  1027. return MODE_ERROR;
  1028. }
  1029. rc = dsi_display_validate_mode(display, full_dsi_mode,
  1030. DSI_VALIDATE_FLAG_ALLOW_ADJUST);
  1031. if (rc) {
  1032. DSI_ERR("mode not supported, rc=%d\n", rc);
  1033. return MODE_BAD;
  1034. }
  1035. return MODE_OK;
  1036. }
  1037. int dsi_conn_pre_kickoff(struct drm_connector *connector,
  1038. void *display,
  1039. struct msm_display_kickoff_params *params)
  1040. {
  1041. if (!connector || !display || !params) {
  1042. DSI_ERR("Invalid params\n");
  1043. return -EINVAL;
  1044. }
  1045. return dsi_display_pre_kickoff(connector, display, params);
  1046. }
  1047. int dsi_conn_prepare_commit(void *display,
  1048. struct msm_display_conn_params *params)
  1049. {
  1050. if (!display || !params) {
  1051. pr_err("Invalid params\n");
  1052. return -EINVAL;
  1053. }
  1054. return dsi_display_pre_commit(display, params);
  1055. }
  1056. void dsi_conn_enable_event(struct drm_connector *connector,
  1057. uint32_t event_idx, bool enable, void *display)
  1058. {
  1059. struct dsi_event_cb_info event_info;
  1060. memset(&event_info, 0, sizeof(event_info));
  1061. event_info.event_cb = sde_connector_trigger_event;
  1062. event_info.event_usr_ptr = connector;
  1063. dsi_display_enable_event(connector, display,
  1064. event_idx, &event_info, enable);
  1065. }
  1066. int dsi_conn_post_kickoff(struct drm_connector *connector,
  1067. struct msm_display_conn_params *params)
  1068. {
  1069. struct drm_encoder *encoder;
  1070. struct drm_bridge *bridge;
  1071. struct dsi_bridge *c_bridge;
  1072. struct dsi_display_mode adj_mode;
  1073. struct dsi_display *display;
  1074. struct dsi_display_ctrl *m_ctrl, *ctrl;
  1075. int i, rc = 0, ctrl_version;
  1076. bool enable;
  1077. struct dsi_dyn_clk_caps *dyn_clk_caps;
  1078. if (!connector || !connector->state) {
  1079. DSI_ERR("invalid connector or connector state\n");
  1080. return -EINVAL;
  1081. }
  1082. encoder = connector->state->best_encoder;
  1083. if (!encoder) {
  1084. DSI_DEBUG("best encoder is not available\n");
  1085. return 0;
  1086. }
  1087. bridge = drm_bridge_chain_get_first_bridge(encoder);
  1088. if (!bridge) {
  1089. DSI_DEBUG("bridge is not available\n");
  1090. return 0;
  1091. }
  1092. c_bridge = to_dsi_bridge(bridge);
  1093. adj_mode = c_bridge->dsi_mode;
  1094. display = c_bridge->display;
  1095. dyn_clk_caps = &(display->panel->dyn_clk_caps);
  1096. if (adj_mode.dsi_mode_flags & DSI_MODE_FLAG_VRR) {
  1097. m_ctrl = &display->ctrl[display->clk_master_idx];
  1098. ctrl_version = m_ctrl->ctrl->version;
  1099. rc = dsi_ctrl_timing_db_update(m_ctrl->ctrl, false);
  1100. if (rc) {
  1101. DSI_ERR("[%s] failed to dfps update rc=%d\n",
  1102. display->name, rc);
  1103. return -EINVAL;
  1104. }
  1105. /*
  1106. * When both DFPS and dynamic clock switch with constant
  1107. * fps features are enabled, wait for dynamic refresh done
  1108. * only in case of clock switch.
  1109. * In case where only fps changes, clock remains same.
  1110. * So, wait for dynamic refresh done is not required.
  1111. */
  1112. if ((ctrl_version >= DSI_CTRL_VERSION_2_5) &&
  1113. (dyn_clk_caps->maintain_const_fps) &&
  1114. (adj_mode.dsi_mode_flags & DSI_MODE_FLAG_DYN_CLK)) {
  1115. display_for_each_ctrl(i, display) {
  1116. ctrl = &display->ctrl[i];
  1117. rc = dsi_ctrl_wait4dynamic_refresh_done(
  1118. ctrl->ctrl);
  1119. if (rc)
  1120. DSI_ERR("wait4dfps refresh failed\n");
  1121. dsi_phy_dynamic_refresh_clear(ctrl->phy);
  1122. dsi_clk_disable_unprepare(&display->clock_info.pll_clks);
  1123. }
  1124. }
  1125. /* Update the rest of the controllers */
  1126. display_for_each_ctrl(i, display) {
  1127. ctrl = &display->ctrl[i];
  1128. if (!ctrl->ctrl || (ctrl == m_ctrl))
  1129. continue;
  1130. rc = dsi_ctrl_timing_db_update(ctrl->ctrl, false);
  1131. if (rc) {
  1132. DSI_ERR("[%s] failed to dfps update rc=%d\n",
  1133. display->name, rc);
  1134. return -EINVAL;
  1135. }
  1136. }
  1137. c_bridge->dsi_mode.dsi_mode_flags &= ~DSI_MODE_FLAG_VRR;
  1138. }
  1139. /* ensure dynamic clk switch flag is reset */
  1140. c_bridge->dsi_mode.dsi_mode_flags &= ~DSI_MODE_FLAG_DYN_CLK;
  1141. if (params->qsync_update) {
  1142. enable = (params->qsync_mode > 0) ? true : false;
  1143. display_for_each_ctrl(i, display)
  1144. dsi_ctrl_setup_avr(display->ctrl[i].ctrl, enable);
  1145. }
  1146. return 0;
  1147. }
  1148. struct dsi_bridge *dsi_drm_bridge_init(struct dsi_display *display,
  1149. struct drm_device *dev,
  1150. struct drm_encoder *encoder)
  1151. {
  1152. int rc = 0;
  1153. struct dsi_bridge *bridge;
  1154. bridge = kzalloc(sizeof(*bridge), GFP_KERNEL);
  1155. if (!bridge) {
  1156. rc = -ENOMEM;
  1157. goto error;
  1158. }
  1159. bridge->display = display;
  1160. bridge->base.funcs = &dsi_bridge_ops;
  1161. bridge->base.encoder = encoder;
  1162. rc = drm_bridge_attach(encoder, &bridge->base, NULL, 0);
  1163. if (rc) {
  1164. DSI_ERR("failed to attach bridge, rc=%d\n", rc);
  1165. goto error_free_bridge;
  1166. }
  1167. return bridge;
  1168. error_free_bridge:
  1169. kfree(bridge);
  1170. error:
  1171. return ERR_PTR(rc);
  1172. }
  1173. void dsi_drm_bridge_cleanup(struct dsi_bridge *bridge)
  1174. {
  1175. kfree(bridge);
  1176. }
  1177. static bool is_valid_poms_switch(struct dsi_display_mode *mode_a,
  1178. struct dsi_display_mode *mode_b)
  1179. {
  1180. /*
  1181. * POMS cannot happen in conjunction with any other type of mode set.
  1182. * Check to ensure FPS remains same between the modes and also
  1183. * resolution.
  1184. */
  1185. return((mode_a->timing.refresh_rate == mode_b->timing.refresh_rate) &&
  1186. (mode_a->timing.v_active == mode_b->timing.v_active) &&
  1187. (mode_a->timing.h_active == mode_b->timing.h_active));
  1188. }
  1189. void dsi_conn_set_allowed_mode_switch(struct drm_connector *connector,
  1190. void *display)
  1191. {
  1192. u32 mode_idx = 0, cmp_mode_idx = 0;
  1193. u32 common_mode_caps = 0;
  1194. struct drm_display_mode *drm_mode, *cmp_drm_mode;
  1195. struct dsi_display_mode dsi_mode, *panel_dsi_mode, *cmp_panel_dsi_mode;
  1196. struct list_head *mode_list = &connector->modes;
  1197. struct dsi_display *disp = display;
  1198. struct dsi_panel *panel;
  1199. int mode_count = 0, rc = 0;
  1200. struct dsi_display_mode_priv_info *dsi_mode_info, *cmp_dsi_mode_info;
  1201. bool allow_switch = false;
  1202. if (!disp || !disp->panel) {
  1203. DSI_ERR("invalid parameters");
  1204. return;
  1205. }
  1206. panel = disp->panel;
  1207. list_for_each_entry(drm_mode, &connector->modes, head)
  1208. mode_count++;
  1209. list_for_each_entry(drm_mode, &connector->modes, head) {
  1210. convert_to_dsi_mode(drm_mode, &dsi_mode);
  1211. rc = dsi_display_find_mode(display, &dsi_mode, NULL, &panel_dsi_mode);
  1212. if (rc)
  1213. return;
  1214. dsi_mode_info = panel_dsi_mode->priv_info;
  1215. dsi_mode_info->allowed_mode_switch |= BIT(mode_idx);
  1216. if (mode_idx == mode_count - 1)
  1217. break;
  1218. mode_list = mode_list->next;
  1219. cmp_mode_idx = 1;
  1220. list_for_each_entry(cmp_drm_mode, mode_list, head) {
  1221. if (&cmp_drm_mode->head == &connector->modes)
  1222. continue;
  1223. convert_to_dsi_mode(cmp_drm_mode, &dsi_mode);
  1224. rc = dsi_display_find_mode(display, &dsi_mode,
  1225. NULL, &cmp_panel_dsi_mode);
  1226. if (rc)
  1227. return;
  1228. cmp_dsi_mode_info = cmp_panel_dsi_mode->priv_info;
  1229. allow_switch = false;
  1230. common_mode_caps = (panel_dsi_mode->panel_mode_caps &
  1231. cmp_panel_dsi_mode->panel_mode_caps);
  1232. /*
  1233. * FPS switch among video modes, is only supported
  1234. * if DFPS or dynamic clocks are specified.
  1235. * Reject any mode switches between video mode timing
  1236. * nodes if support for those features is not present.
  1237. */
  1238. if (common_mode_caps & DSI_OP_CMD_MODE) {
  1239. allow_switch = true;
  1240. } else if ((common_mode_caps & DSI_OP_VIDEO_MODE) &&
  1241. (panel->dfps_caps.dfps_support ||
  1242. panel->dyn_clk_caps.dyn_clk_support)) {
  1243. allow_switch = true;
  1244. } else {
  1245. if (is_valid_poms_switch(panel_dsi_mode,
  1246. cmp_panel_dsi_mode))
  1247. allow_switch = true;
  1248. }
  1249. if (allow_switch) {
  1250. dsi_mode_info->allowed_mode_switch |=
  1251. BIT(mode_idx + cmp_mode_idx);
  1252. cmp_dsi_mode_info->allowed_mode_switch |=
  1253. BIT(mode_idx);
  1254. }
  1255. if ((mode_idx + cmp_mode_idx) >= mode_count - 1)
  1256. break;
  1257. cmp_mode_idx++;
  1258. }
  1259. mode_idx++;
  1260. }
  1261. }
  1262. int dsi_conn_set_dyn_bit_clk(struct drm_connector *connector, uint64_t value)
  1263. {
  1264. struct sde_connector *c_conn = NULL;
  1265. struct dsi_display *display;
  1266. if (!connector) {
  1267. DSI_ERR("invalid connector\n");
  1268. return -EINVAL;
  1269. }
  1270. c_conn = to_sde_connector(connector);
  1271. display = (struct dsi_display *) c_conn->display;
  1272. display->dyn_bit_clk = value;
  1273. display->dyn_bit_clk_pending = true;
  1274. SDE_EVT32(display->dyn_bit_clk);
  1275. DSI_DEBUG("update dynamic bit clock rate to %llu\n", display->dyn_bit_clk);
  1276. return 0;
  1277. }