dp_mst_drm.c 60 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4. * Copyright (c) 2018-2021, The Linux Foundation. All rights reserved.
  5. */
  6. /*
  7. * Copyright © 2014 Red Hat.
  8. *
  9. * Permission to use, copy, modify, distribute, and sell this software and its
  10. * documentation for any purpose is hereby granted without fee, provided that
  11. * the above copyright notice appear in all copies and that both that copyright
  12. * notice and this permission notice appear in supporting documentation, and
  13. * that the name of the copyright holders not be used in advertising or
  14. * publicity pertaining to distribution of the software without specific,
  15. * written prior permission. The copyright holders make no representations
  16. * about the suitability of this software for any purpose. It is provided "as
  17. * is" without express or implied warranty.
  18. *
  19. * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  20. * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  21. * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  22. * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  23. * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  24. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  25. * OF THIS SOFTWARE.
  26. */
  27. #include <linux/kernel.h>
  28. #include <linux/init.h>
  29. #include <linux/errno.h>
  30. #include <linux/version.h>
  31. #include <drm/drm_atomic_helper.h>
  32. #include <drm/drm_atomic.h>
  33. #include <drm/drm_crtc.h>
  34. #include <drm/drm_fixed.h>
  35. #include <drm/drm_connector.h>
  36. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  37. #include <drm/display/drm_dp_helper.h>
  38. #include <drm/display/drm_dp_mst_helper.h>
  39. #else
  40. #include <drm/drm_dp_helper.h>
  41. #include <drm/drm_dp_mst_helper.h>
  42. #endif
  43. #include <linux/version.h>
  44. #include "msm_drv.h"
  45. #include "msm_kms.h"
  46. #include "sde_connector.h"
  47. #include "dp_drm.h"
  48. #include "dp_debug.h"
  49. #include "dp_parser.h"
  50. #define DP_MST_DEBUG(fmt, ...) DP_DEBUG(fmt, ##__VA_ARGS__)
  51. #define DP_MST_INFO(fmt, ...) DP_INFO(fmt, ##__VA_ARGS__)
  52. #define DP_MST_DEBUG_V(fmt, ...) DP_DEBUG_V(fmt, ##__VA_ARGS__)
  53. #define DP_MST_INFO_V(fmt, ...) DP_INFO_V(fmt, ##__VA_ARGS__)
  54. #define MAX_DP_MST_DRM_ENCODERS 2
  55. #define MAX_DP_MST_DRM_BRIDGES 2
  56. #define HPD_STRING_SIZE 30
  57. #define DP_MST_CONN_ID(bridge) ((bridge)->connector ? \
  58. (bridge)->connector->base.id : 0)
  59. struct dp_drm_mst_fw_helper_ops {
  60. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  61. int (*atomic_find_time_slots)(struct drm_atomic_state *state,
  62. struct drm_dp_mst_topology_mgr *mgr,
  63. struct drm_dp_mst_port *port,
  64. int pbn);
  65. int (*update_payload_part1)(struct drm_dp_mst_topology_mgr *mgr,
  66. struct drm_dp_mst_topology_state *mst_state,
  67. struct drm_dp_mst_atomic_payload *payload);
  68. int (*update_payload_part2)(struct drm_dp_mst_topology_mgr *mgr,
  69. struct drm_atomic_state *state,
  70. struct drm_dp_mst_atomic_payload *payload);
  71. #if (KERNEL_VERSION(6, 1, 25) <= LINUX_VERSION_CODE)
  72. void (*reset_vcpi_slots)(struct drm_dp_mst_topology_mgr *mgr,
  73. struct drm_dp_mst_topology_state *mst_state,
  74. const struct drm_dp_mst_atomic_payload *old_payload,
  75. struct drm_dp_mst_atomic_payload *new_payload);
  76. #else
  77. void (*reset_vcpi_slots)(struct drm_dp_mst_topology_mgr *mgr,
  78. struct drm_dp_mst_topology_state *mst_state,
  79. struct drm_dp_mst_atomic_payload *payload);
  80. #endif
  81. #else
  82. int (*atomic_find_vcpi_slots)(struct drm_atomic_state *state,
  83. struct drm_dp_mst_topology_mgr *mgr,
  84. struct drm_dp_mst_port *port,
  85. int pbn, int pbn_div);
  86. int (*update_payload_part1)(struct drm_dp_mst_topology_mgr *mgr);
  87. int (*update_payload_part2)(struct drm_dp_mst_topology_mgr *mgr);
  88. void (*reset_vcpi_slots)(struct drm_dp_mst_topology_mgr *mgr,
  89. struct drm_dp_mst_port *port);
  90. #endif
  91. int (*atomic_release_time_slots)(struct drm_atomic_state *state,
  92. struct drm_dp_mst_topology_mgr *mgr,
  93. struct drm_dp_mst_port *port);
  94. int (*calc_pbn_mode)(struct dp_display_mode *dp_mode);
  95. int (*find_vcpi_slots)(struct drm_dp_mst_topology_mgr *mgr, int pbn);
  96. bool (*allocate_vcpi)(struct drm_dp_mst_topology_mgr *mgr,
  97. struct drm_dp_mst_port *port,
  98. int pbn, int slots);
  99. int (*check_act_status)(struct drm_dp_mst_topology_mgr *mgr);
  100. int (*detect_port_ctx)(
  101. struct drm_connector *connector,
  102. struct drm_modeset_acquire_ctx *ctx,
  103. struct drm_dp_mst_topology_mgr *mgr,
  104. struct drm_dp_mst_port *port);
  105. struct edid *(*get_edid)(struct drm_connector *connector,
  106. struct drm_dp_mst_topology_mgr *mgr,
  107. struct drm_dp_mst_port *port);
  108. int (*topology_mgr_set_mst)(struct drm_dp_mst_topology_mgr *mgr,
  109. bool mst_state);
  110. void (*get_vcpi_info)(struct drm_dp_mst_topology_mgr *mgr,
  111. int vcpi, int *start_slot, int *num_slots);
  112. void (*deallocate_vcpi)(struct drm_dp_mst_topology_mgr *mgr,
  113. struct drm_dp_mst_port *port);
  114. };
  115. struct dp_mst_sim_port_edid {
  116. u8 port_number;
  117. u8 edid[SZ_256];
  118. bool valid;
  119. };
  120. struct dp_mst_bridge {
  121. struct drm_bridge base;
  122. struct drm_private_obj obj;
  123. u32 id;
  124. bool in_use;
  125. struct dp_display *display;
  126. struct drm_encoder *encoder;
  127. struct drm_display_mode drm_mode;
  128. struct dp_display_mode dp_mode;
  129. struct drm_connector *connector;
  130. void *dp_panel;
  131. int vcpi;
  132. int pbn;
  133. int num_slots;
  134. int start_slot;
  135. u32 fixed_port_num;
  136. bool fixed_port_added;
  137. struct drm_connector *fixed_connector;
  138. };
  139. struct dp_mst_bridge_state {
  140. struct drm_private_state base;
  141. struct drm_connector *connector;
  142. void *dp_panel;
  143. int num_slots;
  144. };
  145. struct dp_mst_private {
  146. bool mst_initialized;
  147. struct dp_mst_caps caps;
  148. struct drm_dp_mst_topology_mgr mst_mgr;
  149. struct dp_mst_bridge mst_bridge[MAX_DP_MST_DRM_BRIDGES];
  150. struct dp_display *dp_display;
  151. const struct dp_drm_mst_fw_helper_ops *mst_fw_cbs;
  152. struct mutex mst_lock;
  153. struct mutex edid_lock;
  154. enum dp_drv_state state;
  155. bool mst_session_state;
  156. };
  157. struct dp_mst_encoder_info_cache {
  158. u8 cnt;
  159. struct drm_encoder *mst_enc[MAX_DP_MST_DRM_BRIDGES];
  160. };
  161. #define to_dp_mst_bridge(x) container_of((x), struct dp_mst_bridge, base)
  162. #define to_dp_mst_bridge_priv(x) \
  163. container_of((x), struct dp_mst_bridge, obj)
  164. #define to_dp_mst_bridge_priv_state(x) \
  165. container_of((x), struct dp_mst_bridge_state, base)
  166. #define to_dp_mst_bridge_state(x) \
  167. to_dp_mst_bridge_priv_state((x)->obj.state)
  168. struct dp_mst_private dp_mst;
  169. struct dp_mst_encoder_info_cache dp_mst_enc_cache;
  170. static struct drm_private_state *dp_mst_duplicate_bridge_state(
  171. struct drm_private_obj *obj)
  172. {
  173. struct dp_mst_bridge_state *state;
  174. state = kmemdup(obj->state, sizeof(*state), GFP_KERNEL);
  175. if (!state)
  176. return NULL;
  177. __drm_atomic_helper_private_obj_duplicate_state(obj, &state->base);
  178. return &state->base;
  179. }
  180. static void dp_mst_destroy_bridge_state(struct drm_private_obj *obj,
  181. struct drm_private_state *state)
  182. {
  183. struct dp_mst_bridge_state *priv_state =
  184. to_dp_mst_bridge_priv_state(state);
  185. kfree(priv_state);
  186. }
  187. static const struct drm_private_state_funcs dp_mst_bridge_state_funcs = {
  188. .atomic_duplicate_state = dp_mst_duplicate_bridge_state,
  189. .atomic_destroy_state = dp_mst_destroy_bridge_state,
  190. };
  191. static struct dp_mst_bridge_state *dp_mst_get_bridge_atomic_state(
  192. struct drm_atomic_state *state, struct dp_mst_bridge *bridge)
  193. {
  194. struct drm_device *dev = bridge->base.dev;
  195. WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  196. return to_dp_mst_bridge_priv_state(
  197. drm_atomic_get_private_obj_state(state, &bridge->obj));
  198. }
  199. static int dp_mst_detect_port(
  200. struct drm_connector *connector,
  201. struct drm_modeset_acquire_ctx *ctx,
  202. struct drm_dp_mst_topology_mgr *mgr,
  203. struct drm_dp_mst_port *port)
  204. {
  205. struct dp_mst_private *mst = container_of(mgr,
  206. struct dp_mst_private, mst_mgr);
  207. int status = connector_status_disconnected;
  208. if (mst->mst_session_state)
  209. status = drm_dp_mst_detect_port(connector, ctx, mgr, port);
  210. DP_MST_DEBUG("mst port status: %d, session state: %d\n",
  211. status, mst->mst_session_state);
  212. return status;
  213. }
  214. static void _dp_mst_get_vcpi_info(
  215. struct drm_dp_mst_topology_mgr *mgr,
  216. int vcpi, int *start_slot, int *num_slots)
  217. {
  218. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  219. struct drm_dp_mst_topology_state *state;
  220. struct drm_dp_mst_atomic_payload *payload;
  221. #else
  222. int i;
  223. #endif
  224. *start_slot = 0;
  225. *num_slots = 0;
  226. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  227. state = to_drm_dp_mst_topology_state(mgr->base.state);
  228. list_for_each_entry(payload, &state->payloads, next) {
  229. if (payload->vcpi == vcpi) {
  230. *start_slot = payload->vc_start_slot;
  231. *num_slots = payload->time_slots;
  232. break;
  233. }
  234. }
  235. #else
  236. mutex_lock(&mgr->payload_lock);
  237. for (i = 0; i < mgr->max_payloads; i++) {
  238. if (mgr->payloads[i].vcpi == vcpi) {
  239. *start_slot = mgr->payloads[i].start_slot;
  240. *num_slots = mgr->payloads[i].num_slots;
  241. break;
  242. }
  243. }
  244. mutex_unlock(&mgr->payload_lock);
  245. #endif
  246. DP_INFO("vcpi_info. vcpi:%d, start_slot:%d, num_slots:%d\n",
  247. vcpi, *start_slot, *num_slots);
  248. }
  249. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  250. /**
  251. * dp_mst_find_vcpi_slots() - Find VCPI slots for this PBN value
  252. * @mgr: manager to use
  253. * @pbn: payload bandwidth to convert into slots.
  254. *
  255. * Calculate the number of VCPI slots that will be required for the given PBN
  256. * value.
  257. *
  258. * RETURNS:
  259. * The total slots required for this port, or error.
  260. */
  261. static int dp_mst_find_vcpi_slots(struct drm_dp_mst_topology_mgr *mgr, int pbn)
  262. {
  263. int num_slots;
  264. struct drm_dp_mst_topology_state *state;
  265. state = to_drm_dp_mst_topology_state(mgr->base.state);
  266. num_slots = DIV_ROUND_UP(pbn, state->pbn_div);
  267. /* max. time slots - one slot for MTP header */
  268. if (num_slots > 63)
  269. return -ENOSPC;
  270. return num_slots;
  271. }
  272. #endif
  273. static int dp_mst_calc_pbn_mode(struct dp_display_mode *dp_mode)
  274. {
  275. int pbn, bpp;
  276. bool dsc_en;
  277. s64 pbn_fp;
  278. struct dp_panel_info *pinfo = &dp_mode->timing;
  279. dsc_en = pinfo->comp_info.enabled;
  280. bpp = dsc_en ? DSC_BPP(pinfo->comp_info.dsc_info.config) : pinfo->bpp;
  281. pbn = drm_dp_calc_pbn_mode(pinfo->pixel_clk_khz, bpp, false);
  282. pbn_fp = drm_fixp_from_fraction(pbn, 1);
  283. pinfo->pbn_no_overhead = pbn;
  284. if (dsc_en)
  285. pbn_fp = drm_fixp_mul(pbn_fp, dp_mode->dsc_overhead_fp);
  286. if (dp_mode->fec_overhead_fp)
  287. pbn_fp = drm_fixp_mul(pbn_fp, dp_mode->fec_overhead_fp);
  288. pbn = drm_fixp2int(pbn_fp);
  289. pinfo->pbn = pbn;
  290. DP_DEBUG_V("pbn before overhead:%d pbn final:%d, bpp:%d\n", pinfo->pbn_no_overhead, pbn,
  291. bpp);
  292. return pbn;
  293. }
  294. static const struct dp_drm_mst_fw_helper_ops drm_dp_mst_fw_helper_ops = {
  295. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  296. .calc_pbn_mode = dp_mst_calc_pbn_mode,
  297. .find_vcpi_slots = dp_mst_find_vcpi_slots,
  298. .atomic_find_time_slots = drm_dp_atomic_find_time_slots,
  299. .update_payload_part1 = drm_dp_add_payload_part1,
  300. .check_act_status = drm_dp_check_act_status,
  301. .update_payload_part2 = drm_dp_add_payload_part2,
  302. .detect_port_ctx = dp_mst_detect_port,
  303. .get_edid = drm_dp_mst_get_edid,
  304. .topology_mgr_set_mst = drm_dp_mst_topology_mgr_set_mst,
  305. .get_vcpi_info = _dp_mst_get_vcpi_info,
  306. .atomic_release_time_slots = drm_dp_atomic_release_time_slots,
  307. .reset_vcpi_slots = drm_dp_remove_payload,
  308. #else
  309. .calc_pbn_mode = dp_mst_calc_pbn_mode,
  310. .find_vcpi_slots = drm_dp_find_vcpi_slots,
  311. .atomic_find_vcpi_slots = drm_dp_atomic_find_vcpi_slots,
  312. .allocate_vcpi = drm_dp_mst_allocate_vcpi,
  313. .update_payload_part1 = drm_dp_update_payload_part1,
  314. .check_act_status = drm_dp_check_act_status,
  315. .update_payload_part2 = drm_dp_update_payload_part2,
  316. .detect_port_ctx = dp_mst_detect_port,
  317. .get_edid = drm_dp_mst_get_edid,
  318. .topology_mgr_set_mst = drm_dp_mst_topology_mgr_set_mst,
  319. .get_vcpi_info = _dp_mst_get_vcpi_info,
  320. .atomic_release_time_slots = drm_dp_atomic_release_vcpi_slots,
  321. .reset_vcpi_slots = drm_dp_mst_reset_vcpi_slots,
  322. .deallocate_vcpi = drm_dp_mst_deallocate_vcpi,
  323. #endif
  324. };
  325. /* DP MST Bridge OPs */
  326. static int dp_mst_bridge_attach(struct drm_bridge *dp_bridge,
  327. enum drm_bridge_attach_flags flags)
  328. {
  329. struct dp_mst_bridge *bridge;
  330. DP_MST_DEBUG_V("enter\n");
  331. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  332. if (!dp_bridge) {
  333. DP_ERR("Invalid params\n");
  334. return -EINVAL;
  335. }
  336. bridge = to_dp_mst_bridge(dp_bridge);
  337. DP_MST_DEBUG("mst bridge [%d] attached\n", bridge->id);
  338. return 0;
  339. }
  340. static bool dp_mst_bridge_mode_fixup(struct drm_bridge *drm_bridge,
  341. const struct drm_display_mode *mode,
  342. struct drm_display_mode *adjusted_mode)
  343. {
  344. bool ret = true;
  345. struct dp_display_mode dp_mode;
  346. struct dp_mst_bridge *bridge;
  347. struct dp_display *dp;
  348. struct drm_crtc_state *crtc_state;
  349. struct dp_mst_bridge_state *bridge_state;
  350. DP_MST_DEBUG_V("enter\n");
  351. if (!drm_bridge || !mode || !adjusted_mode) {
  352. DP_ERR("Invalid params\n");
  353. ret = false;
  354. goto end;
  355. }
  356. bridge = to_dp_mst_bridge(drm_bridge);
  357. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  358. crtc_state = container_of(mode, struct drm_crtc_state, mode);
  359. bridge_state = dp_mst_get_bridge_atomic_state(crtc_state->state,
  360. bridge);
  361. if (IS_ERR(bridge_state)) {
  362. DP_ERR("invalid bridge state\n");
  363. ret = false;
  364. goto end;
  365. }
  366. if (!bridge_state->dp_panel) {
  367. DP_ERR("Invalid dp_panel\n");
  368. ret = false;
  369. goto end;
  370. }
  371. dp = bridge->display;
  372. dp->convert_to_dp_mode(dp, bridge_state->dp_panel, mode, &dp_mode);
  373. dp->clear_reservation(dp, bridge_state->dp_panel);
  374. convert_to_drm_mode(&dp_mode, adjusted_mode);
  375. DP_MST_DEBUG("mst bridge [%d] mode:%s fixup\n", bridge->id, mode->name);
  376. end:
  377. return ret;
  378. }
  379. static int _dp_mst_compute_config(struct drm_atomic_state *state,
  380. struct dp_mst_private *mst, struct drm_connector *connector,
  381. struct dp_display_mode *mode)
  382. {
  383. int slots = 0, pbn;
  384. struct sde_connector *c_conn = to_sde_connector(connector);
  385. int rc = 0;
  386. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  387. struct drm_dp_mst_topology_state *mst_state;
  388. #endif
  389. DP_MST_DEBUG_V("enter\n");
  390. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  391. pbn = mst->mst_fw_cbs->calc_pbn_mode(mode);
  392. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  393. mst_state = to_drm_dp_mst_topology_state(mst->mst_mgr.base.state);
  394. if (!mst_state->pbn_div)
  395. mst_state->pbn_div = mst->dp_display->get_mst_pbn_div(mst->dp_display);
  396. rc = mst->mst_fw_cbs->atomic_find_time_slots(state, &mst->mst_mgr, c_conn->mst_port, pbn);
  397. if (rc < 0) {
  398. DP_ERR("conn:%d failed to find vcpi slots. pbn:%d, rc:%d\n",
  399. connector->base.id, pbn, rc);
  400. goto end;
  401. }
  402. slots = rc;
  403. rc = drm_dp_mst_atomic_check(state);
  404. if (rc) {
  405. DP_ERR("conn:%d mst atomic check failed: rc=%d\n", connector->base.id, rc);
  406. slots = 0;
  407. goto end;
  408. }
  409. #else
  410. slots = mst->mst_fw_cbs->atomic_find_vcpi_slots(state,
  411. &mst->mst_mgr, c_conn->mst_port, pbn, 0);
  412. if (slots < 0) {
  413. DP_ERR("conn:%d failed to find vcpi slots. pbn:%d, slots:%d\n",
  414. connector->base.id, pbn, slots);
  415. rc = slots;
  416. slots = 0;
  417. goto end;
  418. }
  419. #endif
  420. end:
  421. DP_MST_DEBUG("conn:%d pbn:%d slots:%d rc:%d\n", connector->base.id, pbn, slots, rc);
  422. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id, pbn, slots, rc);
  423. return (rc < 0 ? rc : slots);
  424. }
  425. static void _dp_mst_update_timeslots(struct dp_mst_private *mst,
  426. struct dp_mst_bridge *mst_bridge, struct drm_dp_mst_port *port)
  427. {
  428. int i;
  429. struct dp_mst_bridge *dp_bridge;
  430. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  431. struct drm_dp_mst_topology_state *mst_state;
  432. struct drm_dp_mst_atomic_payload *payload;
  433. int prev_start = 0;
  434. int prev_slots = 0;
  435. mst_state = to_drm_dp_mst_topology_state(mst->mst_mgr.base.state);
  436. payload = drm_atomic_get_mst_payload_state(mst_state, port);
  437. if (!payload) {
  438. DP_ERR("mst bridge [%d] update_timeslots failed, null payload\n",
  439. mst_bridge->id);
  440. return;
  441. }
  442. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  443. dp_bridge = &mst->mst_bridge[i];
  444. if (mst_bridge == dp_bridge) {
  445. /*
  446. * When a payload was removed make sure to move any payloads after it
  447. * to the left so all payloads are aligned to the left.
  448. */
  449. if (payload->vc_start_slot < 0) {
  450. // cache the payload
  451. prev_start = dp_bridge->start_slot;
  452. prev_slots = dp_bridge->num_slots;
  453. dp_bridge->pbn = 0;
  454. dp_bridge->start_slot = 1;
  455. dp_bridge->num_slots = 0;
  456. dp_bridge->vcpi = 0;
  457. } else { //add payload
  458. dp_bridge->pbn = payload->pbn;
  459. dp_bridge->start_slot = payload->vc_start_slot;
  460. dp_bridge->num_slots = payload->time_slots;
  461. dp_bridge->vcpi = payload->vcpi;
  462. }
  463. }
  464. }
  465. // Now commit all the updated payloads
  466. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  467. dp_bridge = &mst->mst_bridge[i];
  468. //Shift payloads to the left if there was a removed payload.
  469. if ((payload->vc_start_slot < 0) && (dp_bridge->start_slot > prev_start)) {
  470. dp_bridge->start_slot -= prev_slots;
  471. }
  472. mst->dp_display->set_stream_info(mst->dp_display, dp_bridge->dp_panel,
  473. dp_bridge->id, dp_bridge->start_slot, dp_bridge->num_slots,
  474. dp_bridge->pbn, dp_bridge->vcpi);
  475. DP_INFO("conn:%d vcpi:%d start_slot:%d num_slots:%d, pbn:%d\n",
  476. DP_MST_CONN_ID(dp_bridge), dp_bridge->vcpi, dp_bridge->start_slot,
  477. dp_bridge->num_slots, dp_bridge->pbn);
  478. }
  479. #else
  480. int pbn, start_slot, num_slots;
  481. mst->mst_fw_cbs->update_payload_part1(&mst->mst_mgr);
  482. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  483. dp_bridge = &mst->mst_bridge[i];
  484. pbn = 0;
  485. start_slot = 0;
  486. num_slots = 0;
  487. if (dp_bridge->vcpi) {
  488. mst->mst_fw_cbs->get_vcpi_info(&mst->mst_mgr,
  489. dp_bridge->vcpi,
  490. &start_slot, &num_slots);
  491. pbn = dp_bridge->pbn;
  492. }
  493. if (mst_bridge == dp_bridge)
  494. dp_bridge->num_slots = num_slots;
  495. mst->dp_display->set_stream_info(mst->dp_display,
  496. dp_bridge->dp_panel,
  497. dp_bridge->id, start_slot, num_slots, pbn,
  498. dp_bridge->vcpi);
  499. DP_INFO("conn:%d vcpi:%d start_slot:%d num_slots:%d, pbn:%d\n",
  500. DP_MST_CONN_ID(dp_bridge), dp_bridge->vcpi,
  501. start_slot, num_slots, pbn);
  502. }
  503. #endif
  504. }
  505. static void _dp_mst_update_single_timeslot(struct dp_mst_private *mst,
  506. struct dp_mst_bridge *mst_bridge)
  507. {
  508. int pbn = 0, start_slot = 0, num_slots = 0;
  509. if (mst->state == PM_SUSPEND) {
  510. if (mst_bridge->vcpi) {
  511. mst->mst_fw_cbs->get_vcpi_info(&mst->mst_mgr,
  512. mst_bridge->vcpi,
  513. &start_slot, &num_slots);
  514. pbn = mst_bridge->pbn;
  515. }
  516. mst_bridge->num_slots = num_slots;
  517. mst->dp_display->set_stream_info(mst->dp_display,
  518. mst_bridge->dp_panel,
  519. mst_bridge->id, start_slot, num_slots, pbn,
  520. mst_bridge->vcpi);
  521. }
  522. }
  523. static int _dp_mst_bridge_pre_enable_part1(struct dp_mst_bridge *dp_bridge)
  524. {
  525. struct dp_display *dp_display = dp_bridge->display;
  526. struct sde_connector *c_conn =
  527. to_sde_connector(dp_bridge->connector);
  528. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  529. struct drm_dp_mst_port *port = c_conn->mst_port;
  530. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  531. struct drm_dp_mst_topology_state *mst_state;
  532. struct drm_dp_mst_atomic_payload *payload;
  533. #endif
  534. bool ret;
  535. int pbn, slots;
  536. int rc = 0;
  537. DP_MST_DEBUG_V("enter\n");
  538. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(dp_bridge));
  539. /* skip mst specific disable operations during suspend */
  540. if (mst->state == PM_SUSPEND) {
  541. dp_display->wakeup_phy_layer(dp_display, true);
  542. drm_dp_send_power_updown_phy(&mst->mst_mgr, port, true);
  543. dp_display->wakeup_phy_layer(dp_display, false);
  544. _dp_mst_update_single_timeslot(mst, dp_bridge);
  545. return rc;
  546. }
  547. pbn = mst->mst_fw_cbs->calc_pbn_mode(&dp_bridge->dp_mode);
  548. slots = mst->mst_fw_cbs->find_vcpi_slots(&mst->mst_mgr, pbn);
  549. DP_INFO("conn:%d pbn:%d, slots:%d\n", DP_MST_CONN_ID(dp_bridge), pbn, slots);
  550. ret = false;
  551. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  552. mst_state = to_drm_dp_mst_topology_state(mst->mst_mgr.base.state);
  553. payload = drm_atomic_get_mst_payload_state(mst_state, port);
  554. if (!payload || payload->time_slots <= 0) {
  555. DP_ERR("time slots not allocated for conn:%d\n", DP_MST_CONN_ID(dp_bridge));
  556. rc = -EINVAL;
  557. goto end;
  558. }
  559. drm_dp_mst_update_slots(mst_state, DP_CAP_ANSI_8B10B);
  560. rc = mst->mst_fw_cbs->update_payload_part1(&mst->mst_mgr,
  561. mst_state, payload);
  562. if (rc) {
  563. DP_ERR("payload allocation failure for conn:%d\n", DP_MST_CONN_ID(dp_bridge));
  564. goto end;
  565. }
  566. #else
  567. ret = mst->mst_fw_cbs->allocate_vcpi(&mst->mst_mgr, port, pbn, slots);
  568. if (!ret) {
  569. DP_ERR("mst: failed to allocate vcpi. bridge:%d\n", dp_bridge->id);
  570. rc = -EINVAL;
  571. goto end;
  572. }
  573. dp_bridge->vcpi = port->vcpi.vcpi;
  574. dp_bridge->pbn = pbn;
  575. #endif
  576. _dp_mst_update_timeslots(mst, dp_bridge, port);
  577. end:
  578. return rc;
  579. }
  580. static void _dp_mst_bridge_pre_enable_part2(struct dp_mst_bridge *dp_bridge)
  581. {
  582. struct dp_display *dp_display = dp_bridge->display;
  583. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  584. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  585. struct sde_connector *c_conn = to_sde_connector(dp_bridge->connector);
  586. struct drm_dp_mst_port *port = c_conn->mst_port;
  587. struct drm_dp_mst_topology_state *mst_state;
  588. struct drm_dp_mst_atomic_payload *payload;
  589. #endif
  590. DP_MST_DEBUG_V("enter\n");
  591. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(dp_bridge));
  592. /* skip mst specific disable operations during suspend */
  593. if (mst->state == PM_SUSPEND)
  594. return;
  595. mst->mst_fw_cbs->check_act_status(&mst->mst_mgr);
  596. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  597. mst_state = to_drm_dp_mst_topology_state(mst->mst_mgr.base.state);
  598. payload = drm_atomic_get_mst_payload_state(mst_state, port);
  599. if (!payload) {
  600. DP_ERR("mst bridge [%d] _pre enable part-2 failed, null payload\n", dp_bridge->id);
  601. return;
  602. }
  603. if (!payload->port) {
  604. DP_ERR("mst bridge [%d] _pre enable part-2 failed, null port\n", dp_bridge->id);
  605. return;
  606. }
  607. if (!payload->port->connector) {
  608. DP_ERR("mst bridge [%d] _pre enable part-2 failed, null connector\n",
  609. dp_bridge->id);
  610. return;
  611. }
  612. mst->mst_fw_cbs->update_payload_part2(&mst->mst_mgr, mst_state->base.state, payload);
  613. #else
  614. mst->mst_fw_cbs->update_payload_part2(&mst->mst_mgr);
  615. #endif
  616. DP_MST_DEBUG("mst bridge [%d] _pre enable part-2 complete\n",
  617. dp_bridge->id);
  618. }
  619. static void _dp_mst_bridge_pre_disable_part1(struct dp_mst_bridge *dp_bridge)
  620. {
  621. struct dp_display *dp_display = dp_bridge->display;
  622. struct sde_connector *c_conn =
  623. to_sde_connector(dp_bridge->connector);
  624. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  625. struct drm_dp_mst_port *port = c_conn->mst_port;
  626. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  627. struct drm_dp_mst_topology_state *mst_state;
  628. struct drm_dp_mst_atomic_payload *payload;
  629. #endif
  630. DP_MST_DEBUG_V("enter\n");
  631. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(dp_bridge));
  632. /* skip mst specific disable operations during suspend */
  633. if (mst->state == PM_SUSPEND) {
  634. _dp_mst_update_single_timeslot(mst, dp_bridge);
  635. return;
  636. }
  637. #if (KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE)
  638. mst_state = to_drm_dp_mst_topology_state(mst->mst_mgr.base.state);
  639. payload = drm_atomic_get_mst_payload_state(mst_state, port);
  640. if (!payload) {
  641. DP_ERR("mst bridge [%d] _pre disable part-1 failed, null payload\n",
  642. dp_bridge->id);
  643. return;
  644. }
  645. #if (KERNEL_VERSION(6, 1, 25) <= LINUX_VERSION_CODE)
  646. mst->mst_fw_cbs->reset_vcpi_slots(&mst->mst_mgr, mst_state, payload, payload);
  647. #else
  648. mst->mst_fw_cbs->reset_vcpi_slots(&mst->mst_mgr, mst_state, payload);
  649. #endif
  650. #else
  651. mst->mst_fw_cbs->reset_vcpi_slots(&mst->mst_mgr, port);
  652. #endif
  653. _dp_mst_update_timeslots(mst, dp_bridge, port);
  654. DP_MST_DEBUG("mst bridge [%d] _pre disable part-1 complete\n",
  655. dp_bridge->id);
  656. }
  657. static void _dp_mst_bridge_pre_disable_part2(struct dp_mst_bridge *dp_bridge)
  658. {
  659. struct dp_display *dp_display = dp_bridge->display;
  660. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  661. struct sde_connector *c_conn =
  662. to_sde_connector(dp_bridge->connector);
  663. struct drm_dp_mst_port *port = c_conn->mst_port;
  664. DP_MST_DEBUG_V("enter\n");
  665. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(dp_bridge));
  666. /* skip mst specific disable operations during suspend */
  667. if (mst->state == PM_SUSPEND) {
  668. dp_display->wakeup_phy_layer(dp_display, true);
  669. drm_dp_send_power_updown_phy(&mst->mst_mgr, port, false);
  670. dp_display->wakeup_phy_layer(dp_display, false);
  671. return;
  672. }
  673. mst->mst_fw_cbs->check_act_status(&mst->mst_mgr);
  674. #if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
  675. mst->mst_fw_cbs->update_payload_part2(&mst->mst_mgr);
  676. port->vcpi.vcpi = dp_bridge->vcpi;
  677. mst->mst_fw_cbs->deallocate_vcpi(&mst->mst_mgr, port);
  678. dp_bridge->vcpi = 0;
  679. dp_bridge->pbn = 0;
  680. #endif
  681. DP_MST_DEBUG("mst bridge [%d] _pre disable part-2 complete\n",
  682. dp_bridge->id);
  683. }
  684. static void dp_mst_bridge_pre_enable(struct drm_bridge *drm_bridge)
  685. {
  686. int rc = 0;
  687. struct dp_mst_bridge *bridge;
  688. struct dp_display *dp;
  689. struct dp_mst_private *mst;
  690. if (!drm_bridge) {
  691. DP_ERR("Invalid params\n");
  692. return;
  693. }
  694. DP_MST_DEBUG_V("enter\n");
  695. bridge = to_dp_mst_bridge(drm_bridge);
  696. dp = bridge->display;
  697. if (!bridge->connector) {
  698. DP_ERR("Invalid connector\n");
  699. return;
  700. }
  701. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  702. mst = dp->dp_mst_prv_info;
  703. mutex_lock(&mst->mst_lock);
  704. /* By this point mode should have been validated through mode_fixup */
  705. rc = dp->set_mode(dp, bridge->dp_panel, &bridge->dp_mode);
  706. if (rc) {
  707. DP_ERR("[%d] failed to perform a mode set, rc=%d\n",
  708. bridge->id, rc);
  709. goto end;
  710. }
  711. rc = dp->prepare(dp, bridge->dp_panel);
  712. if (rc) {
  713. DP_ERR("[%d] DP display prepare failed, rc=%d\n",
  714. bridge->id, rc);
  715. goto end;
  716. }
  717. rc = _dp_mst_bridge_pre_enable_part1(bridge);
  718. if (rc) {
  719. DP_ERR("[%d] DP display pre-enable failed, rc=%d\n", bridge->id, rc);
  720. dp->unprepare(dp, bridge->dp_panel);
  721. goto end;
  722. }
  723. rc = dp->enable(dp, bridge->dp_panel);
  724. if (rc) {
  725. DP_ERR("[%d] DP display enable failed, rc=%d\n",
  726. bridge->id, rc);
  727. dp->unprepare(dp, bridge->dp_panel);
  728. goto end;
  729. } else {
  730. _dp_mst_bridge_pre_enable_part2(bridge);
  731. }
  732. DP_MST_INFO("conn:%d mode:%s fps:%d dsc:%d vcpi:%d slots:%d to %d\n",
  733. DP_MST_CONN_ID(bridge), bridge->drm_mode.name,
  734. drm_mode_vrefresh(&bridge->drm_mode),
  735. bridge->dp_mode.timing.comp_info.enabled,
  736. bridge->vcpi, bridge->start_slot,
  737. bridge->start_slot + bridge->num_slots);
  738. end:
  739. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, DP_MST_CONN_ID(bridge));
  740. mutex_unlock(&mst->mst_lock);
  741. }
  742. static void dp_mst_bridge_enable(struct drm_bridge *drm_bridge)
  743. {
  744. int rc = 0;
  745. struct dp_mst_bridge *bridge;
  746. struct dp_display *dp;
  747. if (!drm_bridge) {
  748. DP_ERR("Invalid params\n");
  749. return;
  750. }
  751. bridge = to_dp_mst_bridge(drm_bridge);
  752. if (!bridge->connector) {
  753. DP_ERR("Invalid connector\n");
  754. return;
  755. }
  756. DP_MST_DEBUG_V("enter\n");
  757. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  758. dp = bridge->display;
  759. rc = dp->post_enable(dp, bridge->dp_panel);
  760. if (rc) {
  761. DP_ERR("mst bridge [%d] post enable failed, rc=%d\n",
  762. bridge->id, rc);
  763. return;
  764. }
  765. DP_MST_INFO("mst bridge:%d conn:%d post enable complete\n",
  766. bridge->id, DP_MST_CONN_ID(bridge));
  767. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, DP_MST_CONN_ID(bridge));
  768. }
  769. static void dp_mst_bridge_disable(struct drm_bridge *drm_bridge)
  770. {
  771. int rc = 0;
  772. struct dp_mst_bridge *bridge;
  773. struct dp_display *dp;
  774. struct dp_mst_private *mst;
  775. if (!drm_bridge) {
  776. DP_ERR("Invalid params\n");
  777. return;
  778. }
  779. DP_MST_DEBUG_V("enter\n");
  780. bridge = to_dp_mst_bridge(drm_bridge);
  781. if (!bridge->connector) {
  782. DP_ERR("Invalid connector\n");
  783. return;
  784. }
  785. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  786. dp = bridge->display;
  787. mst = dp->dp_mst_prv_info;
  788. sde_connector_helper_bridge_disable(bridge->connector);
  789. mutex_lock(&mst->mst_lock);
  790. _dp_mst_bridge_pre_disable_part1(bridge);
  791. rc = dp->pre_disable(dp, bridge->dp_panel);
  792. if (rc)
  793. DP_ERR("[%d] DP display pre disable failed, rc=%d\n",
  794. bridge->id, rc);
  795. _dp_mst_bridge_pre_disable_part2(bridge);
  796. DP_MST_INFO("mst bridge:%d conn:%d disable complete\n", bridge->id,
  797. DP_MST_CONN_ID(bridge));
  798. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, DP_MST_CONN_ID(bridge));
  799. mutex_unlock(&mst->mst_lock);
  800. }
  801. static void dp_mst_bridge_post_disable(struct drm_bridge *drm_bridge)
  802. {
  803. int rc = 0;
  804. struct dp_mst_bridge *bridge;
  805. struct dp_display *dp;
  806. struct dp_mst_private *mst;
  807. if (!drm_bridge) {
  808. DP_ERR("Invalid params\n");
  809. return;
  810. }
  811. bridge = to_dp_mst_bridge(drm_bridge);
  812. if (!bridge->connector) {
  813. DP_ERR("Invalid connector\n");
  814. return;
  815. }
  816. DP_MST_DEBUG_V("enter\n");
  817. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  818. dp = bridge->display;
  819. mst = dp->dp_mst_prv_info;
  820. rc = dp->disable(dp, bridge->dp_panel);
  821. if (rc)
  822. DP_MST_INFO("bridge:%d conn:%d display disable failed, rc=%d\n",
  823. bridge->id, DP_MST_CONN_ID(bridge), rc);
  824. rc = dp->unprepare(dp, bridge->dp_panel);
  825. if (rc)
  826. DP_MST_INFO("bridge:%d conn:%d display unprepare failed, rc=%d\n",
  827. bridge->id, DP_MST_CONN_ID(bridge), rc);
  828. bridge->connector = NULL;
  829. bridge->dp_panel = NULL;
  830. DP_MST_INFO("mst bridge:%d conn:%d post disable complete\n",
  831. bridge->id, DP_MST_CONN_ID(bridge));
  832. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, DP_MST_CONN_ID(bridge));
  833. }
  834. static void dp_mst_bridge_mode_set(struct drm_bridge *drm_bridge,
  835. const struct drm_display_mode *mode,
  836. const struct drm_display_mode *adjusted_mode)
  837. {
  838. struct dp_mst_bridge *bridge;
  839. struct dp_mst_bridge_state *dp_bridge_state;
  840. struct dp_display *dp;
  841. DP_MST_DEBUG_V("enter\n");
  842. if (!drm_bridge || !mode || !adjusted_mode) {
  843. DP_ERR("Invalid params\n");
  844. return;
  845. }
  846. bridge = to_dp_mst_bridge(drm_bridge);
  847. dp_bridge_state = to_dp_mst_bridge_state(bridge);
  848. bridge->connector = dp_bridge_state->connector;
  849. bridge->dp_panel = dp_bridge_state->dp_panel;
  850. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, DP_MST_CONN_ID(bridge));
  851. dp = bridge->display;
  852. memset(&bridge->dp_mode, 0x0, sizeof(struct dp_display_mode));
  853. memcpy(&bridge->drm_mode, adjusted_mode, sizeof(bridge->drm_mode));
  854. dp->convert_to_dp_mode(dp, bridge->dp_panel, adjusted_mode,
  855. &bridge->dp_mode);
  856. dp->clear_reservation(dp, dp_bridge_state->dp_panel);
  857. DP_MST_INFO("mst bridge:%d conn:%d mode set complete %s\n", bridge->id,
  858. DP_MST_CONN_ID(bridge), mode->name);
  859. }
  860. /* DP MST Bridge APIs */
  861. static struct drm_connector *
  862. dp_mst_drm_fixed_connector_init(struct dp_display *dp_display,
  863. struct drm_encoder *encoder);
  864. static const struct drm_bridge_funcs dp_mst_bridge_ops = {
  865. .attach = dp_mst_bridge_attach,
  866. .mode_fixup = dp_mst_bridge_mode_fixup,
  867. .pre_enable = dp_mst_bridge_pre_enable,
  868. .enable = dp_mst_bridge_enable,
  869. .disable = dp_mst_bridge_disable,
  870. .post_disable = dp_mst_bridge_post_disable,
  871. .mode_set = dp_mst_bridge_mode_set,
  872. };
  873. int dp_mst_drm_bridge_init(void *data, struct drm_encoder *encoder)
  874. {
  875. int rc = 0;
  876. struct dp_mst_bridge *bridge = NULL;
  877. struct dp_mst_bridge_state *state;
  878. struct drm_device *dev;
  879. struct dp_display *display = data;
  880. struct msm_drm_private *priv = NULL;
  881. struct dp_mst_private *mst = display->dp_mst_prv_info;
  882. int i;
  883. if (!mst || !mst->mst_initialized) {
  884. if (dp_mst_enc_cache.cnt >= MAX_DP_MST_DRM_BRIDGES) {
  885. DP_MST_INFO("exceeding max bridge cnt %d\n",
  886. dp_mst_enc_cache.cnt);
  887. return 0;
  888. }
  889. dp_mst_enc_cache.mst_enc[dp_mst_enc_cache.cnt] = encoder;
  890. dp_mst_enc_cache.cnt++;
  891. DP_MST_INFO("mst not initialized. cache encoder information\n");
  892. return 0;
  893. }
  894. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  895. if (!mst->mst_bridge[i].in_use) {
  896. bridge = &mst->mst_bridge[i];
  897. bridge->encoder = encoder;
  898. bridge->in_use = true;
  899. bridge->id = i;
  900. break;
  901. }
  902. }
  903. if (i == MAX_DP_MST_DRM_BRIDGES) {
  904. DP_ERR("mst supports only %d bridges\n", i);
  905. rc = -EACCES;
  906. goto end;
  907. }
  908. dev = display->drm_dev;
  909. bridge->display = display;
  910. bridge->base.funcs = &dp_mst_bridge_ops;
  911. bridge->base.encoder = encoder;
  912. priv = dev->dev_private;
  913. rc = drm_bridge_attach(encoder, &bridge->base, NULL, 0);
  914. if (rc) {
  915. DP_ERR("failed to attach bridge, rc=%d\n", rc);
  916. goto end;
  917. }
  918. priv->bridges[priv->num_bridges++] = &bridge->base;
  919. state = kzalloc(sizeof(*state), GFP_KERNEL);
  920. if (state == NULL) {
  921. rc = -ENOMEM;
  922. goto end;
  923. }
  924. drm_atomic_private_obj_init(dev, &bridge->obj,
  925. &state->base,
  926. &dp_mst_bridge_state_funcs);
  927. DP_MST_DEBUG("mst drm bridge init. bridge id:%d\n", i);
  928. /*
  929. * If fixed topology port is defined, connector will be created
  930. * immediately.
  931. */
  932. rc = display->mst_get_fixed_topology_port(display, bridge->id,
  933. &bridge->fixed_port_num);
  934. if (!rc) {
  935. bridge->fixed_connector =
  936. dp_mst_drm_fixed_connector_init(display,
  937. bridge->encoder);
  938. if (bridge->fixed_connector == NULL) {
  939. DP_ERR("failed to create fixed connector\n");
  940. kfree(state);
  941. rc = -ENOMEM;
  942. goto end;
  943. }
  944. }
  945. return 0;
  946. end:
  947. return rc;
  948. }
  949. void dp_mst_drm_bridge_deinit(void *display)
  950. {
  951. DP_MST_DEBUG("mst bridge deinit\n");
  952. }
  953. /* DP MST Connector OPs */
  954. static int
  955. dp_mst_connector_detect(struct drm_connector *connector,
  956. struct drm_modeset_acquire_ctx *ctx,
  957. bool force,
  958. void *display)
  959. {
  960. struct sde_connector *c_conn = to_sde_connector(connector);
  961. struct dp_display *dp_display = c_conn->display;
  962. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  963. struct dp_panel *dp_panel;
  964. enum drm_connector_status status;
  965. DP_MST_DEBUG_V("enter:\n");
  966. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  967. dp_panel = c_conn->drv_panel;
  968. if (dp_panel->mst_hide)
  969. return connector_status_disconnected;
  970. status = mst->mst_fw_cbs->detect_port_ctx(connector,
  971. ctx, &mst->mst_mgr, c_conn->mst_port);
  972. DP_MST_INFO("conn:%d status:%d\n", connector->base.id, status);
  973. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id, status);
  974. return (int)status;
  975. }
  976. void dp_mst_clear_edid_cache(void *dp_display) {
  977. struct dp_display *dp = dp_display;
  978. struct drm_connector_list_iter conn_iter;
  979. struct drm_connector *conn;
  980. struct sde_connector *c_conn;
  981. DP_MST_DEBUG_V("enter:\n");
  982. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  983. if (!dp) {
  984. DP_ERR("invalid input\n");
  985. return;
  986. }
  987. drm_connector_list_iter_begin(dp->drm_dev, &conn_iter);
  988. drm_for_each_connector_iter(conn, &conn_iter) {
  989. c_conn = to_sde_connector(conn);
  990. if (!c_conn->mst_port)
  991. continue;
  992. mutex_lock(&dp_mst.edid_lock);
  993. kfree(c_conn->cached_edid);
  994. c_conn->cached_edid = NULL;
  995. mutex_unlock(&dp_mst.edid_lock);
  996. }
  997. drm_connector_list_iter_end(&conn_iter);
  998. DP_MST_DEBUG_V("exit:\n");
  999. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT);
  1000. }
  1001. static int dp_mst_connector_get_modes(struct drm_connector *connector,
  1002. void *display, const struct msm_resource_caps_info *avail_res)
  1003. {
  1004. struct sde_connector *c_conn = to_sde_connector(connector);
  1005. struct dp_display *dp_display = display;
  1006. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  1007. struct dp_display_mode *dp_mode = NULL;
  1008. int rc = 0;
  1009. struct edid *edid = NULL;
  1010. DP_MST_DEBUG_V("enter:\n");
  1011. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  1012. mutex_lock(&mst->edid_lock);
  1013. if (c_conn->cached_edid)
  1014. goto duplicate_edid;
  1015. mutex_unlock(&mst->edid_lock);
  1016. edid = mst->mst_fw_cbs->get_edid(connector,
  1017. &mst->mst_mgr, c_conn->mst_port);
  1018. if (!edid) {
  1019. DP_WARN("get edid failed. id: %d\n", connector->base.id);
  1020. goto end;
  1021. }
  1022. mutex_lock(&mst->edid_lock);
  1023. c_conn->cached_edid = edid;
  1024. duplicate_edid:
  1025. edid = drm_edid_duplicate(c_conn->cached_edid);
  1026. mutex_unlock(&mst->edid_lock);
  1027. if (IS_ERR(edid)) {
  1028. DP_MST_DEBUG("edid duplication failed. id: %d\n",
  1029. connector->base.id);
  1030. goto end;
  1031. }
  1032. rc = dp_display->mst_connector_update_edid(dp_display,
  1033. connector, edid);
  1034. end:
  1035. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id, rc);
  1036. if (rc <= 0) {
  1037. DP_WARN("conn:%d has no modes, adding failsafe. rc=%d\n", connector->base.id, rc);
  1038. dp_mode = kzalloc(sizeof(*dp_mode), GFP_KERNEL);
  1039. if (!dp_mode)
  1040. return 0;
  1041. init_failsafe_mode(dp_mode);
  1042. rc = dp_connector_add_custom_mode(connector, dp_mode);
  1043. } else {
  1044. DP_MST_INFO("conn:%d has %d modes\n", connector->base.id, rc);
  1045. }
  1046. return rc;
  1047. }
  1048. enum drm_mode_status dp_mst_connector_mode_valid(
  1049. struct drm_connector *connector,
  1050. struct drm_display_mode *mode,
  1051. void *display, const struct msm_resource_caps_info *avail_res)
  1052. {
  1053. struct dp_display *dp_display = display;
  1054. struct dp_mst_private *mst;
  1055. struct sde_connector *c_conn;
  1056. struct drm_dp_mst_port *mst_port;
  1057. struct dp_display_mode dp_mode;
  1058. struct dp_panel *dp_panel;
  1059. uint16_t full_pbn, required_pbn;
  1060. int available_slots, required_slots;
  1061. struct dp_mst_bridge_state *dp_bridge_state;
  1062. int i, vrefresh, slots_in_use = 0, active_enc_cnt = 0;
  1063. const u32 tot_slots = 63;
  1064. if (!connector || !mode || !display) {
  1065. DP_ERR("invalid input\n");
  1066. return 0;
  1067. }
  1068. mst = dp_display->dp_mst_prv_info;
  1069. c_conn = to_sde_connector(connector);
  1070. mst_port = c_conn->mst_port;
  1071. dp_panel = c_conn->drv_panel;
  1072. if (!dp_panel || !mst_port)
  1073. return MODE_ERROR;
  1074. vrefresh = drm_mode_vrefresh(mode);
  1075. if (dp_panel->mode_override && (mode->hdisplay != dp_panel->hdisplay ||
  1076. mode->vdisplay != dp_panel->vdisplay ||
  1077. vrefresh != dp_panel->vrefresh ||
  1078. mode->picture_aspect_ratio != dp_panel->aspect_ratio))
  1079. return MODE_BAD;
  1080. /* dp bridge state is protected by drm_mode_config.connection_mutex */
  1081. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1082. dp_bridge_state = to_dp_mst_bridge_state(&mst->mst_bridge[i]);
  1083. if (dp_bridge_state->connector &&
  1084. dp_bridge_state->connector != connector) {
  1085. active_enc_cnt++;
  1086. slots_in_use += dp_bridge_state->num_slots;
  1087. }
  1088. }
  1089. if (active_enc_cnt < DP_STREAM_MAX) {
  1090. full_pbn = mst_port->full_pbn;
  1091. available_slots = tot_slots - slots_in_use;
  1092. } else {
  1093. DP_DEBUG("all mst streams are active\n");
  1094. return MODE_BAD;
  1095. }
  1096. dp_display->convert_to_dp_mode(dp_display, c_conn->drv_panel,
  1097. mode, &dp_mode);
  1098. required_pbn = mst->mst_fw_cbs->calc_pbn_mode(&dp_mode);
  1099. required_slots = mst->mst_fw_cbs->find_vcpi_slots(
  1100. &mst->mst_mgr, required_pbn);
  1101. if (required_pbn > full_pbn || required_slots > available_slots) {
  1102. DP_DEBUG("mode:%s not supported. pbn %d vs %d slots %d vs %d\n",
  1103. mode->name, required_pbn, full_pbn,
  1104. required_slots, available_slots);
  1105. return MODE_BAD;
  1106. }
  1107. return dp_display->validate_mode(dp_display, dp_panel, mode, avail_res);
  1108. }
  1109. int dp_mst_connector_get_mode_info(struct drm_connector *connector,
  1110. const struct drm_display_mode *drm_mode,
  1111. struct msm_sub_mode *sub_mode,
  1112. struct msm_mode_info *mode_info,
  1113. void *display,
  1114. const struct msm_resource_caps_info *avail_res)
  1115. {
  1116. int rc;
  1117. DP_MST_DEBUG_V("enter:\n");
  1118. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  1119. rc = dp_connector_get_mode_info(connector, drm_mode, NULL, mode_info,
  1120. display, avail_res);
  1121. DP_MST_DEBUG_V("mst connector:%d get mode info. rc:%d\n",
  1122. connector->base.id, rc);
  1123. DP_MST_DEBUG_V("exit:\n");
  1124. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id);
  1125. return rc;
  1126. }
  1127. static struct drm_encoder *
  1128. dp_mst_atomic_best_encoder(struct drm_connector *connector,
  1129. void *display, struct drm_connector_state *state)
  1130. {
  1131. struct dp_display *dp_display = display;
  1132. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  1133. struct sde_connector *conn = to_sde_connector(connector);
  1134. struct drm_encoder *enc = NULL;
  1135. struct dp_mst_bridge_state *bridge_state;
  1136. u32 i;
  1137. if (state->best_encoder)
  1138. return state->best_encoder;
  1139. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1140. bridge_state = dp_mst_get_bridge_atomic_state(
  1141. state->state, &mst->mst_bridge[i]);
  1142. if (IS_ERR(bridge_state))
  1143. goto end;
  1144. if (bridge_state->connector == connector) {
  1145. enc = mst->mst_bridge[i].encoder;
  1146. goto end;
  1147. }
  1148. }
  1149. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1150. if (mst->mst_bridge[i].fixed_connector)
  1151. continue;
  1152. bridge_state = dp_mst_get_bridge_atomic_state(
  1153. state->state, &mst->mst_bridge[i]);
  1154. if (!bridge_state->connector) {
  1155. bridge_state->connector = connector;
  1156. bridge_state->dp_panel = conn->drv_panel;
  1157. enc = mst->mst_bridge[i].encoder;
  1158. break;
  1159. }
  1160. }
  1161. end:
  1162. if (enc)
  1163. DP_MST_DEBUG("mst connector:%d atomic best encoder:%d\n",
  1164. connector->base.id, i);
  1165. else
  1166. DP_MST_DEBUG("mst connector:%d atomic best encoder failed\n",
  1167. connector->base.id);
  1168. return enc;
  1169. }
  1170. static int dp_mst_connector_atomic_check(struct drm_connector *connector,
  1171. void *display, struct drm_atomic_state *state)
  1172. {
  1173. int rc = 0, slots, i;
  1174. bool vcpi_released = false;
  1175. struct drm_connector_state *old_conn_state;
  1176. struct drm_connector_state *new_conn_state;
  1177. struct drm_crtc *old_crtc;
  1178. struct drm_crtc_state *crtc_state;
  1179. struct dp_mst_bridge *bridge;
  1180. struct dp_mst_bridge_state *bridge_state;
  1181. struct drm_bridge *drm_bridge;
  1182. struct dp_display *dp_display = display;
  1183. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  1184. struct sde_connector *c_conn = to_sde_connector(connector);
  1185. struct dp_display_mode dp_mode;
  1186. DP_MST_DEBUG_V("enter:\n");
  1187. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  1188. if (!state)
  1189. return rc;
  1190. new_conn_state = drm_atomic_get_new_connector_state(state, connector);
  1191. if (!new_conn_state)
  1192. return rc;
  1193. old_conn_state = drm_atomic_get_old_connector_state(state, connector);
  1194. if (!old_conn_state)
  1195. goto mode_set;
  1196. old_crtc = old_conn_state->crtc;
  1197. if (!old_crtc)
  1198. goto mode_set;
  1199. crtc_state = drm_atomic_get_new_crtc_state(state, old_crtc);
  1200. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1201. bridge = &mst->mst_bridge[i];
  1202. DP_MST_DEBUG("bridge id:%d, vcpi:%d, pbn:%d, slots:%d\n",
  1203. bridge->id, bridge->vcpi, bridge->pbn,
  1204. bridge->num_slots);
  1205. }
  1206. /*attempt to release vcpi slots on a modeset change for crtc state*/
  1207. if (drm_atomic_crtc_needs_modeset(crtc_state)) {
  1208. if (WARN_ON(!old_conn_state->best_encoder)) {
  1209. rc = -EINVAL;
  1210. goto end;
  1211. }
  1212. drm_bridge = drm_bridge_chain_get_first_bridge(
  1213. old_conn_state->best_encoder);
  1214. if (WARN_ON(!drm_bridge)) {
  1215. rc = -EINVAL;
  1216. goto end;
  1217. }
  1218. bridge = to_dp_mst_bridge(drm_bridge);
  1219. bridge_state = dp_mst_get_bridge_atomic_state(state, bridge);
  1220. if (IS_ERR(bridge_state)) {
  1221. rc = PTR_ERR(bridge_state);
  1222. goto end;
  1223. }
  1224. if (WARN_ON(bridge_state->connector != connector)) {
  1225. rc = -EINVAL;
  1226. goto end;
  1227. }
  1228. slots = bridge_state->num_slots;
  1229. if (slots > 0) {
  1230. rc = mst->mst_fw_cbs->atomic_release_time_slots(state,
  1231. &mst->mst_mgr, c_conn->mst_port);
  1232. if (rc) {
  1233. DP_ERR("failed releasing %d vcpi slots %d\n",
  1234. slots, rc);
  1235. goto end;
  1236. }
  1237. vcpi_released = true;
  1238. }
  1239. bridge_state->num_slots = 0;
  1240. if (!new_conn_state->crtc && mst->state != PM_SUSPEND) {
  1241. bridge_state->connector = NULL;
  1242. bridge_state->dp_panel = NULL;
  1243. DP_MST_DEBUG("clear best encoder: %d\n", bridge->id);
  1244. }
  1245. }
  1246. mode_set:
  1247. if (!new_conn_state->crtc)
  1248. goto end;
  1249. crtc_state = drm_atomic_get_new_crtc_state(state, new_conn_state->crtc);
  1250. if (drm_atomic_crtc_needs_modeset(crtc_state) && crtc_state->active) {
  1251. c_conn = to_sde_connector(connector);
  1252. if (WARN_ON(!new_conn_state->best_encoder)) {
  1253. rc = -EINVAL;
  1254. goto end;
  1255. }
  1256. drm_bridge = drm_bridge_chain_get_first_bridge(
  1257. new_conn_state->best_encoder);
  1258. if (WARN_ON(!drm_bridge)) {
  1259. rc = -EINVAL;
  1260. goto end;
  1261. }
  1262. bridge = to_dp_mst_bridge(drm_bridge);
  1263. bridge_state = dp_mst_get_bridge_atomic_state(state, bridge);
  1264. if (IS_ERR(bridge_state)) {
  1265. rc = PTR_ERR(bridge_state);
  1266. goto end;
  1267. }
  1268. if (WARN_ON(bridge_state->connector != connector)) {
  1269. rc = -EINVAL;
  1270. goto end;
  1271. }
  1272. /*
  1273. * check if vcpi slots are trying to get allocated in same phase
  1274. * as deallocation. If so, go to end to avoid allocation.
  1275. */
  1276. if (vcpi_released) {
  1277. DP_WARN("skipping allocation since vcpi was released in the same state\n");
  1278. goto end;
  1279. }
  1280. if (WARN_ON(bridge_state->num_slots)) {
  1281. rc = -EINVAL;
  1282. goto end;
  1283. }
  1284. dp_display->convert_to_dp_mode(dp_display, c_conn->drv_panel,
  1285. &crtc_state->mode, &dp_mode);
  1286. slots = _dp_mst_compute_config(state, mst, connector, &dp_mode);
  1287. if (slots < 0) {
  1288. rc = slots;
  1289. goto end;
  1290. }
  1291. bridge_state->num_slots = slots;
  1292. }
  1293. end:
  1294. DP_MST_DEBUG("mst connector:%d atomic check ret %d\n",
  1295. connector->base.id, rc);
  1296. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id, rc);
  1297. return rc;
  1298. }
  1299. static int dp_mst_connector_config_hdr(struct drm_connector *connector,
  1300. void *display, struct sde_connector_state *c_state)
  1301. {
  1302. int rc;
  1303. DP_MST_DEBUG_V("enter:\n");
  1304. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  1305. rc = dp_connector_config_hdr(connector, display, c_state);
  1306. DP_MST_DEBUG("mst connector:%d cfg hdr. rc:%d\n",
  1307. connector->base.id, rc);
  1308. DP_MST_DEBUG_V("exit:\n");
  1309. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id, rc);
  1310. return rc;
  1311. }
  1312. static void dp_mst_connector_pre_destroy(struct drm_connector *connector,
  1313. void *display)
  1314. {
  1315. struct dp_display *dp_display = display;
  1316. struct sde_connector *c_conn = to_sde_connector(connector);
  1317. u32 conn_id = connector->base.id;
  1318. DP_MST_DEBUG_V("enter:\n");
  1319. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, conn_id);
  1320. kfree(c_conn->cached_edid);
  1321. c_conn->cached_edid = NULL;
  1322. drm_dp_mst_put_port_malloc(c_conn->mst_port);
  1323. dp_display->mst_connector_uninstall(dp_display, connector);
  1324. DP_MST_DEBUG_V("exit:\n");
  1325. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, conn_id);
  1326. }
  1327. static int dp_mst_connector_post_init(struct drm_connector *connector,
  1328. void *display)
  1329. {
  1330. struct dp_display *dp_display = display;
  1331. struct sde_connector *sde_conn = to_sde_connector(connector);
  1332. if (!dp_display || !connector)
  1333. return -EINVAL;
  1334. if (dp_display->dsc_cont_pps)
  1335. sde_conn->ops.update_pps = NULL;
  1336. return 0;
  1337. }
  1338. /* DRM MST callbacks */
  1339. static struct drm_connector *
  1340. dp_mst_add_connector(struct drm_dp_mst_topology_mgr *mgr,
  1341. struct drm_dp_mst_port *port, const char *pathprop)
  1342. {
  1343. static const struct sde_connector_ops dp_mst_connector_ops = {
  1344. .post_init = dp_mst_connector_post_init,
  1345. .detect_ctx = dp_mst_connector_detect,
  1346. .get_modes = dp_mst_connector_get_modes,
  1347. .mode_valid = dp_mst_connector_mode_valid,
  1348. .get_info = dp_connector_get_info,
  1349. .get_mode_info = dp_mst_connector_get_mode_info,
  1350. .atomic_best_encoder = dp_mst_atomic_best_encoder,
  1351. .atomic_check = dp_mst_connector_atomic_check,
  1352. .config_hdr = dp_mst_connector_config_hdr,
  1353. .pre_destroy = dp_mst_connector_pre_destroy,
  1354. .update_pps = dp_connector_update_pps,
  1355. .install_properties = dp_connector_install_properties,
  1356. };
  1357. struct dp_mst_private *dp_mst;
  1358. struct drm_device *dev;
  1359. struct dp_display *dp_display;
  1360. struct drm_connector *connector;
  1361. struct sde_connector *c_conn;
  1362. int rc, i;
  1363. DP_MST_DEBUG_V("enter\n");
  1364. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  1365. dp_mst = container_of(mgr, struct dp_mst_private, mst_mgr);
  1366. dp_display = dp_mst->dp_display;
  1367. dev = dp_display->drm_dev;
  1368. /* make sure connector is not accessed before reset */
  1369. drm_modeset_lock_all(dev);
  1370. connector = sde_connector_init(dev,
  1371. dp_mst->mst_bridge[0].encoder,
  1372. NULL,
  1373. dp_display,
  1374. &dp_mst_connector_ops,
  1375. DRM_CONNECTOR_POLL_HPD,
  1376. DRM_MODE_CONNECTOR_DisplayPort);
  1377. if (IS_ERR_OR_NULL(connector)) {
  1378. DP_ERR("mst sde_connector_init failed\n");
  1379. drm_modeset_unlock_all(dev);
  1380. return NULL;
  1381. }
  1382. rc = dp_display->mst_connector_install(dp_display, connector);
  1383. if (rc) {
  1384. DP_ERR("mst connector install failed\n");
  1385. sde_connector_destroy(connector);
  1386. drm_modeset_unlock_all(dev);
  1387. return NULL;
  1388. }
  1389. c_conn = to_sde_connector(connector);
  1390. c_conn->mst_port = port;
  1391. drm_dp_mst_get_port_malloc(c_conn->mst_port);
  1392. if (connector->funcs->reset)
  1393. connector->funcs->reset(connector);
  1394. for (i = 1; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1395. drm_connector_attach_encoder(connector,
  1396. dp_mst->mst_bridge[i].encoder);
  1397. }
  1398. drm_object_attach_property(&connector->base,
  1399. dev->mode_config.path_property, 0);
  1400. drm_object_attach_property(&connector->base,
  1401. dev->mode_config.tile_property, 0);
  1402. /* unlock connector and make it accessible */
  1403. drm_modeset_unlock_all(dev);
  1404. DP_MST_INFO("add mst connector id:%d\n", connector->base.id);
  1405. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, connector->base.id);
  1406. return connector;
  1407. }
  1408. static int
  1409. dp_mst_fixed_connector_detect(struct drm_connector *connector,
  1410. struct drm_modeset_acquire_ctx *ctx,
  1411. bool force,
  1412. void *display)
  1413. {
  1414. struct dp_display *dp_display = display;
  1415. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  1416. int i;
  1417. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1418. if (mst->mst_bridge[i].fixed_connector != connector)
  1419. continue;
  1420. if (!mst->mst_bridge[i].fixed_port_added)
  1421. break;
  1422. return dp_mst_connector_detect(connector, ctx, force, display);
  1423. }
  1424. return (int)connector_status_disconnected;
  1425. }
  1426. static struct drm_encoder *
  1427. dp_mst_fixed_atomic_best_encoder(struct drm_connector *connector,
  1428. void *display, struct drm_connector_state *state)
  1429. {
  1430. struct dp_display *dp_display = display;
  1431. struct dp_mst_private *mst = dp_display->dp_mst_prv_info;
  1432. struct sde_connector *conn = to_sde_connector(connector);
  1433. struct drm_encoder *enc = NULL;
  1434. struct dp_mst_bridge_state *bridge_state;
  1435. u32 i;
  1436. if (state->best_encoder)
  1437. return state->best_encoder;
  1438. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1439. if (mst->mst_bridge[i].fixed_connector == connector) {
  1440. bridge_state = dp_mst_get_bridge_atomic_state(
  1441. state->state, &mst->mst_bridge[i]);
  1442. if (IS_ERR(bridge_state))
  1443. goto end;
  1444. bridge_state->connector = connector;
  1445. bridge_state->dp_panel = conn->drv_panel;
  1446. enc = mst->mst_bridge[i].encoder;
  1447. break;
  1448. }
  1449. }
  1450. end:
  1451. if (enc)
  1452. DP_MST_DEBUG("mst connector:%d atomic best encoder:%d\n",
  1453. connector->base.id, i);
  1454. else
  1455. DP_MST_DEBUG("mst connector:%d atomic best encoder failed\n",
  1456. connector->base.id);
  1457. return enc;
  1458. }
  1459. static u32 dp_mst_find_fixed_port_num(struct drm_dp_mst_branch *mstb,
  1460. struct drm_dp_mst_port *target)
  1461. {
  1462. struct drm_dp_mst_port *port;
  1463. u32 port_num = 0;
  1464. /*
  1465. * search through reversed order of adding sequence, so the port number
  1466. * will be unique once topology is fixed
  1467. */
  1468. list_for_each_entry_reverse(port, &mstb->ports, next) {
  1469. if (port->mstb)
  1470. port_num += dp_mst_find_fixed_port_num(port->mstb,
  1471. target);
  1472. else if (!port->input) {
  1473. ++port_num;
  1474. if (port == target)
  1475. break;
  1476. }
  1477. }
  1478. return port_num;
  1479. }
  1480. static struct drm_connector *
  1481. dp_mst_find_fixed_connector(struct dp_mst_private *dp_mst,
  1482. struct drm_dp_mst_port *port)
  1483. {
  1484. struct dp_display *dp_display = dp_mst->dp_display;
  1485. struct drm_connector *connector = NULL;
  1486. struct sde_connector *c_conn;
  1487. u32 port_num;
  1488. int i;
  1489. mutex_lock(&port->mgr->lock);
  1490. port_num = dp_mst_find_fixed_port_num(port->mgr->mst_primary, port);
  1491. mutex_unlock(&port->mgr->lock);
  1492. if (!port_num)
  1493. return NULL;
  1494. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1495. if (dp_mst->mst_bridge[i].fixed_port_num == port_num) {
  1496. connector = dp_mst->mst_bridge[i].fixed_connector;
  1497. c_conn = to_sde_connector(connector);
  1498. c_conn->mst_port = port;
  1499. dp_display->mst_connector_update_link_info(dp_display,
  1500. connector);
  1501. dp_mst->mst_bridge[i].fixed_port_added = true;
  1502. DP_MST_DEBUG("found fixed connector %d\n",
  1503. DRMID(connector));
  1504. break;
  1505. }
  1506. }
  1507. return connector;
  1508. }
  1509. static int
  1510. dp_mst_find_first_available_encoder_idx(struct dp_mst_private *dp_mst)
  1511. {
  1512. int enc_idx = MAX_DP_MST_DRM_BRIDGES;
  1513. int i;
  1514. for (i = 0; i < MAX_DP_MST_DRM_BRIDGES; i++) {
  1515. if (!dp_mst->mst_bridge[i].fixed_connector) {
  1516. enc_idx = i;
  1517. break;
  1518. }
  1519. }
  1520. return enc_idx;
  1521. }
  1522. static struct drm_connector *
  1523. dp_mst_add_fixed_connector(struct drm_dp_mst_topology_mgr *mgr,
  1524. struct drm_dp_mst_port *port, const char *pathprop)
  1525. {
  1526. struct dp_mst_private *dp_mst;
  1527. struct drm_device *dev;
  1528. struct dp_display *dp_display;
  1529. struct drm_connector *connector;
  1530. int i, enc_idx;
  1531. DP_MST_DEBUG_V("enter\n");
  1532. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  1533. dp_mst = container_of(mgr, struct dp_mst_private, mst_mgr);
  1534. dp_display = dp_mst->dp_display;
  1535. dev = dp_display->drm_dev;
  1536. if (port->input || port->mstb)
  1537. enc_idx = MAX_DP_MST_DRM_BRIDGES;
  1538. else {
  1539. /* if port is already reserved, return immediately */
  1540. connector = dp_mst_find_fixed_connector(dp_mst, port);
  1541. if (connector != NULL)
  1542. return connector;
  1543. /* first available bridge index for non-reserved port */
  1544. enc_idx = dp_mst_find_first_available_encoder_idx(dp_mst);
  1545. }
  1546. /* add normal connector */
  1547. connector = dp_mst_add_connector(mgr, port, pathprop);
  1548. if (!connector) {
  1549. DP_MST_DEBUG("failed to add connector\n");
  1550. return NULL;
  1551. }
  1552. drm_modeset_lock_all(dev);
  1553. /* clear encoder list */
  1554. connector->possible_encoders = 0;
  1555. /* re-attach encoders from first available encoders */
  1556. for (i = enc_idx; i < MAX_DP_MST_DRM_BRIDGES; i++)
  1557. drm_connector_attach_encoder(connector,
  1558. dp_mst->mst_bridge[i].encoder);
  1559. drm_modeset_unlock_all(dev);
  1560. DP_MST_DEBUG("add mst connector:%d\n", connector->base.id);
  1561. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id);
  1562. return connector;
  1563. }
  1564. static struct drm_connector *
  1565. dp_mst_drm_fixed_connector_init(struct dp_display *dp_display,
  1566. struct drm_encoder *encoder)
  1567. {
  1568. static const struct sde_connector_ops dp_mst_connector_ops = {
  1569. .post_init = dp_mst_connector_post_init,
  1570. .detect_ctx = dp_mst_fixed_connector_detect,
  1571. .get_modes = dp_mst_connector_get_modes,
  1572. .mode_valid = dp_mst_connector_mode_valid,
  1573. .get_info = dp_connector_get_info,
  1574. .get_mode_info = dp_mst_connector_get_mode_info,
  1575. .atomic_best_encoder = dp_mst_fixed_atomic_best_encoder,
  1576. .atomic_check = dp_mst_connector_atomic_check,
  1577. .config_hdr = dp_mst_connector_config_hdr,
  1578. .pre_destroy = dp_mst_connector_pre_destroy,
  1579. };
  1580. struct drm_device *dev;
  1581. struct drm_connector *connector;
  1582. int rc;
  1583. DP_MST_DEBUG_V("enter\n");
  1584. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY);
  1585. dev = dp_display->drm_dev;
  1586. connector = sde_connector_init(dev,
  1587. encoder,
  1588. NULL,
  1589. dp_display,
  1590. &dp_mst_connector_ops,
  1591. DRM_CONNECTOR_POLL_HPD,
  1592. DRM_MODE_CONNECTOR_DisplayPort);
  1593. if (IS_ERR_OR_NULL(connector)) {
  1594. DP_ERR("mst sde_connector_init failed\n");
  1595. return NULL;
  1596. }
  1597. rc = dp_display->mst_connector_install(dp_display, connector);
  1598. if (rc) {
  1599. DP_ERR("mst connector install failed\n");
  1600. sde_connector_destroy(connector);
  1601. return NULL;
  1602. }
  1603. drm_object_attach_property(&connector->base,
  1604. dev->mode_config.path_property, 0);
  1605. drm_object_attach_property(&connector->base,
  1606. dev->mode_config.tile_property, 0);
  1607. DP_MST_DEBUG("add mst fixed connector:%d\n", connector->base.id);
  1608. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, connector->base.id);
  1609. return connector;
  1610. }
  1611. static void dp_mst_hpd_event_notify(struct dp_mst_private *mst, bool hpd_status)
  1612. {
  1613. struct drm_device *dev = mst->dp_display->drm_dev;
  1614. char event_string[] = "HOTPLUG=1";
  1615. char status[HPD_STRING_SIZE];
  1616. char *envp[3];
  1617. if (hpd_status)
  1618. snprintf(status, HPD_STRING_SIZE, "status=connected");
  1619. else
  1620. snprintf(status, HPD_STRING_SIZE, "status=disconnected");
  1621. envp[0] = event_string;
  1622. envp[1] = status;
  1623. envp[2] = NULL;
  1624. kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE, envp);
  1625. DP_MST_INFO("%s finished. hpd_status:%d\n", __func__, hpd_status);
  1626. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, hpd_status);
  1627. }
  1628. /* DP Driver Callback OPs */
  1629. static int dp_mst_display_set_mgr_state(void *dp_display, bool state)
  1630. {
  1631. int rc;
  1632. struct dp_display *dp = dp_display;
  1633. struct dp_mst_private *mst = dp->dp_mst_prv_info;
  1634. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, state);
  1635. /*
  1636. * on hpd high, set_mgr_state is called before hotplug event is sent
  1637. * to usermode and mst_session_state should be updated here.
  1638. * on hpd_low, set_mgr_state is called after hotplug event is sent and
  1639. * the session_state was already updated prior to that.
  1640. */
  1641. if (state)
  1642. mst->mst_session_state = state;
  1643. dp_mst_clear_edid_cache(dp);
  1644. mst->mst_fw_cbs = &drm_dp_mst_fw_helper_ops;
  1645. rc = mst->mst_fw_cbs->topology_mgr_set_mst(&mst->mst_mgr, state);
  1646. if (rc < 0) {
  1647. DP_ERR("failed to set topology mgr state to %d. rc %d\n",
  1648. state, rc);
  1649. }
  1650. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_EXIT, rc);
  1651. return rc;
  1652. }
  1653. static void dp_mst_display_hpd(void *dp_display, bool hpd_status)
  1654. {
  1655. struct dp_display *dp = dp_display;
  1656. struct dp_mst_private *mst = dp->dp_mst_prv_info;
  1657. /*
  1658. * on hpd high, set_mgr_state is called before hotplug event is sent
  1659. * to usermode and mst_session_state was already updated there.
  1660. * on hpd_low, hotplug event is sent before set_mgr_state and the
  1661. * session state should be unset here for the connection status to be
  1662. * updated accordingly.
  1663. */
  1664. if (!hpd_status)
  1665. mst->mst_session_state = hpd_status;
  1666. dp_mst_hpd_event_notify(mst, hpd_status);
  1667. }
  1668. static void dp_mst_display_hpd_irq(void *dp_display)
  1669. {
  1670. int rc;
  1671. struct dp_display *dp = dp_display;
  1672. struct dp_mst_private *mst = dp->dp_mst_prv_info;
  1673. u8 esi[14];
  1674. unsigned int esi_res = DP_SINK_COUNT_ESI + 1;
  1675. bool handled;
  1676. if (!mst->mst_session_state) {
  1677. DP_ERR("mst_hpd_irq received before mst session start\n");
  1678. return;
  1679. }
  1680. rc = drm_dp_dpcd_read(mst->caps.drm_aux, DP_SINK_COUNT_ESI,
  1681. esi, 14);
  1682. if (rc != 14) {
  1683. DP_ERR("dpcd sink status read failed, rlen=%d\n", rc);
  1684. return;
  1685. }
  1686. DP_MST_DEBUG("mst irq: esi1[0x%x] esi2[0x%x] esi3[%x]\n",
  1687. esi[1], esi[2], esi[3]);
  1688. rc = drm_dp_mst_hpd_irq(&mst->mst_mgr, esi, &handled);
  1689. /* ack the request */
  1690. if (handled) {
  1691. rc = drm_dp_dpcd_write(mst->caps.drm_aux, esi_res, &esi[1], 3);
  1692. if (esi[1] & DP_UP_REQ_MSG_RDY)
  1693. dp_mst_clear_edid_cache(dp);
  1694. if (rc != 3)
  1695. DP_ERR("dpcd esi_res failed. rlen=%d\n", rc);
  1696. }
  1697. DP_MST_DEBUG("mst display hpd_irq handled:%d rc:%d\n", handled, rc);
  1698. }
  1699. static void dp_mst_set_state(void *dp_display, enum dp_drv_state mst_state)
  1700. {
  1701. struct dp_display *dp = dp_display;
  1702. struct dp_mst_private *mst = dp->dp_mst_prv_info;
  1703. if (!mst) {
  1704. DP_DEBUG("mst not initialized\n");
  1705. return;
  1706. }
  1707. SDE_EVT32_EXTERNAL(SDE_EVTLOG_FUNC_ENTRY, mst_state);
  1708. mst->state = mst_state;
  1709. DP_MST_INFO("mst power state:%d\n", mst_state);
  1710. }
  1711. static void dp_mst_display_set_mst_mode_params(void *dp_display, struct dp_display_mode *mode)
  1712. {
  1713. // update pbn values that will later be used for rg calculation
  1714. dp_mst_calc_pbn_mode(mode);
  1715. }
  1716. /* DP MST APIs */
  1717. static const struct dp_mst_drm_cbs dp_mst_display_cbs = {
  1718. .hpd = dp_mst_display_hpd,
  1719. .hpd_irq = dp_mst_display_hpd_irq,
  1720. .set_drv_state = dp_mst_set_state,
  1721. .set_mgr_state = dp_mst_display_set_mgr_state,
  1722. .set_mst_mode_params = dp_mst_display_set_mst_mode_params,
  1723. };
  1724. static const struct drm_dp_mst_topology_cbs dp_mst_drm_cbs = {
  1725. .add_connector = dp_mst_add_connector,
  1726. };
  1727. static const struct drm_dp_mst_topology_cbs dp_mst_fixed_drm_cbs = {
  1728. .add_connector = dp_mst_add_fixed_connector,
  1729. };
  1730. int dp_mst_init(struct dp_display *dp_display)
  1731. {
  1732. struct drm_device *dev;
  1733. int conn_base_id = 0;
  1734. int ret, i;
  1735. struct dp_mst_drm_install_info install_info;
  1736. memset(&dp_mst, 0, sizeof(dp_mst));
  1737. if (!dp_display) {
  1738. DP_ERR("invalid params\n");
  1739. return 0;
  1740. }
  1741. dev = dp_display->drm_dev;
  1742. /* register with DP driver */
  1743. install_info.dp_mst_prv_info = &dp_mst;
  1744. install_info.cbs = &dp_mst_display_cbs;
  1745. dp_display->mst_install(dp_display, &install_info);
  1746. dp_display->get_mst_caps(dp_display, &dp_mst.caps);
  1747. if (!dp_mst.caps.has_mst) {
  1748. DP_MST_DEBUG("mst not supported\n");
  1749. return 0;
  1750. }
  1751. dp_mst.mst_fw_cbs = &drm_dp_mst_fw_helper_ops;
  1752. memset(&dp_mst.mst_mgr, 0, sizeof(dp_mst.mst_mgr));
  1753. dp_mst.mst_mgr.cbs = &dp_mst_drm_cbs;
  1754. conn_base_id = dp_display->base_connector->base.id;
  1755. dp_mst.dp_display = dp_display;
  1756. mutex_init(&dp_mst.mst_lock);
  1757. mutex_init(&dp_mst.edid_lock);
  1758. /*
  1759. * Upstream driver modified drm_dp_mst_topology_mgr_init signature
  1760. * in 5.15 kernel and reverted it back in 6.1
  1761. */
  1762. #if ((KERNEL_VERSION(5, 15, 0) <= LINUX_VERSION_CODE) && \
  1763. (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE))
  1764. ret = drm_dp_mst_topology_mgr_init(&dp_mst.mst_mgr, dev,
  1765. dp_mst.caps.drm_aux,
  1766. dp_mst.caps.max_dpcd_transaction_bytes,
  1767. dp_mst.caps.max_streams_supported,
  1768. 4, DP_MAX_LINK_CLK_KHZ, conn_base_id);
  1769. #else
  1770. ret = drm_dp_mst_topology_mgr_init(&dp_mst.mst_mgr, dev,
  1771. dp_mst.caps.drm_aux,
  1772. dp_mst.caps.max_dpcd_transaction_bytes,
  1773. dp_mst.caps.max_streams_supported,
  1774. conn_base_id);
  1775. #endif
  1776. if (ret) {
  1777. DP_ERR("dp drm mst topology manager init failed\n");
  1778. goto error;
  1779. }
  1780. dp_mst.mst_initialized = true;
  1781. /* create drm_bridges for cached mst encoders and clear cache */
  1782. for (i = 0; i < dp_mst_enc_cache.cnt; i++) {
  1783. ret = dp_mst_drm_bridge_init(dp_display,
  1784. dp_mst_enc_cache.mst_enc[i]);
  1785. }
  1786. memset(&dp_mst_enc_cache, 0, sizeof(dp_mst_enc_cache));
  1787. /* choose fixed callback function if fixed topology is found */
  1788. if (!dp_display->mst_get_fixed_topology_port(dp_display, 0, NULL))
  1789. dp_mst.mst_mgr.cbs = &dp_mst_fixed_drm_cbs;
  1790. DP_MST_INFO("dp drm mst topology manager init completed\n");
  1791. return ret;
  1792. error:
  1793. mutex_destroy(&dp_mst.mst_lock);
  1794. mutex_destroy(&dp_mst.edid_lock);
  1795. return ret;
  1796. }
  1797. void dp_mst_deinit(struct dp_display *dp_display)
  1798. {
  1799. struct dp_mst_private *mst;
  1800. if (!dp_display) {
  1801. DP_ERR("invalid params\n");
  1802. return;
  1803. }
  1804. mst = dp_display->dp_mst_prv_info;
  1805. if (!mst->mst_initialized)
  1806. return;
  1807. dp_display->mst_uninstall(dp_display);
  1808. drm_dp_mst_topology_mgr_destroy(&mst->mst_mgr);
  1809. dp_mst.mst_initialized = false;
  1810. mutex_destroy(&mst->mst_lock);
  1811. mutex_destroy(&mst->edid_lock);
  1812. DP_MST_INFO("dp drm mst topology manager deinit completed\n");
  1813. }