dp_mst_drm.c 61 KB

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