sde_connector.c 88 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
  4. */
  5. #define pr_fmt(fmt) "[drm:%s:%d] " fmt, __func__, __LINE__
  6. #include "msm_drv.h"
  7. #include "sde_dbg.h"
  8. #include "sde_kms.h"
  9. #include "sde_connector.h"
  10. #include "sde_encoder.h"
  11. #include "msm_cooling_device.h"
  12. #include <linux/backlight.h>
  13. #include <linux/string.h>
  14. #include "dsi_drm.h"
  15. #include "dsi_display.h"
  16. #include "sde_crtc.h"
  17. #include "sde_rm.h"
  18. #include "sde_vm.h"
  19. #include <drm/drm_probe_helper.h>
  20. #define BL_NODE_NAME_SIZE 32
  21. #define HDR10_PLUS_VSIF_TYPE_CODE 0x81
  22. /* Autorefresh will occur after FRAME_CNT frames. Large values are unlikely */
  23. #define AUTOREFRESH_MAX_FRAME_CNT 6
  24. #define SDE_DEBUG_CONN(c, fmt, ...) SDE_DEBUG("conn%d " fmt,\
  25. (c) ? (c)->base.base.id : -1, ##__VA_ARGS__)
  26. #define SDE_ERROR_CONN(c, fmt, ...) SDE_ERROR("conn%d " fmt,\
  27. (c) ? (c)->base.base.id : -1, ##__VA_ARGS__)
  28. static const struct drm_prop_enum_list e_topology_name[] = {
  29. {SDE_RM_TOPOLOGY_NONE, "sde_none"},
  30. {SDE_RM_TOPOLOGY_SINGLEPIPE, "sde_singlepipe"},
  31. {SDE_RM_TOPOLOGY_SINGLEPIPE_DSC, "sde_singlepipe_dsc"},
  32. {SDE_RM_TOPOLOGY_SINGLEPIPE_VDC, "sde_singlepipe_vdc"},
  33. {SDE_RM_TOPOLOGY_DUALPIPE, "sde_dualpipe"},
  34. {SDE_RM_TOPOLOGY_DUALPIPE_DSC, "sde_dualpipe_dsc"},
  35. {SDE_RM_TOPOLOGY_DUALPIPE_3DMERGE, "sde_dualpipemerge"},
  36. {SDE_RM_TOPOLOGY_DUALPIPE_3DMERGE_DSC, "sde_dualpipemerge_dsc"},
  37. {SDE_RM_TOPOLOGY_DUALPIPE_3DMERGE_VDC, "sde_dualpipemerge_vdc"},
  38. {SDE_RM_TOPOLOGY_DUALPIPE_DSCMERGE, "sde_dualpipe_dscmerge"},
  39. {SDE_RM_TOPOLOGY_PPSPLIT, "sde_ppsplit"},
  40. {SDE_RM_TOPOLOGY_QUADPIPE_3DMERGE, "sde_quadpipemerge"},
  41. {SDE_RM_TOPOLOGY_QUADPIPE_3DMERGE_DSC, "sde_quadpipe_3dmerge_dsc"},
  42. {SDE_RM_TOPOLOGY_QUADPIPE_DSCMERGE, "sde_quadpipe_dscmerge"},
  43. {SDE_RM_TOPOLOGY_QUADPIPE_DSC4HSMERGE, "sde_quadpipe_dsc4hsmerge"},
  44. };
  45. static const struct drm_prop_enum_list e_topology_control[] = {
  46. {SDE_RM_TOPCTL_RESERVE_LOCK, "reserve_lock"},
  47. {SDE_RM_TOPCTL_RESERVE_CLEAR, "reserve_clear"},
  48. {SDE_RM_TOPCTL_DSPP, "dspp"},
  49. {SDE_RM_TOPCTL_DS, "ds"},
  50. };
  51. static const struct drm_prop_enum_list e_power_mode[] = {
  52. {SDE_MODE_DPMS_ON, "ON"},
  53. {SDE_MODE_DPMS_LP1, "LP1"},
  54. {SDE_MODE_DPMS_LP2, "LP2"},
  55. {SDE_MODE_DPMS_OFF, "OFF"},
  56. };
  57. static const struct drm_prop_enum_list e_qsync_mode[] = {
  58. {SDE_RM_QSYNC_DISABLED, "none"},
  59. {SDE_RM_QSYNC_CONTINUOUS_MODE, "continuous"},
  60. {SDE_RM_QSYNC_ONE_SHOT_MODE, "one_shot"},
  61. };
  62. static const struct drm_prop_enum_list e_dsc_mode[] = {
  63. {MSM_DISPLAY_DSC_MODE_NONE, "none"},
  64. {MSM_DISPLAY_DSC_MODE_ENABLED, "dsc_enabled"},
  65. {MSM_DISPLAY_DSC_MODE_DISABLED, "dsc_disabled"},
  66. };
  67. static const struct drm_prop_enum_list e_frame_trigger_mode[] = {
  68. {FRAME_DONE_WAIT_DEFAULT, "default"},
  69. {FRAME_DONE_WAIT_SERIALIZE, "serialize_frame_trigger"},
  70. {FRAME_DONE_WAIT_POSTED_START, "posted_start"},
  71. };
  72. static const struct drm_prop_enum_list e_panel_mode[] = {
  73. {MSM_DISPLAY_VIDEO_MODE, "video_mode"},
  74. {MSM_DISPLAY_CMD_MODE, "command_mode"},
  75. {MSM_DISPLAY_MODE_MAX, "none"},
  76. };
  77. static inline struct sde_kms *_sde_connector_get_kms(struct drm_connector *conn)
  78. {
  79. struct msm_drm_private *priv;
  80. if (!conn || !conn->dev || !conn->dev->dev_private) {
  81. SDE_ERROR("invalid connector\n");
  82. return NULL;
  83. }
  84. priv = conn->dev->dev_private;
  85. if (!priv || !priv->kms) {
  86. SDE_ERROR("invalid kms\n");
  87. return NULL;
  88. }
  89. return to_sde_kms(priv->kms);
  90. }
  91. static void sde_dimming_bl_notify(struct sde_connector *conn, struct dsi_backlight_config *config)
  92. {
  93. struct drm_event event;
  94. struct drm_msm_backlight_info bl_info;
  95. if (!conn || !config)
  96. return;
  97. SDE_DEBUG("bl_config.dimming_status 0x%x user_disable_notify %d\n",
  98. config->dimming_status, config->user_disable_notification);
  99. if (!conn->dimming_bl_notify_enabled || config->user_disable_notification)
  100. return;
  101. bl_info.brightness_max = config->brightness_max_level;
  102. bl_info.brightness = config->brightness;
  103. bl_info.bl_level_max = config->bl_max_level;
  104. bl_info.bl_level = config->bl_level;
  105. bl_info.bl_scale = config->bl_scale;
  106. bl_info.bl_scale_sv = config->bl_scale_sv;
  107. bl_info.status = config->dimming_status;
  108. bl_info.min_bl = config->dimming_min_bl;
  109. bl_info.bl_scale_max = MAX_BL_SCALE_LEVEL;
  110. bl_info.bl_scale_sv_max = SV_BL_SCALE_CAP;
  111. event.type = DRM_EVENT_DIMMING_BL;
  112. event.length = sizeof(bl_info);
  113. SDE_DEBUG("dimming BL event bl_level %d bl_scale %d, bl_scale_sv = %d "
  114. "min_bl %d status 0x%x\n", bl_info.bl_level, bl_info.bl_scale,
  115. bl_info.bl_scale_sv, bl_info.min_bl, bl_info.status);
  116. msm_mode_object_event_notify(&conn->base.base, conn->base.dev, &event, (u8 *)&bl_info);
  117. }
  118. static int sde_backlight_device_update_status(struct backlight_device *bd)
  119. {
  120. int brightness;
  121. struct dsi_display *display;
  122. struct sde_connector *c_conn = bl_get_data(bd);
  123. int bl_lvl;
  124. struct drm_event event;
  125. int rc = 0;
  126. struct sde_kms *sde_kms;
  127. sde_kms = _sde_connector_get_kms(&c_conn->base);
  128. if (!sde_kms) {
  129. SDE_ERROR("invalid kms\n");
  130. return -EINVAL;
  131. }
  132. brightness = bd->props.brightness;
  133. if ((bd->props.power != FB_BLANK_UNBLANK) ||
  134. (bd->props.state & BL_CORE_FBBLANK) ||
  135. (bd->props.state & BL_CORE_SUSPENDED))
  136. brightness = 0;
  137. display = (struct dsi_display *) c_conn->display;
  138. if (brightness > display->panel->bl_config.brightness_max_level)
  139. brightness = display->panel->bl_config.brightness_max_level;
  140. if (brightness > c_conn->thermal_max_brightness)
  141. brightness = c_conn->thermal_max_brightness;
  142. display->panel->bl_config.brightness = brightness;
  143. /* map UI brightness into driver backlight level with rounding */
  144. bl_lvl = mult_frac(brightness, display->panel->bl_config.bl_max_level,
  145. display->panel->bl_config.brightness_max_level);
  146. if (!bl_lvl && brightness)
  147. bl_lvl = 1;
  148. if (!c_conn->allow_bl_update) {
  149. c_conn->unset_bl_level = bl_lvl;
  150. return 0;
  151. }
  152. sde_vm_lock(sde_kms);
  153. if (!sde_vm_owns_hw(sde_kms)) {
  154. SDE_DEBUG("skipping bl update due to HW unavailablity\n");
  155. goto done;
  156. }
  157. if (c_conn->ops.set_backlight) {
  158. /* skip notifying user space if bl is 0 */
  159. if (brightness != 0) {
  160. event.type = DRM_EVENT_SYS_BACKLIGHT;
  161. event.length = sizeof(u32);
  162. msm_mode_object_event_notify(&c_conn->base.base,
  163. c_conn->base.dev, &event, (u8 *)&brightness);
  164. }
  165. rc = c_conn->ops.set_backlight(&c_conn->base,
  166. c_conn->display, bl_lvl);
  167. if (!rc)
  168. sde_dimming_bl_notify(c_conn, &display->panel->bl_config);
  169. c_conn->unset_bl_level = 0;
  170. }
  171. done:
  172. sde_vm_unlock(sde_kms);
  173. return rc;
  174. }
  175. static int sde_backlight_device_get_brightness(struct backlight_device *bd)
  176. {
  177. return 0;
  178. }
  179. static const struct backlight_ops sde_backlight_device_ops = {
  180. .update_status = sde_backlight_device_update_status,
  181. .get_brightness = sde_backlight_device_get_brightness,
  182. };
  183. static int sde_backlight_cooling_cb(struct notifier_block *nb,
  184. unsigned long val, void *data)
  185. {
  186. struct sde_connector *c_conn;
  187. struct backlight_device *bd = (struct backlight_device *)data;
  188. c_conn = bl_get_data(bd);
  189. SDE_DEBUG("bl: thermal max brightness cap:%lu\n", val);
  190. c_conn->thermal_max_brightness = val;
  191. sde_backlight_device_update_status(bd);
  192. return 0;
  193. }
  194. static int sde_backlight_setup(struct sde_connector *c_conn,
  195. struct drm_device *dev)
  196. {
  197. struct backlight_properties props;
  198. struct dsi_display *display;
  199. struct dsi_backlight_config *bl_config;
  200. struct sde_kms *sde_kms;
  201. static int display_count;
  202. char bl_node_name[BL_NODE_NAME_SIZE];
  203. sde_kms = _sde_connector_get_kms(&c_conn->base);
  204. if (!sde_kms) {
  205. SDE_ERROR("invalid kms\n");
  206. return -EINVAL;
  207. } else if (c_conn->connector_type != DRM_MODE_CONNECTOR_DSI) {
  208. return 0;
  209. }
  210. display = (struct dsi_display *) c_conn->display;
  211. bl_config = &display->panel->bl_config;
  212. if (bl_config->type != DSI_BACKLIGHT_DCS &&
  213. sde_in_trusted_vm(sde_kms))
  214. return 0;
  215. memset(&props, 0, sizeof(props));
  216. props.type = BACKLIGHT_RAW;
  217. props.power = FB_BLANK_UNBLANK;
  218. props.max_brightness = bl_config->brightness_max_level;
  219. props.brightness = bl_config->brightness_max_level;
  220. snprintf(bl_node_name, BL_NODE_NAME_SIZE, "panel%u-backlight",
  221. display_count);
  222. c_conn->bl_device = backlight_device_register(bl_node_name, dev->dev, c_conn,
  223. &sde_backlight_device_ops, &props);
  224. if (IS_ERR_OR_NULL(c_conn->bl_device)) {
  225. SDE_ERROR("Failed to register backlight: %ld\n",
  226. PTR_ERR(c_conn->bl_device));
  227. c_conn->bl_device = NULL;
  228. return -ENODEV;
  229. }
  230. c_conn->thermal_max_brightness = bl_config->brightness_max_level;
  231. /**
  232. * In TVM, thermal cooling device is not enabled. Registering with dummy
  233. * thermal device will return a NULL leading to a failure. So skip it.
  234. */
  235. if (sde_in_trusted_vm(sde_kms))
  236. goto done;
  237. c_conn->n.notifier_call = sde_backlight_cooling_cb;
  238. c_conn->cdev = backlight_cdev_register(dev->dev, c_conn->bl_device,
  239. &c_conn->n);
  240. if (IS_ERR_OR_NULL(c_conn->cdev)) {
  241. SDE_INFO("Failed to register backlight cdev: %ld\n",
  242. PTR_ERR(c_conn->cdev));
  243. c_conn->cdev = NULL;
  244. }
  245. done:
  246. display_count++;
  247. return 0;
  248. }
  249. int sde_connector_trigger_event(void *drm_connector,
  250. uint32_t event_idx, uint32_t instance_idx,
  251. uint32_t data0, uint32_t data1,
  252. uint32_t data2, uint32_t data3)
  253. {
  254. struct sde_connector *c_conn;
  255. unsigned long irq_flags;
  256. int (*cb_func)(uint32_t event_idx,
  257. uint32_t instance_idx, void *usr,
  258. uint32_t data0, uint32_t data1,
  259. uint32_t data2, uint32_t data3);
  260. void *usr;
  261. int rc = 0;
  262. /*
  263. * This function may potentially be called from an ISR context, so
  264. * avoid excessive logging/etc.
  265. */
  266. if (!drm_connector)
  267. return -EINVAL;
  268. else if (event_idx >= SDE_CONN_EVENT_COUNT)
  269. return -EINVAL;
  270. c_conn = to_sde_connector(drm_connector);
  271. spin_lock_irqsave(&c_conn->event_lock, irq_flags);
  272. cb_func = c_conn->event_table[event_idx].cb_func;
  273. usr = c_conn->event_table[event_idx].usr;
  274. spin_unlock_irqrestore(&c_conn->event_lock, irq_flags);
  275. if (cb_func)
  276. rc = cb_func(event_idx, instance_idx, usr,
  277. data0, data1, data2, data3);
  278. else
  279. rc = -EAGAIN;
  280. return rc;
  281. }
  282. int sde_connector_register_event(struct drm_connector *connector,
  283. uint32_t event_idx,
  284. int (*cb_func)(uint32_t event_idx,
  285. uint32_t instance_idx, void *usr,
  286. uint32_t data0, uint32_t data1,
  287. uint32_t data2, uint32_t data3),
  288. void *usr)
  289. {
  290. struct sde_connector *c_conn;
  291. unsigned long irq_flags;
  292. if (!connector) {
  293. SDE_ERROR("invalid connector\n");
  294. return -EINVAL;
  295. } else if (event_idx >= SDE_CONN_EVENT_COUNT) {
  296. SDE_ERROR("conn%d, invalid event %d\n",
  297. connector->base.id, event_idx);
  298. return -EINVAL;
  299. }
  300. c_conn = to_sde_connector(connector);
  301. spin_lock_irqsave(&c_conn->event_lock, irq_flags);
  302. c_conn->event_table[event_idx].cb_func = cb_func;
  303. c_conn->event_table[event_idx].usr = usr;
  304. spin_unlock_irqrestore(&c_conn->event_lock, irq_flags);
  305. /* optionally notify display of event registration */
  306. if (c_conn->ops.enable_event && c_conn->display)
  307. c_conn->ops.enable_event(connector, event_idx,
  308. cb_func != NULL, c_conn->display);
  309. return 0;
  310. }
  311. void sde_connector_unregister_event(struct drm_connector *connector,
  312. uint32_t event_idx)
  313. {
  314. (void)sde_connector_register_event(connector, event_idx, 0, 0);
  315. }
  316. static void _sde_connector_install_dither_property(struct drm_device *dev,
  317. struct sde_kms *sde_kms, struct sde_connector *c_conn)
  318. {
  319. char prop_name[DRM_PROP_NAME_LEN];
  320. struct sde_mdss_cfg *catalog = NULL;
  321. u32 version = 0;
  322. if (!dev || !sde_kms || !c_conn) {
  323. SDE_ERROR("invld args (s), dev %pK, sde_kms %pK, c_conn %pK\n",
  324. dev, sde_kms, c_conn);
  325. return;
  326. }
  327. catalog = sde_kms->catalog;
  328. version = SDE_COLOR_PROCESS_MAJOR(
  329. catalog->pingpong[0].sblk->dither.version);
  330. snprintf(prop_name, ARRAY_SIZE(prop_name), "%s%d",
  331. "SDE_PP_DITHER_V", version);
  332. switch (version) {
  333. case 1:
  334. case 2:
  335. msm_property_install_blob(&c_conn->property_info, prop_name,
  336. DRM_MODE_PROP_BLOB,
  337. CONNECTOR_PROP_PP_DITHER);
  338. break;
  339. default:
  340. SDE_ERROR("unsupported dither version %d\n", version);
  341. return;
  342. }
  343. }
  344. int sde_connector_get_dither_cfg(struct drm_connector *conn,
  345. struct drm_connector_state *state, void **cfg,
  346. size_t *len, bool idle_pc)
  347. {
  348. struct sde_connector *c_conn = NULL;
  349. struct sde_connector_state *c_state = NULL;
  350. size_t dither_sz = 0;
  351. bool is_dirty;
  352. u32 *p = (u32 *)cfg;
  353. if (!conn || !state || !p) {
  354. SDE_ERROR("invalid arguments\n");
  355. return -EINVAL;
  356. }
  357. c_conn = to_sde_connector(conn);
  358. c_state = to_sde_connector_state(state);
  359. is_dirty = msm_property_is_dirty(&c_conn->property_info,
  360. &c_state->property_state,
  361. CONNECTOR_PROP_PP_DITHER);
  362. if (!is_dirty && !idle_pc) {
  363. return -ENODATA;
  364. } else if (is_dirty || idle_pc) {
  365. *cfg = msm_property_get_blob(&c_conn->property_info,
  366. &c_state->property_state,
  367. &dither_sz,
  368. CONNECTOR_PROP_PP_DITHER);
  369. /*
  370. * in idle_pc use case return early,
  371. * when dither is already disabled.
  372. */
  373. if (idle_pc && *cfg == NULL)
  374. return -ENODATA;
  375. /* disable dither based on user config data */
  376. else if (*cfg == NULL)
  377. return 0;
  378. }
  379. *len = dither_sz;
  380. return 0;
  381. }
  382. static void sde_connector_get_avail_res_info(struct drm_connector *conn,
  383. struct msm_resource_caps_info *avail_res)
  384. {
  385. struct sde_kms *sde_kms;
  386. struct drm_encoder *drm_enc = NULL;
  387. struct sde_connector *sde_conn;
  388. sde_kms = _sde_connector_get_kms(conn);
  389. if (!sde_kms) {
  390. SDE_ERROR("invalid kms\n");
  391. return;
  392. }
  393. sde_conn = to_sde_connector(conn);
  394. if (conn->state && conn->state->best_encoder)
  395. drm_enc = conn->state->best_encoder;
  396. else
  397. drm_enc = conn->encoder;
  398. sde_rm_get_resource_info(&sde_kms->rm, drm_enc, avail_res);
  399. if ((sde_kms->catalog->allowed_dsc_reservation_switch &
  400. SDE_DP_DSC_RESERVATION_SWITCH) &&
  401. sde_conn->connector_type == DRM_MODE_CONNECTOR_DisplayPort)
  402. avail_res->num_dsc = sde_kms->catalog->dsc_count;
  403. avail_res->max_mixer_width = sde_kms->catalog->max_mixer_width;
  404. }
  405. int sde_connector_set_msm_mode(struct drm_connector_state *conn_state,
  406. struct drm_display_mode *adj_mode)
  407. {
  408. struct sde_connector_state *c_state;
  409. c_state = to_sde_connector_state(conn_state);
  410. if (!c_state || !adj_mode) {
  411. SDE_ERROR("invalid params c_state: %d, adj_mode %d\n",
  412. c_state == NULL, adj_mode == NULL);
  413. return -EINVAL;
  414. }
  415. c_state->msm_mode.base = adj_mode;
  416. return 0;
  417. }
  418. int sde_connector_get_lm_cnt_from_topology(struct drm_connector *conn,
  419. const struct drm_display_mode *drm_mode)
  420. {
  421. struct sde_connector *c_conn;
  422. c_conn = to_sde_connector(conn);
  423. if (!c_conn || c_conn->connector_type != DRM_MODE_CONNECTOR_DSI ||
  424. !c_conn->ops.get_num_lm_from_mode)
  425. return -EINVAL;
  426. return c_conn->ops.get_num_lm_from_mode(c_conn->display, drm_mode);
  427. }
  428. int sde_connector_get_mode_info(struct drm_connector *conn,
  429. const struct drm_display_mode *drm_mode,
  430. struct msm_sub_mode *sub_mode,
  431. struct msm_mode_info *mode_info)
  432. {
  433. struct sde_connector *sde_conn;
  434. struct msm_resource_caps_info avail_res;
  435. memset(&avail_res, 0, sizeof(avail_res));
  436. sde_conn = to_sde_connector(conn);
  437. if (!sde_conn)
  438. return -EINVAL;
  439. sde_connector_get_avail_res_info(conn, &avail_res);
  440. return sde_conn->ops.get_mode_info(conn, drm_mode, sub_mode,
  441. mode_info, sde_conn->display, &avail_res);
  442. }
  443. int sde_connector_state_get_mode_info(struct drm_connector_state *conn_state,
  444. struct msm_mode_info *mode_info)
  445. {
  446. struct sde_connector_state *sde_conn_state = NULL;
  447. if (!conn_state || !mode_info) {
  448. SDE_ERROR("Invalid arguments\n");
  449. return -EINVAL;
  450. }
  451. sde_conn_state = to_sde_connector_state(conn_state);
  452. memcpy(mode_info, &sde_conn_state->mode_info,
  453. sizeof(sde_conn_state->mode_info));
  454. return 0;
  455. }
  456. static int sde_connector_handle_panel_id(uint32_t event_idx,
  457. uint32_t instance_idx, void *usr,
  458. uint32_t data0, uint32_t data1,
  459. uint32_t data2, uint32_t data3)
  460. {
  461. struct sde_connector *c_conn = usr;
  462. int i;
  463. u64 panel_id;
  464. u8 msb_arr[8];
  465. if (!c_conn)
  466. return -EINVAL;
  467. panel_id = (((u64)data0) << 32) | data1;
  468. if (panel_id == ~0x0)
  469. return 0;
  470. for (i = 0; i < 8; i++)
  471. msb_arr[i] = (panel_id >> (8 * (7 - i)));
  472. /* update the panel id */
  473. msm_property_set_blob(&c_conn->property_info,
  474. &c_conn->blob_panel_id, &msb_arr, sizeof(msb_arr),
  475. CONNECTOR_PROP_DEMURA_PANEL_ID);
  476. sde_connector_register_event(&c_conn->base,
  477. SDE_CONN_EVENT_PANEL_ID, NULL, c_conn);
  478. return 0;
  479. }
  480. static int sde_connector_handle_disp_recovery(uint32_t event_idx,
  481. uint32_t instance_idx, void *usr,
  482. uint32_t data0, uint32_t data1,
  483. uint32_t data2, uint32_t data3)
  484. {
  485. struct sde_connector *c_conn = usr;
  486. int rc = 0;
  487. if (!c_conn)
  488. return -EINVAL;
  489. rc = sde_kms_handle_recovery(c_conn->encoder);
  490. return rc;
  491. }
  492. int sde_connector_get_info(struct drm_connector *connector,
  493. struct msm_display_info *info)
  494. {
  495. struct sde_connector *c_conn;
  496. if (!connector || !info) {
  497. SDE_ERROR("invalid argument(s), conn %pK, info %pK\n",
  498. connector, info);
  499. return -EINVAL;
  500. }
  501. c_conn = to_sde_connector(connector);
  502. if (!c_conn->display || !c_conn->ops.get_info) {
  503. SDE_ERROR("display info not supported for %pK\n",
  504. c_conn->display);
  505. return -EINVAL;
  506. }
  507. return c_conn->ops.get_info(&c_conn->base, info, c_conn->display);
  508. }
  509. void sde_connector_schedule_status_work(struct drm_connector *connector,
  510. bool en)
  511. {
  512. struct sde_connector *c_conn;
  513. struct msm_display_info info;
  514. c_conn = to_sde_connector(connector);
  515. if (!c_conn)
  516. return;
  517. /* Return if there is no change in ESD status check condition */
  518. if (en == c_conn->esd_status_check)
  519. return;
  520. sde_connector_get_info(connector, &info);
  521. if (c_conn->ops.check_status &&
  522. (info.capabilities & MSM_DISPLAY_ESD_ENABLED)) {
  523. if (en) {
  524. u32 interval;
  525. /*
  526. * If debugfs property is not set then take
  527. * default value
  528. */
  529. interval = c_conn->esd_status_interval ?
  530. c_conn->esd_status_interval :
  531. STATUS_CHECK_INTERVAL_MS;
  532. /* Schedule ESD status check */
  533. schedule_delayed_work(&c_conn->status_work,
  534. msecs_to_jiffies(interval));
  535. c_conn->esd_status_check = true;
  536. } else {
  537. /* Cancel any pending ESD status check */
  538. cancel_delayed_work_sync(&c_conn->status_work);
  539. c_conn->esd_status_check = false;
  540. }
  541. }
  542. }
  543. static int _sde_connector_update_power_locked(struct sde_connector *c_conn)
  544. {
  545. struct drm_connector *connector;
  546. void *display;
  547. int (*set_power)(struct drm_connector *conn, int status, void *disp);
  548. int mode, rc = 0;
  549. if (!c_conn)
  550. return -EINVAL;
  551. connector = &c_conn->base;
  552. switch (c_conn->dpms_mode) {
  553. case DRM_MODE_DPMS_ON:
  554. mode = c_conn->lp_mode;
  555. break;
  556. case DRM_MODE_DPMS_STANDBY:
  557. mode = SDE_MODE_DPMS_STANDBY;
  558. break;
  559. case DRM_MODE_DPMS_SUSPEND:
  560. mode = SDE_MODE_DPMS_SUSPEND;
  561. break;
  562. case DRM_MODE_DPMS_OFF:
  563. mode = SDE_MODE_DPMS_OFF;
  564. break;
  565. default:
  566. mode = c_conn->lp_mode;
  567. SDE_ERROR("conn %d dpms set to unrecognized mode %d\n",
  568. connector->base.id, mode);
  569. break;
  570. }
  571. SDE_EVT32(connector->base.id, c_conn->dpms_mode, c_conn->lp_mode, mode);
  572. SDE_DEBUG("conn %d - dpms %d, lp %d, panel %d\n", connector->base.id,
  573. c_conn->dpms_mode, c_conn->lp_mode, mode);
  574. if (mode != c_conn->last_panel_power_mode && c_conn->ops.set_power) {
  575. display = c_conn->display;
  576. set_power = c_conn->ops.set_power;
  577. mutex_unlock(&c_conn->lock);
  578. rc = set_power(connector, mode, display);
  579. mutex_lock(&c_conn->lock);
  580. }
  581. c_conn->last_panel_power_mode = mode;
  582. mutex_unlock(&c_conn->lock);
  583. if (mode != SDE_MODE_DPMS_ON)
  584. sde_connector_schedule_status_work(connector, false);
  585. else
  586. sde_connector_schedule_status_work(connector, true);
  587. mutex_lock(&c_conn->lock);
  588. return rc;
  589. }
  590. static int _sde_connector_update_dimming_bl_lut(struct sde_connector *c_conn,
  591. struct sde_connector_state *c_state)
  592. {
  593. bool is_dirty;
  594. size_t sz = 0;
  595. struct dsi_display *dsi_display;
  596. struct dsi_backlight_config *bl_config;
  597. int rc = 0;
  598. if (!c_conn || !c_state) {
  599. SDE_ERROR("invalid arguments\n");
  600. return -EINVAL;
  601. }
  602. dsi_display = c_conn->display;
  603. if (!dsi_display || !dsi_display->panel) {
  604. SDE_ERROR("Invalid params(s) dsi_display %pK, panel %pK\n",
  605. dsi_display,
  606. ((dsi_display) ? dsi_display->panel : NULL));
  607. return -EINVAL;
  608. }
  609. is_dirty = msm_property_is_dirty(&c_conn->property_info,
  610. &c_state->property_state,
  611. CONNECTOR_PROP_DIMMING_BL_LUT);
  612. if (!is_dirty)
  613. return -ENODATA;
  614. bl_config = &dsi_display->panel->bl_config;
  615. bl_config->dimming_bl_lut = msm_property_get_blob(&c_conn->property_info,
  616. &c_state->property_state, &sz, CONNECTOR_PROP_DIMMING_BL_LUT);
  617. rc = c_conn->ops.set_backlight(&c_conn->base,
  618. dsi_display, bl_config->bl_level);
  619. if (!rc)
  620. c_conn->unset_bl_level = 0;
  621. return 0;
  622. }
  623. static int _sde_connector_update_dimming_ctrl(struct sde_connector *c_conn,
  624. struct sde_connector_state *c_state, uint64_t val)
  625. {
  626. struct dsi_display *dsi_display;
  627. struct dsi_backlight_config *bl_config;
  628. bool prev, curr = (bool)val;
  629. if (!c_conn || !c_state) {
  630. SDE_ERROR("invalid arguments\n");
  631. return -EINVAL;
  632. }
  633. dsi_display = c_conn->display;
  634. if (!dsi_display || !dsi_display->panel) {
  635. SDE_ERROR("Invalid params(s) dsi_display %pK, panel %pK\n",
  636. dsi_display,
  637. ((dsi_display) ? dsi_display->panel : NULL));
  638. return -EINVAL;
  639. }
  640. bl_config = &dsi_display->panel->bl_config;
  641. prev = (bool)(bl_config->dimming_status & DIMMING_ENABLE);
  642. if (curr == prev)
  643. return 0;
  644. if(val) {
  645. bl_config->dimming_status |= DIMMING_ENABLE;
  646. } else {
  647. bl_config->dimming_status &= ~DIMMING_ENABLE;
  648. }
  649. bl_config->user_disable_notification = false;
  650. sde_dimming_bl_notify(c_conn, bl_config);
  651. if (!val)
  652. bl_config->user_disable_notification = true;
  653. return 0;
  654. }
  655. static int _sde_connector_update_dimming_min_bl(struct sde_connector *c_conn,
  656. struct sde_connector_state *c_state, uint64_t val)
  657. {
  658. struct dsi_display *dsi_display;
  659. struct dsi_backlight_config *bl_config;
  660. uint32_t tmp = 0;
  661. if (!c_conn || !c_state) {
  662. SDE_ERROR("invalid arguments\n");
  663. return -EINVAL;
  664. }
  665. dsi_display = c_conn->display;
  666. if (!dsi_display || !dsi_display->panel) {
  667. SDE_ERROR("Invalid params(s) dsi_display %pK, panel %pK\n",
  668. dsi_display,
  669. ((dsi_display) ? dsi_display->panel : NULL));
  670. return -EINVAL;
  671. }
  672. bl_config = &dsi_display->panel->bl_config;
  673. tmp = (uint32_t)val;
  674. if (tmp == bl_config->dimming_min_bl)
  675. return 0;
  676. bl_config->dimming_min_bl = tmp;
  677. bl_config->dimming_status |= DIMMING_MIN_BL_VALID;
  678. sde_dimming_bl_notify(c_conn, bl_config);
  679. bl_config->dimming_status &= ~DIMMING_MIN_BL_VALID;
  680. return 0;
  681. }
  682. static int _sde_connector_update_bl_scale(struct sde_connector *c_conn)
  683. {
  684. struct dsi_display *dsi_display;
  685. struct dsi_backlight_config *bl_config;
  686. int rc = 0;
  687. if (!c_conn) {
  688. SDE_ERROR("Invalid params sde_connector null\n");
  689. return -EINVAL;
  690. }
  691. dsi_display = c_conn->display;
  692. if (!dsi_display || !dsi_display->panel) {
  693. SDE_ERROR("Invalid params(s) dsi_display %pK, panel %pK\n",
  694. dsi_display,
  695. ((dsi_display) ? dsi_display->panel : NULL));
  696. return -EINVAL;
  697. }
  698. bl_config = &dsi_display->panel->bl_config;
  699. if (!c_conn->allow_bl_update) {
  700. c_conn->unset_bl_level = bl_config->bl_level;
  701. return 0;
  702. }
  703. if (c_conn->unset_bl_level)
  704. bl_config->bl_level = c_conn->unset_bl_level;
  705. bl_config->bl_scale = c_conn->bl_scale > MAX_BL_SCALE_LEVEL ?
  706. MAX_BL_SCALE_LEVEL : c_conn->bl_scale;
  707. bl_config->bl_scale_sv = c_conn->bl_scale_sv > SV_BL_SCALE_CAP ?
  708. SV_BL_SCALE_CAP : c_conn->bl_scale_sv;
  709. SDE_DEBUG("bl_scale = %u, bl_scale_sv = %u, bl_level = %u\n",
  710. bl_config->bl_scale, bl_config->bl_scale_sv,
  711. bl_config->bl_level);
  712. rc = c_conn->ops.set_backlight(&c_conn->base,
  713. dsi_display, bl_config->bl_level);
  714. if (!rc)
  715. sde_dimming_bl_notify(c_conn, bl_config);
  716. c_conn->unset_bl_level = 0;
  717. return rc;
  718. }
  719. void sde_connector_set_colorspace(struct sde_connector *c_conn)
  720. {
  721. int rc = 0;
  722. if (c_conn->ops.set_colorspace)
  723. rc = c_conn->ops.set_colorspace(&c_conn->base,
  724. c_conn->display);
  725. if (rc)
  726. SDE_ERROR_CONN(c_conn, "cannot apply new colorspace %d\n", rc);
  727. }
  728. void sde_connector_set_qsync_params(struct drm_connector *connector)
  729. {
  730. struct sde_connector *c_conn;
  731. struct sde_connector_state *c_state;
  732. u32 qsync_propval = 0, step_val = 0;
  733. bool prop_dirty;
  734. if (!connector)
  735. return;
  736. c_conn = to_sde_connector(connector);
  737. c_state = to_sde_connector_state(connector->state);
  738. c_conn->qsync_updated = false;
  739. prop_dirty = msm_property_is_dirty(&c_conn->property_info,
  740. &c_state->property_state,
  741. CONNECTOR_PROP_QSYNC_MODE);
  742. if (prop_dirty) {
  743. qsync_propval = sde_connector_get_property(c_conn->base.state,
  744. CONNECTOR_PROP_QSYNC_MODE);
  745. if (qsync_propval != c_conn->qsync_mode) {
  746. SDE_DEBUG("updated qsync mode %d -> %d\n",
  747. c_conn->qsync_mode, qsync_propval);
  748. c_conn->qsync_updated = true;
  749. c_conn->qsync_mode = qsync_propval;
  750. }
  751. }
  752. prop_dirty = msm_property_is_dirty(&c_conn->property_info, &c_state->property_state,
  753. CONNECTOR_PROP_AVR_STEP);
  754. if (prop_dirty) {
  755. step_val = sde_connector_get_property(c_conn->base.state, CONNECTOR_PROP_AVR_STEP);
  756. if (step_val != c_conn->avr_step) {
  757. SDE_DEBUG("updated avr step %d -> %d\n", c_conn->avr_step, step_val);
  758. c_conn->qsync_updated = true;
  759. c_conn->avr_step = step_val;
  760. }
  761. }
  762. }
  763. void sde_connector_complete_qsync_commit(struct drm_connector *conn,
  764. struct msm_display_conn_params *params)
  765. {
  766. struct sde_connector *c_conn;
  767. if (!conn || !params) {
  768. SDE_ERROR("invalid params\n");
  769. return;
  770. }
  771. c_conn = to_sde_connector(conn);
  772. if (c_conn && c_conn->qsync_updated &&
  773. (c_conn->qsync_mode == SDE_RM_QSYNC_ONE_SHOT_MODE)) {
  774. /* Reset qsync states if mode is one shot */
  775. params->qsync_mode = c_conn->qsync_mode = 0;
  776. params->qsync_update = true;
  777. SDE_EVT32(conn->base.id, c_conn->qsync_mode);
  778. }
  779. }
  780. static int _sde_connector_update_hdr_metadata(struct sde_connector *c_conn,
  781. struct sde_connector_state *c_state)
  782. {
  783. int rc = 0;
  784. if (c_conn->ops.config_hdr)
  785. rc = c_conn->ops.config_hdr(&c_conn->base, c_conn->display,
  786. c_state);
  787. if (rc)
  788. SDE_ERROR_CONN(c_conn, "cannot apply hdr metadata %d\n", rc);
  789. SDE_DEBUG_CONN(c_conn, "updated hdr metadata: %d\n", rc);
  790. return rc;
  791. }
  792. static int _sde_connector_update_dirty_properties(
  793. struct drm_connector *connector)
  794. {
  795. struct sde_connector *c_conn;
  796. struct sde_connector_state *c_state;
  797. int idx;
  798. if (!connector) {
  799. SDE_ERROR("invalid argument\n");
  800. return -EINVAL;
  801. }
  802. c_conn = to_sde_connector(connector);
  803. c_state = to_sde_connector_state(connector->state);
  804. mutex_lock(&c_conn->property_info.property_lock);
  805. while ((idx = msm_property_pop_dirty(&c_conn->property_info,
  806. &c_state->property_state)) >= 0) {
  807. switch (idx) {
  808. case CONNECTOR_PROP_LP:
  809. mutex_lock(&c_conn->lock);
  810. c_conn->lp_mode = sde_connector_get_property(
  811. connector->state, CONNECTOR_PROP_LP);
  812. _sde_connector_update_power_locked(c_conn);
  813. mutex_unlock(&c_conn->lock);
  814. break;
  815. case CONNECTOR_PROP_HDR_METADATA:
  816. _sde_connector_update_hdr_metadata(c_conn, c_state);
  817. break;
  818. default:
  819. /* nothing to do for most properties */
  820. break;
  821. }
  822. }
  823. mutex_unlock(&c_conn->property_info.property_lock);
  824. /* if colorspace needs to be updated do it first */
  825. if (c_conn->colorspace_updated) {
  826. c_conn->colorspace_updated = false;
  827. sde_connector_set_colorspace(c_conn);
  828. }
  829. /*
  830. * Special handling for postproc properties and
  831. * for updating backlight if any unset backlight level is present
  832. */
  833. if (c_conn->bl_scale_dirty || c_conn->unset_bl_level) {
  834. _sde_connector_update_bl_scale(c_conn);
  835. c_conn->bl_scale_dirty = false;
  836. }
  837. return 0;
  838. }
  839. struct sde_connector_dyn_hdr_metadata *sde_connector_get_dyn_hdr_meta(
  840. struct drm_connector *connector)
  841. {
  842. struct sde_connector_state *c_state;
  843. if (!connector)
  844. return NULL;
  845. c_state = to_sde_connector_state(connector->state);
  846. return &c_state->dyn_hdr_meta;
  847. }
  848. int sde_connector_pre_kickoff(struct drm_connector *connector)
  849. {
  850. struct sde_connector *c_conn;
  851. struct sde_connector_state *c_state;
  852. struct msm_display_kickoff_params params;
  853. struct dsi_display *display;
  854. int rc;
  855. if (!connector) {
  856. SDE_ERROR("invalid argument\n");
  857. return -EINVAL;
  858. }
  859. c_conn = to_sde_connector(connector);
  860. c_state = to_sde_connector_state(connector->state);
  861. if (!c_conn->display) {
  862. SDE_ERROR("invalid connector display\n");
  863. return -EINVAL;
  864. }
  865. display = (struct dsi_display *)c_conn->display;
  866. /*
  867. * During pre kickoff DCS commands have to have an
  868. * asynchronous wait to avoid an unnecessary stall
  869. * in pre-kickoff. This flag must be reset at the
  870. * end of display pre-kickoff.
  871. */
  872. if (c_conn->connector_type == DRM_MODE_CONNECTOR_DSI)
  873. display->queue_cmd_waits = true;
  874. rc = _sde_connector_update_dirty_properties(connector);
  875. if (rc) {
  876. SDE_EVT32(connector->base.id, SDE_EVTLOG_ERROR);
  877. goto end;
  878. }
  879. if (!c_conn->ops.pre_kickoff)
  880. return 0;
  881. params.rois = &c_state->rois;
  882. params.hdr_meta = &c_state->hdr_meta;
  883. SDE_EVT32_VERBOSE(connector->base.id);
  884. rc = c_conn->ops.pre_kickoff(connector, c_conn->display, &params);
  885. if (c_conn->connector_type == DRM_MODE_CONNECTOR_DSI)
  886. display->queue_cmd_waits = false;
  887. end:
  888. return rc;
  889. }
  890. int sde_connector_prepare_commit(struct drm_connector *connector)
  891. {
  892. struct sde_connector *c_conn;
  893. struct sde_connector_state *c_state;
  894. struct msm_display_conn_params params;
  895. int rc;
  896. if (!connector) {
  897. SDE_ERROR("invalid argument\n");
  898. return -EINVAL;
  899. }
  900. c_conn = to_sde_connector(connector);
  901. c_state = to_sde_connector_state(connector->state);
  902. if (!c_conn->display) {
  903. SDE_ERROR("invalid connector display\n");
  904. return -EINVAL;
  905. }
  906. if (!c_conn->ops.prepare_commit)
  907. return 0;
  908. memset(&params, 0, sizeof(params));
  909. if (c_conn->qsync_updated) {
  910. params.qsync_mode = c_conn->qsync_mode;
  911. params.qsync_update = true;
  912. }
  913. rc = c_conn->ops.prepare_commit(c_conn->display, &params);
  914. SDE_EVT32(connector->base.id, params.qsync_mode,
  915. params.qsync_update, rc);
  916. return rc;
  917. }
  918. void sde_connector_helper_bridge_disable(struct drm_connector *connector)
  919. {
  920. int rc;
  921. struct sde_connector *c_conn = NULL;
  922. struct dsi_display *display;
  923. bool poms_pending = false;
  924. struct sde_kms *sde_kms;
  925. sde_kms = _sde_connector_get_kms(connector);
  926. if (!sde_kms) {
  927. SDE_ERROR("invalid kms\n");
  928. return;
  929. }
  930. c_conn = to_sde_connector(connector);
  931. if (c_conn->connector_type == DRM_MODE_CONNECTOR_DSI) {
  932. display = (struct dsi_display *) c_conn->display;
  933. poms_pending = display->poms_pending;
  934. }
  935. if (!poms_pending) {
  936. rc = _sde_connector_update_dirty_properties(connector);
  937. if (rc) {
  938. SDE_ERROR("conn %d final pre kickoff failed %d\n",
  939. connector->base.id, rc);
  940. SDE_EVT32(connector->base.id, SDE_EVTLOG_ERROR);
  941. }
  942. }
  943. /* Disable ESD thread */
  944. sde_connector_schedule_status_work(connector, false);
  945. if (!sde_in_trusted_vm(sde_kms) && c_conn->bl_device) {
  946. c_conn->bl_device->props.power = FB_BLANK_POWERDOWN;
  947. c_conn->bl_device->props.state |= BL_CORE_FBBLANK;
  948. backlight_update_status(c_conn->bl_device);
  949. }
  950. c_conn->allow_bl_update = false;
  951. }
  952. void sde_connector_helper_bridge_post_disable(struct drm_connector *connector)
  953. {
  954. struct sde_connector *c_conn = NULL;
  955. c_conn = to_sde_connector(connector);
  956. c_conn->panel_dead = false;
  957. }
  958. void sde_connector_helper_bridge_enable(struct drm_connector *connector)
  959. {
  960. struct sde_connector *c_conn = NULL;
  961. struct dsi_display *display;
  962. struct sde_kms *sde_kms;
  963. sde_kms = _sde_connector_get_kms(connector);
  964. if (!sde_kms) {
  965. SDE_ERROR("invalid kms\n");
  966. return;
  967. }
  968. c_conn = to_sde_connector(connector);
  969. display = (struct dsi_display *) c_conn->display;
  970. /*
  971. * Special handling for some panels which need atleast
  972. * one frame to be transferred to GRAM before enabling backlight.
  973. * So delay backlight update to these panels until the
  974. * first frame commit is received from the HW.
  975. */
  976. if (display->panel->bl_config.bl_update ==
  977. BL_UPDATE_DELAY_UNTIL_FIRST_FRAME)
  978. sde_encoder_wait_for_event(c_conn->encoder,
  979. MSM_ENC_TX_COMPLETE);
  980. c_conn->allow_bl_update = true;
  981. if (!sde_in_trusted_vm(sde_kms) && c_conn->bl_device) {
  982. c_conn->bl_device->props.power = FB_BLANK_UNBLANK;
  983. c_conn->bl_device->props.state &= ~BL_CORE_FBBLANK;
  984. backlight_update_status(c_conn->bl_device);
  985. }
  986. }
  987. int sde_connector_clk_ctrl(struct drm_connector *connector, bool enable)
  988. {
  989. struct sde_connector *c_conn;
  990. struct dsi_display *display;
  991. u32 state = enable ? DSI_CLK_ON : DSI_CLK_OFF;
  992. int rc = 0;
  993. if (!connector) {
  994. SDE_ERROR("invalid connector\n");
  995. return -EINVAL;
  996. }
  997. c_conn = to_sde_connector(connector);
  998. display = (struct dsi_display *) c_conn->display;
  999. if (display && c_conn->ops.clk_ctrl)
  1000. rc = c_conn->ops.clk_ctrl(display->mdp_clk_handle,
  1001. DSI_ALL_CLKS, state);
  1002. return rc;
  1003. }
  1004. void sde_connector_destroy(struct drm_connector *connector)
  1005. {
  1006. struct sde_connector *c_conn;
  1007. if (!connector) {
  1008. SDE_ERROR("invalid connector\n");
  1009. return;
  1010. }
  1011. c_conn = to_sde_connector(connector);
  1012. /* cancel if any pending esd work */
  1013. sde_connector_schedule_status_work(connector, false);
  1014. if (c_conn->ops.pre_destroy)
  1015. c_conn->ops.pre_destroy(connector, c_conn->display);
  1016. if (c_conn->blob_caps)
  1017. drm_property_blob_put(c_conn->blob_caps);
  1018. if (c_conn->blob_hdr)
  1019. drm_property_blob_put(c_conn->blob_hdr);
  1020. if (c_conn->blob_dither)
  1021. drm_property_blob_put(c_conn->blob_dither);
  1022. if (c_conn->blob_mode_info)
  1023. drm_property_blob_put(c_conn->blob_mode_info);
  1024. if (c_conn->blob_ext_hdr)
  1025. drm_property_blob_put(c_conn->blob_ext_hdr);
  1026. if (c_conn->cdev)
  1027. backlight_cdev_unregister(c_conn->cdev);
  1028. if (c_conn->bl_device)
  1029. backlight_device_unregister(c_conn->bl_device);
  1030. drm_connector_unregister(connector);
  1031. mutex_destroy(&c_conn->lock);
  1032. sde_fence_deinit(c_conn->retire_fence);
  1033. drm_connector_cleanup(connector);
  1034. msm_property_destroy(&c_conn->property_info);
  1035. kfree(c_conn);
  1036. }
  1037. /**
  1038. * _sde_connector_destroy_fb - clean up connector state's out_fb buffer
  1039. * @c_conn: Pointer to sde connector structure
  1040. * @c_state: Pointer to sde connector state structure
  1041. */
  1042. static void _sde_connector_destroy_fb(struct sde_connector *c_conn,
  1043. struct sde_connector_state *c_state)
  1044. {
  1045. if (!c_state || !c_state->out_fb) {
  1046. SDE_ERROR("invalid state %pK\n", c_state);
  1047. return;
  1048. }
  1049. drm_framebuffer_put(c_state->out_fb);
  1050. c_state->out_fb = NULL;
  1051. if (c_conn)
  1052. c_state->property_values[CONNECTOR_PROP_OUT_FB].value =
  1053. msm_property_get_default(&c_conn->property_info,
  1054. CONNECTOR_PROP_OUT_FB);
  1055. else
  1056. c_state->property_values[CONNECTOR_PROP_OUT_FB].value = ~0;
  1057. }
  1058. static void sde_connector_atomic_destroy_state(struct drm_connector *connector,
  1059. struct drm_connector_state *state)
  1060. {
  1061. struct sde_connector *c_conn = NULL;
  1062. struct sde_connector_state *c_state = NULL;
  1063. if (!state) {
  1064. SDE_ERROR("invalid state\n");
  1065. return;
  1066. }
  1067. /*
  1068. * The base DRM framework currently always passes in a NULL
  1069. * connector pointer. This is not correct, but attempt to
  1070. * handle that case as much as possible.
  1071. */
  1072. if (connector)
  1073. c_conn = to_sde_connector(connector);
  1074. c_state = to_sde_connector_state(state);
  1075. if (c_state->out_fb)
  1076. _sde_connector_destroy_fb(c_conn, c_state);
  1077. __drm_atomic_helper_connector_destroy_state(&c_state->base);
  1078. if (!c_conn) {
  1079. kfree(c_state);
  1080. } else {
  1081. /* destroy value helper */
  1082. msm_property_destroy_state(&c_conn->property_info, c_state,
  1083. &c_state->property_state);
  1084. }
  1085. }
  1086. static void sde_connector_atomic_reset(struct drm_connector *connector)
  1087. {
  1088. struct sde_connector *c_conn;
  1089. struct sde_connector_state *c_state;
  1090. if (!connector) {
  1091. SDE_ERROR("invalid connector\n");
  1092. return;
  1093. }
  1094. c_conn = to_sde_connector(connector);
  1095. if (connector->state &&
  1096. !sde_crtc_is_reset_required(connector->state->crtc)) {
  1097. SDE_DEBUG_CONN(c_conn, "avoid reset for connector\n");
  1098. return;
  1099. }
  1100. if (connector->state) {
  1101. sde_connector_atomic_destroy_state(connector, connector->state);
  1102. connector->state = 0;
  1103. }
  1104. c_state = msm_property_alloc_state(&c_conn->property_info);
  1105. if (!c_state) {
  1106. SDE_ERROR("state alloc failed\n");
  1107. return;
  1108. }
  1109. /* reset value helper, zero out state structure and reset properties */
  1110. msm_property_reset_state(&c_conn->property_info, c_state,
  1111. &c_state->property_state,
  1112. c_state->property_values);
  1113. __drm_atomic_helper_connector_reset(connector, &c_state->base);
  1114. }
  1115. static struct drm_connector_state *
  1116. sde_connector_atomic_duplicate_state(struct drm_connector *connector)
  1117. {
  1118. struct sde_connector *c_conn;
  1119. struct sde_connector_state *c_state, *c_oldstate;
  1120. if (!connector || !connector->state) {
  1121. SDE_ERROR("invalid connector %pK\n", connector);
  1122. return NULL;
  1123. }
  1124. c_conn = to_sde_connector(connector);
  1125. c_oldstate = to_sde_connector_state(connector->state);
  1126. if (c_oldstate->cont_splash_populated) {
  1127. connector->state->crtc = NULL;
  1128. c_oldstate->cont_splash_populated = false;
  1129. }
  1130. c_state = msm_property_alloc_state(&c_conn->property_info);
  1131. if (!c_state) {
  1132. SDE_ERROR("state alloc failed\n");
  1133. return NULL;
  1134. }
  1135. /* duplicate value helper */
  1136. msm_property_duplicate_state(&c_conn->property_info,
  1137. c_oldstate, c_state,
  1138. &c_state->property_state, c_state->property_values);
  1139. __drm_atomic_helper_connector_duplicate_state(connector,
  1140. &c_state->base);
  1141. /* additional handling for drm framebuffer objects */
  1142. if (c_state->out_fb)
  1143. drm_framebuffer_get(c_state->out_fb);
  1144. /* clear dynamic HDR metadata from prev state */
  1145. if (c_state->dyn_hdr_meta.dynamic_hdr_update) {
  1146. c_state->dyn_hdr_meta.dynamic_hdr_update = false;
  1147. c_state->dyn_hdr_meta.dynamic_hdr_payload_size = 0;
  1148. }
  1149. return &c_state->base;
  1150. }
  1151. int sde_connector_roi_v1_check_roi(struct drm_connector_state *conn_state)
  1152. {
  1153. const struct msm_roi_alignment *align = NULL;
  1154. struct sde_connector *c_conn = NULL;
  1155. struct msm_mode_info mode_info;
  1156. struct sde_connector_state *c_state;
  1157. int i, w, h;
  1158. if (!conn_state)
  1159. return -EINVAL;
  1160. memset(&mode_info, 0, sizeof(mode_info));
  1161. c_state = to_sde_connector_state(conn_state);
  1162. c_conn = to_sde_connector(conn_state->connector);
  1163. memcpy(&mode_info, &c_state->mode_info, sizeof(c_state->mode_info));
  1164. if (!mode_info.roi_caps.enabled)
  1165. return 0;
  1166. if (c_state->rois.num_rects > mode_info.roi_caps.num_roi) {
  1167. SDE_ERROR_CONN(c_conn, "too many rects specified: %d > %d\n",
  1168. c_state->rois.num_rects,
  1169. mode_info.roi_caps.num_roi);
  1170. return -E2BIG;
  1171. }
  1172. align = &mode_info.roi_caps.align;
  1173. for (i = 0; i < c_state->rois.num_rects; ++i) {
  1174. struct drm_clip_rect *roi_conn;
  1175. roi_conn = &c_state->rois.roi[i];
  1176. w = roi_conn->x2 - roi_conn->x1;
  1177. h = roi_conn->y2 - roi_conn->y1;
  1178. SDE_EVT32_VERBOSE(DRMID(&c_conn->base),
  1179. roi_conn->x1, roi_conn->y1,
  1180. roi_conn->x2, roi_conn->y2);
  1181. if (w <= 0 || h <= 0) {
  1182. SDE_ERROR_CONN(c_conn, "invalid conn roi w %d h %d\n",
  1183. w, h);
  1184. return -EINVAL;
  1185. }
  1186. if (w < align->min_width || w % align->width_pix_align) {
  1187. SDE_ERROR_CONN(c_conn,
  1188. "invalid conn roi width %d min %d align %d\n",
  1189. w, align->min_width,
  1190. align->width_pix_align);
  1191. return -EINVAL;
  1192. }
  1193. if (h < align->min_height || h % align->height_pix_align) {
  1194. SDE_ERROR_CONN(c_conn,
  1195. "invalid conn roi height %d min %d align %d\n",
  1196. h, align->min_height,
  1197. align->height_pix_align);
  1198. return -EINVAL;
  1199. }
  1200. if (roi_conn->x1 % align->xstart_pix_align) {
  1201. SDE_ERROR_CONN(c_conn,
  1202. "invalid conn roi x1 %d align %d\n",
  1203. roi_conn->x1, align->xstart_pix_align);
  1204. return -EINVAL;
  1205. }
  1206. if (roi_conn->y1 % align->ystart_pix_align) {
  1207. SDE_ERROR_CONN(c_conn,
  1208. "invalid conn roi y1 %d align %d\n",
  1209. roi_conn->y1, align->ystart_pix_align);
  1210. return -EINVAL;
  1211. }
  1212. }
  1213. return 0;
  1214. }
  1215. static int _sde_connector_set_roi_v1(
  1216. struct sde_connector *c_conn,
  1217. struct sde_connector_state *c_state,
  1218. void __user *usr_ptr)
  1219. {
  1220. struct sde_drm_roi_v1 roi_v1;
  1221. int i;
  1222. if (!c_conn || !c_state) {
  1223. SDE_ERROR("invalid args\n");
  1224. return -EINVAL;
  1225. }
  1226. memset(&c_state->rois, 0, sizeof(c_state->rois));
  1227. if (!usr_ptr) {
  1228. SDE_DEBUG_CONN(c_conn, "rois cleared\n");
  1229. return 0;
  1230. }
  1231. if (copy_from_user(&roi_v1, usr_ptr, sizeof(roi_v1))) {
  1232. SDE_ERROR_CONN(c_conn, "failed to copy roi_v1 data\n");
  1233. return -EINVAL;
  1234. }
  1235. SDE_DEBUG_CONN(c_conn, "num_rects %d\n", roi_v1.num_rects);
  1236. if (roi_v1.num_rects == 0) {
  1237. SDE_DEBUG_CONN(c_conn, "rois cleared\n");
  1238. return 0;
  1239. }
  1240. if (roi_v1.num_rects > SDE_MAX_ROI_V1) {
  1241. SDE_ERROR_CONN(c_conn, "num roi rects more than supported: %d",
  1242. roi_v1.num_rects);
  1243. return -EINVAL;
  1244. }
  1245. c_state->rois.num_rects = roi_v1.num_rects;
  1246. for (i = 0; i < roi_v1.num_rects; ++i) {
  1247. c_state->rois.roi[i] = roi_v1.roi[i];
  1248. SDE_DEBUG_CONN(c_conn, "roi%d: roi (%d,%d) (%d,%d)\n", i,
  1249. c_state->rois.roi[i].x1,
  1250. c_state->rois.roi[i].y1,
  1251. c_state->rois.roi[i].x2,
  1252. c_state->rois.roi[i].y2);
  1253. }
  1254. return 0;
  1255. }
  1256. static int _sde_connector_set_ext_hdr_info(
  1257. struct sde_connector *c_conn,
  1258. struct sde_connector_state *c_state,
  1259. void __user *usr_ptr)
  1260. {
  1261. int rc = 0;
  1262. struct drm_msm_ext_hdr_metadata *hdr_meta;
  1263. size_t payload_size = 0;
  1264. u8 *payload = NULL;
  1265. int i;
  1266. if (!c_conn || !c_state) {
  1267. SDE_ERROR_CONN(c_conn, "invalid args\n");
  1268. rc = -EINVAL;
  1269. goto end;
  1270. }
  1271. memset(&c_state->hdr_meta, 0, sizeof(c_state->hdr_meta));
  1272. if (!usr_ptr) {
  1273. SDE_DEBUG_CONN(c_conn, "hdr metadata cleared\n");
  1274. goto end;
  1275. }
  1276. if (!c_conn->hdr_supported) {
  1277. SDE_ERROR_CONN(c_conn, "sink doesn't support HDR\n");
  1278. rc = -ENOTSUPP;
  1279. goto end;
  1280. }
  1281. if (copy_from_user(&c_state->hdr_meta,
  1282. (void __user *)usr_ptr,
  1283. sizeof(*hdr_meta))) {
  1284. SDE_ERROR_CONN(c_conn, "failed to copy hdr metadata\n");
  1285. rc = -EFAULT;
  1286. goto end;
  1287. }
  1288. hdr_meta = &c_state->hdr_meta;
  1289. /* dynamic metadata support */
  1290. if (!hdr_meta->hdr_plus_payload_size || !hdr_meta->hdr_plus_payload)
  1291. goto skip_dhdr;
  1292. if (!c_conn->hdr_plus_app_ver) {
  1293. SDE_ERROR_CONN(c_conn, "sink doesn't support dynamic HDR\n");
  1294. rc = -ENOTSUPP;
  1295. goto end;
  1296. }
  1297. payload_size = hdr_meta->hdr_plus_payload_size;
  1298. if (payload_size > sizeof(c_state->dyn_hdr_meta.dynamic_hdr_payload)) {
  1299. SDE_ERROR_CONN(c_conn, "payload size exceeds limit\n");
  1300. rc = -EINVAL;
  1301. goto end;
  1302. }
  1303. payload = c_state->dyn_hdr_meta.dynamic_hdr_payload;
  1304. if (copy_from_user(payload,
  1305. (void __user *)c_state->hdr_meta.hdr_plus_payload,
  1306. payload_size)) {
  1307. SDE_ERROR_CONN(c_conn, "failed to copy dhdr metadata\n");
  1308. rc = -EFAULT;
  1309. goto end;
  1310. }
  1311. /* verify 1st header byte, programmed in DP Infoframe SDP header */
  1312. if (payload_size < 1 || (payload[0] != HDR10_PLUS_VSIF_TYPE_CODE)) {
  1313. SDE_ERROR_CONN(c_conn, "invalid payload detected, size: %zd\n",
  1314. payload_size);
  1315. rc = -EINVAL;
  1316. goto end;
  1317. }
  1318. c_state->dyn_hdr_meta.dynamic_hdr_update = true;
  1319. skip_dhdr:
  1320. c_state->dyn_hdr_meta.dynamic_hdr_payload_size = payload_size;
  1321. SDE_DEBUG_CONN(c_conn, "hdr_state %d\n", hdr_meta->hdr_state);
  1322. SDE_DEBUG_CONN(c_conn, "hdr_supported %d\n", hdr_meta->hdr_supported);
  1323. SDE_DEBUG_CONN(c_conn, "eotf %d\n", hdr_meta->eotf);
  1324. SDE_DEBUG_CONN(c_conn, "white_point_x %d\n", hdr_meta->white_point_x);
  1325. SDE_DEBUG_CONN(c_conn, "white_point_y %d\n", hdr_meta->white_point_y);
  1326. SDE_DEBUG_CONN(c_conn, "max_luminance %d\n", hdr_meta->max_luminance);
  1327. SDE_DEBUG_CONN(c_conn, "max_content_light_level %d\n",
  1328. hdr_meta->max_content_light_level);
  1329. SDE_DEBUG_CONN(c_conn, "max_average_light_level %d\n",
  1330. hdr_meta->max_average_light_level);
  1331. for (i = 0; i < HDR_PRIMARIES_COUNT; i++) {
  1332. SDE_DEBUG_CONN(c_conn, "display_primaries_x [%d]\n",
  1333. hdr_meta->display_primaries_x[i]);
  1334. SDE_DEBUG_CONN(c_conn, "display_primaries_y [%d]\n",
  1335. hdr_meta->display_primaries_y[i]);
  1336. }
  1337. SDE_DEBUG_CONN(c_conn, "hdr_plus payload%s updated, size %d\n",
  1338. c_state->dyn_hdr_meta.dynamic_hdr_update ? "" : " NOT",
  1339. c_state->dyn_hdr_meta.dynamic_hdr_payload_size);
  1340. end:
  1341. return rc;
  1342. }
  1343. static int _sde_connector_set_prop_out_fb(struct drm_connector *connector,
  1344. struct drm_connector_state *state,
  1345. uint64_t val)
  1346. {
  1347. int rc = 0;
  1348. struct sde_connector *c_conn;
  1349. struct sde_connector_state *c_state;
  1350. c_conn = to_sde_connector(connector);
  1351. c_state = to_sde_connector_state(state);
  1352. /* clear old fb, if present */
  1353. if (c_state->out_fb)
  1354. _sde_connector_destroy_fb(c_conn, c_state);
  1355. /* convert fb val to drm framebuffer and prepare it */
  1356. c_state->out_fb =
  1357. drm_framebuffer_lookup(connector->dev, NULL, val);
  1358. if (!c_state->out_fb && val) {
  1359. SDE_ERROR("failed to look up fb %lld\n", val);
  1360. rc = -EFAULT;
  1361. } else if (!c_state->out_fb && !val) {
  1362. SDE_DEBUG("cleared fb_id\n");
  1363. rc = 0;
  1364. }
  1365. return rc;
  1366. }
  1367. static int _sde_connector_set_prop_retire_fence(struct drm_connector *connector,
  1368. struct drm_connector_state *state,
  1369. uint64_t val)
  1370. {
  1371. int rc = 0;
  1372. struct sde_connector *c_conn;
  1373. uint64_t fence_user_fd;
  1374. uint64_t __user prev_user_fd;
  1375. c_conn = to_sde_connector(connector);
  1376. rc = copy_from_user(&prev_user_fd, (void __user *)val,
  1377. sizeof(uint64_t));
  1378. if (rc) {
  1379. SDE_ERROR("copy from user failed rc:%d\n", rc);
  1380. rc = -EFAULT;
  1381. goto end;
  1382. }
  1383. /*
  1384. * client is expected to reset the property to -1 before
  1385. * requesting for the retire fence
  1386. */
  1387. if (prev_user_fd == -1) {
  1388. uint32_t offset;
  1389. offset = sde_connector_get_property(state,
  1390. CONN_PROP_RETIRE_FENCE_OFFSET);
  1391. /*
  1392. * update the offset to a timeline for
  1393. * commit completion
  1394. */
  1395. offset++;
  1396. rc = sde_fence_create(c_conn->retire_fence,
  1397. &fence_user_fd, offset);
  1398. if (rc) {
  1399. SDE_ERROR("fence create failed rc:%d\n", rc);
  1400. goto end;
  1401. }
  1402. rc = copy_to_user((uint64_t __user *)(uintptr_t)val,
  1403. &fence_user_fd, sizeof(uint64_t));
  1404. if (rc) {
  1405. SDE_ERROR("copy to user failed rc:%d\n", rc);
  1406. /*
  1407. * fence will be released with timeline
  1408. * update
  1409. */
  1410. put_unused_fd(fence_user_fd);
  1411. rc = -EFAULT;
  1412. goto end;
  1413. }
  1414. }
  1415. end:
  1416. return rc;
  1417. }
  1418. static int sde_connector_atomic_set_property(struct drm_connector *connector,
  1419. struct drm_connector_state *state,
  1420. struct drm_property *property,
  1421. uint64_t val)
  1422. {
  1423. struct sde_connector *c_conn;
  1424. struct sde_connector_state *c_state;
  1425. int idx, rc;
  1426. if (!connector || !state || !property) {
  1427. SDE_ERROR("invalid argument(s), conn %pK, state %pK, prp %pK\n",
  1428. connector, state, property);
  1429. return -EINVAL;
  1430. }
  1431. c_conn = to_sde_connector(connector);
  1432. c_state = to_sde_connector_state(state);
  1433. /* generic property handling */
  1434. rc = msm_property_atomic_set(&c_conn->property_info,
  1435. &c_state->property_state, property, val);
  1436. if (rc)
  1437. goto end;
  1438. /* connector-specific property handling */
  1439. idx = msm_property_index(&c_conn->property_info, property);
  1440. switch (idx) {
  1441. case CONNECTOR_PROP_OUT_FB:
  1442. rc = _sde_connector_set_prop_out_fb(connector, state, val);
  1443. break;
  1444. case CONNECTOR_PROP_RETIRE_FENCE:
  1445. if (!val)
  1446. goto end;
  1447. rc = _sde_connector_set_prop_retire_fence(connector, state, val);
  1448. break;
  1449. case CONNECTOR_PROP_ROI_V1:
  1450. rc = _sde_connector_set_roi_v1(c_conn, c_state,
  1451. (void *)(uintptr_t)val);
  1452. if (rc)
  1453. SDE_ERROR_CONN(c_conn, "invalid roi_v1, rc: %d\n", rc);
  1454. break;
  1455. /* CONNECTOR_PROP_BL_SCALE and CONNECTOR_PROP_SV_BL_SCALE are
  1456. * color-processing properties. These two properties require
  1457. * special handling since they don't quite fit the current standard
  1458. * atomic set property framework.
  1459. */
  1460. case CONNECTOR_PROP_BL_SCALE:
  1461. c_conn->bl_scale = val;
  1462. c_conn->bl_scale_dirty = true;
  1463. break;
  1464. case CONNECTOR_PROP_SV_BL_SCALE:
  1465. c_conn->bl_scale_sv = val;
  1466. c_conn->bl_scale_dirty = true;
  1467. break;
  1468. case CONNECTOR_PROP_DIMMING_BL_LUT:
  1469. rc = _sde_connector_update_dimming_bl_lut(c_conn, c_state);
  1470. break;
  1471. case CONNECTOR_PROP_DIMMING_CTRL:
  1472. rc = _sde_connector_update_dimming_ctrl(c_conn, c_state, val);
  1473. break;
  1474. case CONNECTOR_PROP_DIMMING_MIN_BL:
  1475. rc = _sde_connector_update_dimming_min_bl(c_conn, c_state, val);
  1476. break;
  1477. case CONNECTOR_PROP_HDR_METADATA:
  1478. rc = _sde_connector_set_ext_hdr_info(c_conn,
  1479. c_state, (void *)(uintptr_t)val);
  1480. if (rc)
  1481. SDE_ERROR_CONN(c_conn, "cannot set hdr info %d\n", rc);
  1482. break;
  1483. case CONNECTOR_PROP_QSYNC_MODE:
  1484. msm_property_set_dirty(&c_conn->property_info,
  1485. &c_state->property_state, idx);
  1486. break;
  1487. case CONNECTOR_PROP_SET_PANEL_MODE:
  1488. if (val == DRM_MODE_FLAG_VID_MODE_PANEL)
  1489. c_conn->expected_panel_mode =
  1490. MSM_DISPLAY_VIDEO_MODE;
  1491. else if (val == DRM_MODE_FLAG_CMD_MODE_PANEL)
  1492. c_conn->expected_panel_mode =
  1493. MSM_DISPLAY_CMD_MODE;
  1494. break;
  1495. case CONNECTOR_PROP_DYN_BIT_CLK:
  1496. if (!c_conn->ops.set_dyn_bit_clk)
  1497. break;
  1498. rc = c_conn->ops.set_dyn_bit_clk(connector, val);
  1499. if (rc)
  1500. SDE_ERROR_CONN(c_conn, "dynamic bit clock set failed, rc: %d", rc);
  1501. break;
  1502. default:
  1503. break;
  1504. }
  1505. /* check for custom property handling */
  1506. if (!rc && c_conn->ops.set_property) {
  1507. rc = c_conn->ops.set_property(connector,
  1508. state,
  1509. idx,
  1510. val,
  1511. c_conn->display);
  1512. /* potentially clean up out_fb if rc != 0 */
  1513. if ((idx == CONNECTOR_PROP_OUT_FB) && rc)
  1514. _sde_connector_destroy_fb(c_conn, c_state);
  1515. }
  1516. end:
  1517. return rc;
  1518. }
  1519. static int sde_connector_atomic_get_property(struct drm_connector *connector,
  1520. const struct drm_connector_state *state,
  1521. struct drm_property *property,
  1522. uint64_t *val)
  1523. {
  1524. struct sde_connector *c_conn;
  1525. struct sde_connector_state *c_state;
  1526. int idx, rc = -EINVAL;
  1527. if (!connector || !state) {
  1528. SDE_ERROR("invalid argument(s), conn %pK, state %pK\n",
  1529. connector, state);
  1530. return -EINVAL;
  1531. }
  1532. c_conn = to_sde_connector(connector);
  1533. c_state = to_sde_connector_state(state);
  1534. idx = msm_property_index(&c_conn->property_info, property);
  1535. if (idx == CONNECTOR_PROP_RETIRE_FENCE) {
  1536. *val = ~0;
  1537. rc = 0;
  1538. } else {
  1539. /* get cached property value */
  1540. rc = msm_property_atomic_get(&c_conn->property_info,
  1541. &c_state->property_state, property, val);
  1542. }
  1543. /* allow for custom override */
  1544. if (c_conn->ops.get_property)
  1545. rc = c_conn->ops.get_property(connector,
  1546. (struct drm_connector_state *)state,
  1547. idx,
  1548. val,
  1549. c_conn->display);
  1550. return rc;
  1551. }
  1552. void sde_conn_timeline_status(struct drm_connector *conn)
  1553. {
  1554. struct sde_connector *c_conn;
  1555. if (!conn) {
  1556. SDE_ERROR("invalid connector\n");
  1557. return;
  1558. }
  1559. c_conn = to_sde_connector(conn);
  1560. sde_fence_timeline_status(c_conn->retire_fence, &conn->base);
  1561. }
  1562. void sde_connector_prepare_fence(struct drm_connector *connector)
  1563. {
  1564. if (!connector) {
  1565. SDE_ERROR("invalid connector\n");
  1566. return;
  1567. }
  1568. sde_fence_prepare(to_sde_connector(connector)->retire_fence);
  1569. }
  1570. void sde_connector_complete_commit(struct drm_connector *connector,
  1571. ktime_t ts, enum sde_fence_event fence_event)
  1572. {
  1573. if (!connector) {
  1574. SDE_ERROR("invalid connector\n");
  1575. return;
  1576. }
  1577. /* signal connector's retire fence */
  1578. sde_fence_signal(to_sde_connector(connector)->retire_fence,
  1579. ts, fence_event);
  1580. }
  1581. void sde_connector_commit_reset(struct drm_connector *connector, ktime_t ts)
  1582. {
  1583. if (!connector) {
  1584. SDE_ERROR("invalid connector\n");
  1585. return;
  1586. }
  1587. /* signal connector's retire fence */
  1588. sde_fence_signal(to_sde_connector(connector)->retire_fence,
  1589. ts, SDE_FENCE_RESET_TIMELINE);
  1590. }
  1591. static void sde_connector_update_hdr_props(struct drm_connector *connector)
  1592. {
  1593. struct sde_connector *c_conn = to_sde_connector(connector);
  1594. struct drm_msm_ext_hdr_properties hdr = {0};
  1595. hdr.hdr_metadata_type_one = c_conn->hdr_metadata_type_one ? 1 : 0;
  1596. hdr.hdr_supported = c_conn->hdr_supported ? 1 : 0;
  1597. hdr.hdr_eotf = c_conn->hdr_eotf;
  1598. hdr.hdr_max_luminance = c_conn->hdr_max_luminance;
  1599. hdr.hdr_avg_luminance = c_conn->hdr_avg_luminance;
  1600. hdr.hdr_min_luminance = c_conn->hdr_min_luminance;
  1601. hdr.hdr_plus_supported = c_conn->hdr_plus_app_ver;
  1602. msm_property_set_blob(&c_conn->property_info, &c_conn->blob_ext_hdr,
  1603. &hdr, sizeof(hdr), CONNECTOR_PROP_EXT_HDR_INFO);
  1604. }
  1605. static void sde_connector_update_colorspace(struct drm_connector *connector)
  1606. {
  1607. int ret;
  1608. struct sde_connector *c_conn = to_sde_connector(connector);
  1609. ret = msm_property_set_property(
  1610. sde_connector_get_propinfo(connector),
  1611. sde_connector_get_property_state(connector->state),
  1612. CONNECTOR_PROP_SUPPORTED_COLORSPACES,
  1613. c_conn->color_enc_fmt);
  1614. if (ret)
  1615. SDE_ERROR("failed to set colorspace property for connector\n");
  1616. }
  1617. static int
  1618. sde_connector_detect_ctx(struct drm_connector *connector,
  1619. struct drm_modeset_acquire_ctx *ctx,
  1620. bool force)
  1621. {
  1622. enum drm_connector_status status = connector_status_unknown;
  1623. struct sde_connector *c_conn;
  1624. if (!connector) {
  1625. SDE_ERROR("invalid connector\n");
  1626. return status;
  1627. }
  1628. c_conn = to_sde_connector(connector);
  1629. if (c_conn->ops.detect_ctx)
  1630. status = c_conn->ops.detect_ctx(connector, ctx, force, c_conn->display);
  1631. else if (c_conn->ops.detect)
  1632. status = c_conn->ops.detect(connector, force, c_conn->display);
  1633. SDE_DEBUG("connector id: %d, connection status: %d\n", connector->base.id, status);
  1634. return (int)status;
  1635. }
  1636. int sde_connector_get_dpms(struct drm_connector *connector)
  1637. {
  1638. struct sde_connector *c_conn;
  1639. int rc;
  1640. if (!connector) {
  1641. SDE_DEBUG("invalid connector\n");
  1642. return DRM_MODE_DPMS_OFF;
  1643. }
  1644. c_conn = to_sde_connector(connector);
  1645. mutex_lock(&c_conn->lock);
  1646. rc = c_conn->dpms_mode;
  1647. mutex_unlock(&c_conn->lock);
  1648. return rc;
  1649. }
  1650. int sde_connector_set_property_for_commit(struct drm_connector *connector,
  1651. struct drm_atomic_state *atomic_state,
  1652. uint32_t property_idx, uint64_t value)
  1653. {
  1654. struct drm_connector_state *state;
  1655. struct drm_property *property;
  1656. struct sde_connector *c_conn;
  1657. if (!connector || !atomic_state) {
  1658. SDE_ERROR("invalid argument(s), conn %d, state %d\n",
  1659. connector != NULL, atomic_state != NULL);
  1660. return -EINVAL;
  1661. }
  1662. c_conn = to_sde_connector(connector);
  1663. property = msm_property_index_to_drm_property(
  1664. &c_conn->property_info, property_idx);
  1665. if (!property) {
  1666. SDE_ERROR("invalid property index %d\n", property_idx);
  1667. return -EINVAL;
  1668. }
  1669. state = drm_atomic_get_connector_state(atomic_state, connector);
  1670. if (IS_ERR_OR_NULL(state)) {
  1671. SDE_ERROR("failed to get conn %d state\n",
  1672. connector->base.id);
  1673. return -EINVAL;
  1674. }
  1675. return sde_connector_atomic_set_property(
  1676. connector, state, property, value);
  1677. }
  1678. int sde_connector_helper_reset_custom_properties(
  1679. struct drm_connector *connector,
  1680. struct drm_connector_state *connector_state)
  1681. {
  1682. struct sde_connector *c_conn;
  1683. struct sde_connector_state *c_state;
  1684. struct drm_property *drm_prop;
  1685. enum msm_mdp_conn_property prop_idx;
  1686. if (!connector || !connector_state) {
  1687. SDE_ERROR("invalid params\n");
  1688. return -EINVAL;
  1689. }
  1690. c_conn = to_sde_connector(connector);
  1691. c_state = to_sde_connector_state(connector_state);
  1692. for (prop_idx = 0; prop_idx < CONNECTOR_PROP_COUNT; prop_idx++) {
  1693. uint64_t val = c_state->property_values[prop_idx].value;
  1694. uint64_t def;
  1695. int ret;
  1696. drm_prop = msm_property_index_to_drm_property(
  1697. &c_conn->property_info, prop_idx);
  1698. if (!drm_prop) {
  1699. /* not all props will be installed, based on caps */
  1700. SDE_DEBUG_CONN(c_conn, "invalid property index %d\n",
  1701. prop_idx);
  1702. continue;
  1703. }
  1704. def = msm_property_get_default(&c_conn->property_info,
  1705. prop_idx);
  1706. if (val == def)
  1707. continue;
  1708. SDE_DEBUG_CONN(c_conn, "set prop %s idx %d from %llu to %llu\n",
  1709. drm_prop->name, prop_idx, val, def);
  1710. ret = sde_connector_atomic_set_property(connector,
  1711. connector_state, drm_prop, def);
  1712. if (ret) {
  1713. SDE_ERROR_CONN(c_conn,
  1714. "set property failed, idx %d ret %d\n",
  1715. prop_idx, ret);
  1716. continue;
  1717. }
  1718. }
  1719. return 0;
  1720. }
  1721. static int _sde_connector_lm_preference(struct sde_connector *sde_conn,
  1722. struct sde_kms *sde_kms, uint32_t disp_type)
  1723. {
  1724. int ret = 0;
  1725. u32 num_lm = 0;
  1726. if (!sde_conn || !sde_kms || !sde_conn->ops.get_default_lms) {
  1727. SDE_DEBUG("invalid input params");
  1728. return -EINVAL;
  1729. }
  1730. if (!disp_type || disp_type >= SDE_CONNECTOR_MAX) {
  1731. SDE_DEBUG("invalid display_type");
  1732. return -EINVAL;
  1733. }
  1734. ret = sde_conn->ops.get_default_lms(sde_conn->display, &num_lm);
  1735. if (ret || !num_lm) {
  1736. SDE_DEBUG("failed to get default lm count");
  1737. return ret;
  1738. }
  1739. if (num_lm > sde_kms->catalog->mixer_count) {
  1740. SDE_DEBUG(
  1741. "topology requesting more lms [%d] than hw exists [%d]",
  1742. num_lm, sde_kms->catalog->mixer_count);
  1743. return -EINVAL;
  1744. }
  1745. sde_hw_mixer_set_preference(sde_kms->catalog, num_lm, disp_type);
  1746. return ret;
  1747. }
  1748. int sde_connector_get_panel_vfp(struct drm_connector *connector,
  1749. struct drm_display_mode *mode)
  1750. {
  1751. struct sde_connector *c_conn;
  1752. int vfp = -EINVAL;
  1753. if (!connector || !mode) {
  1754. SDE_ERROR("invalid connector\n");
  1755. return vfp;
  1756. }
  1757. c_conn = to_sde_connector(connector);
  1758. if (!c_conn->ops.get_panel_vfp)
  1759. return vfp;
  1760. vfp = c_conn->ops.get_panel_vfp(c_conn->display,
  1761. mode->hdisplay, mode->vdisplay);
  1762. if (vfp <= 0)
  1763. SDE_ERROR("Failed get_panel_vfp %d\n", vfp);
  1764. return vfp;
  1765. }
  1766. static int _sde_debugfs_conn_cmd_tx_open(struct inode *inode, struct file *file)
  1767. {
  1768. /* non-seekable */
  1769. file->private_data = inode->i_private;
  1770. return nonseekable_open(inode, file);
  1771. }
  1772. static ssize_t _sde_debugfs_conn_cmd_tx_sts_read(struct file *file,
  1773. char __user *buf, size_t count, loff_t *ppos)
  1774. {
  1775. struct drm_connector *connector = file->private_data;
  1776. struct sde_connector *c_conn = NULL;
  1777. char buffer[MAX_CMD_PAYLOAD_SIZE] = {0};
  1778. int blen = 0;
  1779. if (*ppos)
  1780. return 0;
  1781. if (!connector) {
  1782. SDE_ERROR("invalid argument, conn is NULL\n");
  1783. return -EINVAL;
  1784. }
  1785. c_conn = to_sde_connector(connector);
  1786. mutex_lock(&c_conn->lock);
  1787. blen = snprintf(buffer, MAX_CMD_PAYLOAD_SIZE,
  1788. "last_cmd_tx_sts:0x%x",
  1789. c_conn->last_cmd_tx_sts);
  1790. mutex_unlock(&c_conn->lock);
  1791. SDE_DEBUG("output: %s\n", buffer);
  1792. if (blen <= 0) {
  1793. SDE_ERROR("snprintf failed, blen %d\n", blen);
  1794. return -EINVAL;
  1795. }
  1796. if (blen > count)
  1797. blen = count;
  1798. blen = min_t(size_t, blen, MAX_CMD_PAYLOAD_SIZE);
  1799. if (copy_to_user(buf, buffer, blen)) {
  1800. SDE_ERROR("copy to user buffer failed\n");
  1801. return -EFAULT;
  1802. }
  1803. *ppos += blen;
  1804. return blen;
  1805. }
  1806. static ssize_t _sde_debugfs_conn_cmd_tx_write(struct file *file,
  1807. const char __user *p, size_t count, loff_t *ppos)
  1808. {
  1809. struct drm_connector *connector = file->private_data;
  1810. struct sde_connector *c_conn = NULL;
  1811. struct sde_kms *sde_kms;
  1812. char *input, *token, *input_copy, *input_dup = NULL;
  1813. const char *delim = " ";
  1814. char buffer[MAX_CMD_PAYLOAD_SIZE] = {0};
  1815. int rc = 0, strtoint = 0;
  1816. u32 buf_size = 0;
  1817. if (*ppos || !connector) {
  1818. SDE_ERROR("invalid argument(s), conn %d\n", connector != NULL);
  1819. return -EINVAL;
  1820. }
  1821. c_conn = to_sde_connector(connector);
  1822. sde_kms = _sde_connector_get_kms(&c_conn->base);
  1823. if (!sde_kms) {
  1824. SDE_ERROR("invalid kms\n");
  1825. return -EINVAL;
  1826. }
  1827. if (!c_conn->ops.cmd_transfer) {
  1828. SDE_ERROR("no cmd transfer support for connector name %s\n",
  1829. c_conn->name);
  1830. return -EINVAL;
  1831. }
  1832. input = kzalloc(count + 1, GFP_KERNEL);
  1833. if (!input)
  1834. return -ENOMEM;
  1835. sde_vm_lock(sde_kms);
  1836. if (!sde_vm_owns_hw(sde_kms)) {
  1837. SDE_DEBUG("op not supported due to HW unavailablity\n");
  1838. rc = -EOPNOTSUPP;
  1839. goto end;
  1840. }
  1841. if (copy_from_user(input, p, count)) {
  1842. SDE_ERROR("copy from user failed\n");
  1843. rc = -EFAULT;
  1844. goto end;
  1845. }
  1846. input[count] = '\0';
  1847. SDE_INFO("Command requested for transfer to panel: %s\n", input);
  1848. input_copy = kstrdup(input, GFP_KERNEL);
  1849. if (!input_copy) {
  1850. rc = -ENOMEM;
  1851. goto end;
  1852. }
  1853. input_dup = input_copy;
  1854. token = strsep(&input_copy, delim);
  1855. while (token) {
  1856. rc = kstrtoint(token, 0, &strtoint);
  1857. if (rc) {
  1858. SDE_ERROR("input buffer conversion failed\n");
  1859. goto end1;
  1860. }
  1861. buffer[buf_size++] = (strtoint & 0xff);
  1862. if (buf_size >= MAX_CMD_PAYLOAD_SIZE) {
  1863. SDE_ERROR("buffer size exceeding the limit %d\n",
  1864. MAX_CMD_PAYLOAD_SIZE);
  1865. rc = -EFAULT;
  1866. goto end1;
  1867. }
  1868. token = strsep(&input_copy, delim);
  1869. }
  1870. SDE_DEBUG("command packet size in bytes: %u\n", buf_size);
  1871. if (!buf_size) {
  1872. rc = -EFAULT;
  1873. goto end1;
  1874. }
  1875. mutex_lock(&c_conn->lock);
  1876. rc = c_conn->ops.cmd_transfer(&c_conn->base, c_conn->display, buffer,
  1877. buf_size);
  1878. c_conn->last_cmd_tx_sts = !rc ? true : false;
  1879. mutex_unlock(&c_conn->lock);
  1880. rc = count;
  1881. end1:
  1882. kfree(input_dup);
  1883. end:
  1884. sde_vm_unlock(sde_kms);
  1885. kfree(input);
  1886. return rc;
  1887. }
  1888. static const struct file_operations conn_cmd_tx_fops = {
  1889. .open = _sde_debugfs_conn_cmd_tx_open,
  1890. .read = _sde_debugfs_conn_cmd_tx_sts_read,
  1891. .write = _sde_debugfs_conn_cmd_tx_write,
  1892. };
  1893. static int _sde_debugfs_conn_cmd_rx_open(struct inode *inode, struct file *file)
  1894. {
  1895. /* non-seekable */
  1896. file->private_data = inode->i_private;
  1897. return nonseekable_open(inode, file);
  1898. }
  1899. static ssize_t _sde_debugfs_conn_cmd_rx_read(struct file *file,
  1900. char __user *buf, size_t count, loff_t *ppos)
  1901. {
  1902. struct drm_connector *connector = file->private_data;
  1903. struct sde_connector *c_conn = NULL;
  1904. char *strs = NULL;
  1905. char *strs_temp = NULL;
  1906. int blen = 0, i = 0, n = 0, left_size = 0;
  1907. if (*ppos)
  1908. return 0;
  1909. if (!connector) {
  1910. SDE_ERROR("invalid argument, conn is NULL\n");
  1911. return -EINVAL;
  1912. }
  1913. c_conn = to_sde_connector(connector);
  1914. if (c_conn->rx_len <= 0 || c_conn->rx_len > MAX_CMD_RECEIVE_SIZE) {
  1915. SDE_ERROR("no valid data from panel\n");
  1916. return -EINVAL;
  1917. }
  1918. /*
  1919. * Rx data was stored as HEX value in rx buffer,
  1920. * convert 1 HEX value to strings for display, need 5 bytes.
  1921. * for example: HEX value 0xFF, converted to strings, should be '0',
  1922. * 'x','F','F' and 1 space.
  1923. */
  1924. left_size = c_conn->rx_len * 5 + 1;
  1925. strs = kzalloc(left_size, GFP_KERNEL);
  1926. if (!strs)
  1927. return -ENOMEM;
  1928. strs_temp = strs;
  1929. mutex_lock(&c_conn->lock);
  1930. for (i = 0; i < c_conn->rx_len; i++) {
  1931. n = scnprintf(strs_temp, left_size, "0x%.2x ",
  1932. c_conn->cmd_rx_buf[i]);
  1933. strs_temp += n;
  1934. left_size -= n;
  1935. }
  1936. mutex_unlock(&c_conn->lock);
  1937. blen = strlen(strs);
  1938. if (blen <= 0) {
  1939. SDE_ERROR("snprintf failed, blen %d\n", blen);
  1940. blen = -EFAULT;
  1941. goto err;
  1942. }
  1943. if (copy_to_user(buf, strs, blen)) {
  1944. SDE_ERROR("copy to user buffer failed\n");
  1945. blen = -EFAULT;
  1946. goto err;
  1947. }
  1948. *ppos += blen;
  1949. err:
  1950. kfree(strs);
  1951. return blen;
  1952. }
  1953. static ssize_t _sde_debugfs_conn_cmd_rx_write(struct file *file,
  1954. const char __user *p, size_t count, loff_t *ppos)
  1955. {
  1956. struct drm_connector *connector = file->private_data;
  1957. struct sde_connector *c_conn = NULL;
  1958. char *input, *token, *input_copy, *input_dup = NULL;
  1959. const char *delim = " ";
  1960. unsigned char buffer[MAX_CMD_PAYLOAD_SIZE] = {0};
  1961. int rc = 0, strtoint = 0;
  1962. u32 buf_size = 0;
  1963. if (*ppos || !connector) {
  1964. SDE_ERROR("invalid argument(s), conn %d\n", connector != NULL);
  1965. return -EINVAL;
  1966. }
  1967. c_conn = to_sde_connector(connector);
  1968. if (!c_conn->ops.cmd_receive) {
  1969. SDE_ERROR("no cmd receive support for connector name %s\n",
  1970. c_conn->name);
  1971. return -EINVAL;
  1972. }
  1973. memset(c_conn->cmd_rx_buf, 0x0, MAX_CMD_RECEIVE_SIZE);
  1974. c_conn->rx_len = 0;
  1975. input = kzalloc(count + 1, GFP_KERNEL);
  1976. if (!input)
  1977. return -ENOMEM;
  1978. if (copy_from_user(input, p, count)) {
  1979. SDE_ERROR("copy from user failed\n");
  1980. rc = -EFAULT;
  1981. goto end;
  1982. }
  1983. input[count] = '\0';
  1984. SDE_INFO("Command requested for rx from panel: %s\n", input);
  1985. input_copy = kstrdup(input, GFP_KERNEL);
  1986. if (!input_copy) {
  1987. rc = -ENOMEM;
  1988. goto end;
  1989. }
  1990. input_dup = input_copy;
  1991. token = strsep(&input_copy, delim);
  1992. while (token) {
  1993. rc = kstrtoint(token, 0, &strtoint);
  1994. if (rc) {
  1995. SDE_ERROR("input buffer conversion failed\n");
  1996. goto end1;
  1997. }
  1998. buffer[buf_size++] = (strtoint & 0xff);
  1999. if (buf_size >= MAX_CMD_PAYLOAD_SIZE) {
  2000. SDE_ERROR("buffer size = %d exceeding the limit %d\n",
  2001. buf_size, MAX_CMD_PAYLOAD_SIZE);
  2002. rc = -EFAULT;
  2003. goto end1;
  2004. }
  2005. token = strsep(&input_copy, delim);
  2006. }
  2007. if (!buffer[0] || buffer[0] > MAX_CMD_RECEIVE_SIZE) {
  2008. SDE_ERROR("invalid rx length\n");
  2009. rc = -EFAULT;
  2010. goto end1;
  2011. }
  2012. SDE_DEBUG("command packet size in bytes: %u, rx len: %u\n",
  2013. buf_size, buffer[0]);
  2014. if (!buf_size) {
  2015. rc = -EFAULT;
  2016. goto end1;
  2017. }
  2018. mutex_lock(&c_conn->lock);
  2019. c_conn->rx_len = c_conn->ops.cmd_receive(c_conn->display, buffer + 1,
  2020. buf_size - 1, c_conn->cmd_rx_buf, buffer[0]);
  2021. mutex_unlock(&c_conn->lock);
  2022. if (c_conn->rx_len <= 0)
  2023. rc = -EINVAL;
  2024. else
  2025. rc = count;
  2026. end1:
  2027. kfree(input_dup);
  2028. end:
  2029. kfree(input);
  2030. return rc;
  2031. }
  2032. static const struct file_operations conn_cmd_rx_fops = {
  2033. .open = _sde_debugfs_conn_cmd_rx_open,
  2034. .read = _sde_debugfs_conn_cmd_rx_read,
  2035. .write = _sde_debugfs_conn_cmd_rx_write,
  2036. };
  2037. #ifdef CONFIG_DEBUG_FS
  2038. /**
  2039. * sde_connector_init_debugfs - initialize connector debugfs
  2040. * @connector: Pointer to drm connector
  2041. */
  2042. static int sde_connector_init_debugfs(struct drm_connector *connector)
  2043. {
  2044. struct sde_connector *sde_connector;
  2045. struct msm_display_info info;
  2046. if (!connector || !connector->debugfs_entry) {
  2047. SDE_ERROR("invalid connector\n");
  2048. return -EINVAL;
  2049. }
  2050. sde_connector = to_sde_connector(connector);
  2051. sde_connector_get_info(connector, &info);
  2052. if (sde_connector->ops.check_status &&
  2053. (info.capabilities & MSM_DISPLAY_ESD_ENABLED)) {
  2054. debugfs_create_u32("esd_status_interval", 0600,
  2055. connector->debugfs_entry,
  2056. &sde_connector->esd_status_interval);
  2057. }
  2058. if (sde_connector->ops.cmd_transfer) {
  2059. if (!debugfs_create_file("tx_cmd", 0600,
  2060. connector->debugfs_entry,
  2061. connector, &conn_cmd_tx_fops)) {
  2062. SDE_ERROR("failed to create connector cmd_tx\n");
  2063. return -ENOMEM;
  2064. }
  2065. }
  2066. if (sde_connector->ops.cmd_receive) {
  2067. if (!debugfs_create_file("rx_cmd", 0600,
  2068. connector->debugfs_entry,
  2069. connector, &conn_cmd_rx_fops)) {
  2070. SDE_ERROR("failed to create connector cmd_rx\n");
  2071. return -ENOMEM;
  2072. }
  2073. }
  2074. return 0;
  2075. }
  2076. #else
  2077. static int sde_connector_init_debugfs(struct drm_connector *connector)
  2078. {
  2079. return 0;
  2080. }
  2081. #endif
  2082. static int sde_connector_late_register(struct drm_connector *connector)
  2083. {
  2084. return sde_connector_init_debugfs(connector);
  2085. }
  2086. static void sde_connector_early_unregister(struct drm_connector *connector)
  2087. {
  2088. /* debugfs under connector->debugfs are deleted by drm_debugfs */
  2089. }
  2090. static int sde_connector_fill_modes(struct drm_connector *connector,
  2091. uint32_t max_width, uint32_t max_height)
  2092. {
  2093. int rc, mode_count = 0;
  2094. struct sde_connector *sde_conn = NULL;
  2095. sde_conn = to_sde_connector(connector);
  2096. if (!sde_conn) {
  2097. SDE_ERROR("invalid arguments\n");
  2098. return 0;
  2099. }
  2100. mode_count = drm_helper_probe_single_connector_modes(connector,
  2101. max_width, max_height);
  2102. if (sde_conn->ops.set_allowed_mode_switch)
  2103. sde_conn->ops.set_allowed_mode_switch(connector,
  2104. sde_conn->display);
  2105. rc = sde_connector_set_blob_data(connector,
  2106. connector->state,
  2107. CONNECTOR_PROP_MODE_INFO);
  2108. if (rc) {
  2109. SDE_ERROR_CONN(sde_conn,
  2110. "failed to setup mode info prop, rc = %d\n", rc);
  2111. return 0;
  2112. }
  2113. return mode_count;
  2114. }
  2115. static const struct drm_connector_funcs sde_connector_ops = {
  2116. .reset = sde_connector_atomic_reset,
  2117. .destroy = sde_connector_destroy,
  2118. .fill_modes = sde_connector_fill_modes,
  2119. .atomic_duplicate_state = sde_connector_atomic_duplicate_state,
  2120. .atomic_destroy_state = sde_connector_atomic_destroy_state,
  2121. .atomic_set_property = sde_connector_atomic_set_property,
  2122. .atomic_get_property = sde_connector_atomic_get_property,
  2123. .late_register = sde_connector_late_register,
  2124. .early_unregister = sde_connector_early_unregister,
  2125. };
  2126. static int sde_connector_get_modes(struct drm_connector *connector)
  2127. {
  2128. struct sde_connector *c_conn;
  2129. struct msm_resource_caps_info avail_res;
  2130. int mode_count = 0;
  2131. if (!connector) {
  2132. SDE_ERROR("invalid connector\n");
  2133. return 0;
  2134. }
  2135. c_conn = to_sde_connector(connector);
  2136. if (!c_conn->ops.get_modes) {
  2137. SDE_DEBUG("missing get_modes callback\n");
  2138. return 0;
  2139. }
  2140. memset(&avail_res, 0, sizeof(avail_res));
  2141. sde_connector_get_avail_res_info(connector, &avail_res);
  2142. mode_count = c_conn->ops.get_modes(connector, c_conn->display,
  2143. &avail_res);
  2144. if (!mode_count) {
  2145. SDE_ERROR_CONN(c_conn, "failed to get modes\n");
  2146. return 0;
  2147. }
  2148. if (c_conn->hdr_capable)
  2149. sde_connector_update_hdr_props(connector);
  2150. if (c_conn->connector_type == DRM_MODE_CONNECTOR_DisplayPort)
  2151. sde_connector_update_colorspace(connector);
  2152. return mode_count;
  2153. }
  2154. static enum drm_mode_status
  2155. sde_connector_mode_valid(struct drm_connector *connector,
  2156. struct drm_display_mode *mode)
  2157. {
  2158. struct sde_connector *c_conn;
  2159. struct msm_resource_caps_info avail_res;
  2160. if (!connector || !mode) {
  2161. SDE_ERROR("invalid argument(s), conn %pK, mode %pK\n",
  2162. connector, mode);
  2163. return MODE_ERROR;
  2164. }
  2165. c_conn = to_sde_connector(connector);
  2166. memset(&avail_res, 0, sizeof(avail_res));
  2167. sde_connector_get_avail_res_info(connector, &avail_res);
  2168. if (c_conn->ops.mode_valid)
  2169. return c_conn->ops.mode_valid(connector, mode, c_conn->display,
  2170. &avail_res);
  2171. /* assume all modes okay by default */
  2172. return MODE_OK;
  2173. }
  2174. static struct drm_encoder *
  2175. sde_connector_best_encoder(struct drm_connector *connector)
  2176. {
  2177. struct sde_connector *c_conn = to_sde_connector(connector);
  2178. if (!connector) {
  2179. SDE_ERROR("invalid connector\n");
  2180. return NULL;
  2181. }
  2182. /*
  2183. * This is true for now, revisit this code when multiple encoders are
  2184. * supported.
  2185. */
  2186. return c_conn->encoder;
  2187. }
  2188. static struct drm_encoder *
  2189. sde_connector_atomic_best_encoder(struct drm_connector *connector,
  2190. struct drm_connector_state *connector_state)
  2191. {
  2192. struct sde_connector *c_conn;
  2193. struct drm_encoder *encoder = NULL;
  2194. if (!connector) {
  2195. SDE_ERROR("invalid connector\n");
  2196. return NULL;
  2197. }
  2198. c_conn = to_sde_connector(connector);
  2199. if (c_conn->ops.atomic_best_encoder)
  2200. encoder = c_conn->ops.atomic_best_encoder(connector,
  2201. c_conn->display, connector_state);
  2202. return encoder;
  2203. }
  2204. static int sde_connector_atomic_check(struct drm_connector *connector,
  2205. struct drm_atomic_state *state)
  2206. {
  2207. struct sde_connector *c_conn;
  2208. if (!connector) {
  2209. SDE_ERROR("invalid connector\n");
  2210. return -EINVAL;
  2211. }
  2212. c_conn = to_sde_connector(connector);
  2213. if (c_conn->ops.atomic_check)
  2214. return c_conn->ops.atomic_check(connector,
  2215. c_conn->display, state);
  2216. return 0;
  2217. }
  2218. static void _sde_connector_report_panel_dead(struct sde_connector *conn,
  2219. bool skip_pre_kickoff)
  2220. {
  2221. struct drm_event event;
  2222. if (!conn)
  2223. return;
  2224. /* Panel dead notification can come:
  2225. * 1) ESD thread
  2226. * 2) Commit thread (if TE stops coming)
  2227. * So such case, avoid failure notification twice.
  2228. */
  2229. if (conn->panel_dead)
  2230. return;
  2231. SDE_EVT32(SDE_EVTLOG_ERROR);
  2232. conn->panel_dead = true;
  2233. sde_encoder_display_failure_notification(conn->encoder,
  2234. skip_pre_kickoff);
  2235. event.type = DRM_EVENT_PANEL_DEAD;
  2236. event.length = sizeof(bool);
  2237. msm_mode_object_event_notify(&conn->base.base,
  2238. conn->base.dev, &event, (u8 *)&conn->panel_dead);
  2239. SDE_ERROR("esd check failed report PANEL_DEAD conn_id: %d enc_id: %d\n",
  2240. conn->base.base.id, conn->encoder->base.id);
  2241. }
  2242. const char *sde_conn_get_topology_name(struct drm_connector *conn,
  2243. struct msm_display_topology topology)
  2244. {
  2245. struct sde_kms *sde_kms;
  2246. int topology_idx = 0;
  2247. sde_kms = _sde_connector_get_kms(conn);
  2248. if (!sde_kms) {
  2249. SDE_ERROR("invalid kms\n");
  2250. return NULL;
  2251. }
  2252. topology_idx = (int)sde_rm_get_topology_name(&sde_kms->rm,
  2253. topology);
  2254. if (topology_idx >= SDE_RM_TOPOLOGY_MAX) {
  2255. SDE_ERROR("invalid topology\n");
  2256. return NULL;
  2257. }
  2258. return e_topology_name[topology_idx].name;
  2259. }
  2260. int sde_connector_esd_status(struct drm_connector *conn)
  2261. {
  2262. struct sde_connector *sde_conn = NULL;
  2263. struct dsi_display *display;
  2264. int ret = 0;
  2265. if (!conn)
  2266. return ret;
  2267. sde_conn = to_sde_connector(conn);
  2268. if (!sde_conn || !sde_conn->ops.check_status)
  2269. return ret;
  2270. display = sde_conn->display;
  2271. /* protect this call with ESD status check call */
  2272. mutex_lock(&sde_conn->lock);
  2273. if (atomic_read(&(display->panel->esd_recovery_pending))) {
  2274. SDE_ERROR("ESD recovery already pending\n");
  2275. mutex_unlock(&sde_conn->lock);
  2276. return -ETIMEDOUT;
  2277. }
  2278. ret = sde_conn->ops.check_status(&sde_conn->base,
  2279. sde_conn->display, true);
  2280. mutex_unlock(&sde_conn->lock);
  2281. if (ret <= 0) {
  2282. /* cancel if any pending esd work */
  2283. sde_connector_schedule_status_work(conn, false);
  2284. _sde_connector_report_panel_dead(sde_conn, true);
  2285. ret = -ETIMEDOUT;
  2286. } else {
  2287. SDE_DEBUG("Successfully received TE from panel\n");
  2288. ret = 0;
  2289. }
  2290. SDE_EVT32(ret);
  2291. return ret;
  2292. }
  2293. static void sde_connector_check_status_work(struct work_struct *work)
  2294. {
  2295. struct sde_connector *conn;
  2296. int rc = 0;
  2297. struct device *dev;
  2298. conn = container_of(to_delayed_work(work),
  2299. struct sde_connector, status_work);
  2300. if (!conn) {
  2301. SDE_ERROR("not able to get connector object\n");
  2302. return;
  2303. }
  2304. mutex_lock(&conn->lock);
  2305. dev = conn->base.dev->dev;
  2306. if (!conn->ops.check_status || dev->power.is_suspended ||
  2307. (conn->dpms_mode != DRM_MODE_DPMS_ON)) {
  2308. SDE_DEBUG("dpms mode: %d\n", conn->dpms_mode);
  2309. mutex_unlock(&conn->lock);
  2310. return;
  2311. }
  2312. rc = conn->ops.check_status(&conn->base, conn->display, false);
  2313. mutex_unlock(&conn->lock);
  2314. if (rc > 0) {
  2315. u32 interval;
  2316. SDE_DEBUG("esd check status success conn_id: %d enc_id: %d\n",
  2317. conn->base.base.id, conn->encoder->base.id);
  2318. /* If debugfs property is not set then take default value */
  2319. interval = conn->esd_status_interval ?
  2320. conn->esd_status_interval : STATUS_CHECK_INTERVAL_MS;
  2321. schedule_delayed_work(&conn->status_work,
  2322. msecs_to_jiffies(interval));
  2323. return;
  2324. }
  2325. _sde_connector_report_panel_dead(conn, false);
  2326. }
  2327. static const struct drm_connector_helper_funcs sde_connector_helper_ops = {
  2328. .get_modes = sde_connector_get_modes,
  2329. .detect_ctx = sde_connector_detect_ctx,
  2330. .mode_valid = sde_connector_mode_valid,
  2331. .best_encoder = sde_connector_best_encoder,
  2332. .atomic_check = sde_connector_atomic_check,
  2333. };
  2334. static const struct drm_connector_helper_funcs sde_connector_helper_ops_v2 = {
  2335. .get_modes = sde_connector_get_modes,
  2336. .detect_ctx = sde_connector_detect_ctx,
  2337. .mode_valid = sde_connector_mode_valid,
  2338. .best_encoder = sde_connector_best_encoder,
  2339. .atomic_best_encoder = sde_connector_atomic_best_encoder,
  2340. .atomic_check = sde_connector_atomic_check,
  2341. };
  2342. static int sde_connector_populate_mode_info(struct drm_connector *conn,
  2343. struct sde_kms_info *info)
  2344. {
  2345. struct sde_kms *sde_kms;
  2346. struct sde_connector *c_conn = NULL;
  2347. struct drm_display_mode *mode;
  2348. struct msm_mode_info mode_info;
  2349. const char *topo_name = NULL;
  2350. int rc = 0;
  2351. sde_kms = _sde_connector_get_kms(conn);
  2352. if (!sde_kms) {
  2353. SDE_ERROR("invalid kms\n");
  2354. return -EINVAL;
  2355. }
  2356. c_conn = to_sde_connector(conn);
  2357. if (!c_conn->ops.get_mode_info) {
  2358. SDE_ERROR_CONN(c_conn, "get_mode_info not defined\n");
  2359. return -EINVAL;
  2360. }
  2361. list_for_each_entry(mode, &conn->modes, head) {
  2362. memset(&mode_info, 0, sizeof(mode_info));
  2363. rc = sde_connector_get_mode_info(&c_conn->base, mode, NULL,
  2364. &mode_info);
  2365. if (rc) {
  2366. SDE_ERROR_CONN(c_conn,
  2367. "failed to get mode info for mode %s\n",
  2368. mode->name);
  2369. continue;
  2370. }
  2371. sde_kms_info_add_keystr(info, "mode_name", mode->name);
  2372. sde_kms_info_add_keyint(info, "bit_clk_rate",
  2373. mode_info.clk_rate);
  2374. if (c_conn->ops.set_submode_info) {
  2375. c_conn->ops.set_submode_info(conn, info, c_conn->display, mode);
  2376. } else {
  2377. topo_name = sde_conn_get_topology_name(conn, mode_info.topology);
  2378. if (topo_name)
  2379. sde_kms_info_add_keystr(info, "topology", topo_name);
  2380. }
  2381. sde_kms_info_add_keyint(info, "qsync_min_fps", mode_info.qsync_min_fps);
  2382. sde_kms_info_add_keyint(info, "has_cwb_crop", sde_kms->catalog->has_cwb_crop);
  2383. sde_kms_info_add_keyint(info, "has_dedicated_cwb_support",
  2384. sde_kms->catalog->has_dedicated_cwb_support);
  2385. sde_kms_info_add_keyint(info, "mdp_transfer_time_us",
  2386. mode_info.mdp_transfer_time_us);
  2387. sde_kms_info_add_keyint(info, "allowed_mode_switch",
  2388. mode_info.allowed_mode_switches);
  2389. if (!mode_info.roi_caps.num_roi)
  2390. continue;
  2391. sde_kms_info_add_keyint(info, "partial_update_num_roi",
  2392. mode_info.roi_caps.num_roi);
  2393. sde_kms_info_add_keyint(info, "partial_update_xstart",
  2394. mode_info.roi_caps.align.xstart_pix_align);
  2395. sde_kms_info_add_keyint(info, "partial_update_walign",
  2396. mode_info.roi_caps.align.width_pix_align);
  2397. sde_kms_info_add_keyint(info, "partial_update_wmin",
  2398. mode_info.roi_caps.align.min_width);
  2399. sde_kms_info_add_keyint(info, "partial_update_ystart",
  2400. mode_info.roi_caps.align.ystart_pix_align);
  2401. sde_kms_info_add_keyint(info, "partial_update_halign",
  2402. mode_info.roi_caps.align.height_pix_align);
  2403. sde_kms_info_add_keyint(info, "partial_update_hmin",
  2404. mode_info.roi_caps.align.min_height);
  2405. sde_kms_info_add_keyint(info, "partial_update_roimerge",
  2406. mode_info.roi_caps.merge_rois);
  2407. }
  2408. return rc;
  2409. }
  2410. int sde_connector_set_blob_data(struct drm_connector *conn,
  2411. struct drm_connector_state *state,
  2412. enum msm_mdp_conn_property prop_id)
  2413. {
  2414. struct sde_kms_info *info;
  2415. struct sde_connector *c_conn = NULL;
  2416. struct sde_connector_state *sde_conn_state = NULL;
  2417. struct msm_mode_info mode_info;
  2418. struct drm_property_blob **blob = NULL;
  2419. int rc = 0;
  2420. c_conn = to_sde_connector(conn);
  2421. if (!c_conn) {
  2422. SDE_ERROR("invalid argument\n");
  2423. return -EINVAL;
  2424. }
  2425. info = kzalloc(sizeof(*info), GFP_KERNEL);
  2426. if (!info)
  2427. return -ENOMEM;
  2428. sde_kms_info_reset(info);
  2429. switch (prop_id) {
  2430. case CONNECTOR_PROP_SDE_INFO:
  2431. memset(&mode_info, 0, sizeof(mode_info));
  2432. if (state) {
  2433. sde_conn_state = to_sde_connector_state(state);
  2434. memcpy(&mode_info, &sde_conn_state->mode_info,
  2435. sizeof(sde_conn_state->mode_info));
  2436. } else {
  2437. /**
  2438. * connector state is assigned only on first
  2439. * atomic_commit. But this function is allowed to be
  2440. * invoked during probe/init sequence. So not throwing
  2441. * an error.
  2442. */
  2443. SDE_DEBUG_CONN(c_conn, "invalid connector state\n");
  2444. }
  2445. if (c_conn->ops.set_info_blob) {
  2446. rc = c_conn->ops.set_info_blob(conn, info,
  2447. c_conn->display, &mode_info);
  2448. if (rc) {
  2449. SDE_ERROR_CONN(c_conn,
  2450. "set_info_blob failed, %d\n",
  2451. rc);
  2452. goto exit;
  2453. }
  2454. }
  2455. blob = &c_conn->blob_caps;
  2456. break;
  2457. case CONNECTOR_PROP_MODE_INFO:
  2458. rc = sde_connector_populate_mode_info(conn, info);
  2459. if (rc) {
  2460. SDE_ERROR_CONN(c_conn,
  2461. "mode info population failed, %d\n",
  2462. rc);
  2463. goto exit;
  2464. }
  2465. blob = &c_conn->blob_mode_info;
  2466. break;
  2467. default:
  2468. SDE_ERROR_CONN(c_conn, "invalid prop_id: %d\n", prop_id);
  2469. goto exit;
  2470. }
  2471. msm_property_set_blob(&c_conn->property_info,
  2472. blob,
  2473. SDE_KMS_INFO_DATA(info),
  2474. SDE_KMS_INFO_DATALEN(info),
  2475. prop_id);
  2476. exit:
  2477. kfree(info);
  2478. return rc;
  2479. }
  2480. static int _sde_connector_install_properties(struct drm_device *dev,
  2481. struct sde_kms *sde_kms, struct sde_connector *c_conn,
  2482. int connector_type, void *display,
  2483. struct msm_display_info *display_info)
  2484. {
  2485. struct dsi_display *dsi_display;
  2486. int rc;
  2487. struct drm_connector *connector;
  2488. u64 panel_id = ~0x0;
  2489. msm_property_install_blob(&c_conn->property_info, "capabilities",
  2490. DRM_MODE_PROP_IMMUTABLE, CONNECTOR_PROP_SDE_INFO);
  2491. rc = sde_connector_set_blob_data(&c_conn->base,
  2492. NULL, CONNECTOR_PROP_SDE_INFO);
  2493. if (rc) {
  2494. SDE_ERROR_CONN(c_conn,
  2495. "failed to setup connector info, rc = %d\n", rc);
  2496. return rc;
  2497. }
  2498. connector = &c_conn->base;
  2499. msm_property_install_blob(&c_conn->property_info, "mode_properties",
  2500. DRM_MODE_PROP_IMMUTABLE, CONNECTOR_PROP_MODE_INFO);
  2501. if (connector_type == DRM_MODE_CONNECTOR_DSI) {
  2502. dsi_display = (struct dsi_display *)(display);
  2503. if (dsi_display && dsi_display->panel) {
  2504. msm_property_install_blob(&c_conn->property_info,
  2505. "dimming_bl_lut", DRM_MODE_PROP_BLOB,
  2506. CONNECTOR_PROP_DIMMING_BL_LUT);
  2507. msm_property_install_range(&c_conn->property_info, "dimming_dyn_ctrl",
  2508. 0x0, 0, ~0, 0, CONNECTOR_PROP_DIMMING_CTRL);
  2509. msm_property_install_range(&c_conn->property_info, "dimming_min_bl",
  2510. 0x0, 0, dsi_display->panel->bl_config.brightness_max_level, 0,
  2511. CONNECTOR_PROP_DIMMING_MIN_BL);
  2512. }
  2513. if (dsi_display && dsi_display->panel &&
  2514. dsi_display->panel->hdr_props.hdr_enabled == true) {
  2515. msm_property_install_blob(&c_conn->property_info,
  2516. "hdr_properties",
  2517. DRM_MODE_PROP_IMMUTABLE,
  2518. CONNECTOR_PROP_HDR_INFO);
  2519. msm_property_set_blob(&c_conn->property_info,
  2520. &c_conn->blob_hdr,
  2521. &dsi_display->panel->hdr_props,
  2522. sizeof(dsi_display->panel->hdr_props),
  2523. CONNECTOR_PROP_HDR_INFO);
  2524. }
  2525. if (dsi_display && dsi_display->panel &&
  2526. dsi_display->panel->dyn_clk_caps.dyn_clk_support)
  2527. msm_property_install_range(&c_conn->property_info, "dyn_bit_clk",
  2528. 0x0, 0, ~0, 0, CONNECTOR_PROP_DYN_BIT_CLK);
  2529. mutex_lock(&c_conn->base.dev->mode_config.mutex);
  2530. sde_connector_fill_modes(&c_conn->base,
  2531. dev->mode_config.max_width,
  2532. dev->mode_config.max_height);
  2533. mutex_unlock(&c_conn->base.dev->mode_config.mutex);
  2534. }
  2535. msm_property_install_volatile_range(
  2536. &c_conn->property_info, "sde_drm_roi_v1", 0x0,
  2537. 0, ~0, 0, CONNECTOR_PROP_ROI_V1);
  2538. /* install PP_DITHER properties */
  2539. _sde_connector_install_dither_property(dev, sde_kms, c_conn);
  2540. if (connector_type == DRM_MODE_CONNECTOR_DisplayPort) {
  2541. struct drm_msm_ext_hdr_properties hdr = {0};
  2542. c_conn->hdr_capable = true;
  2543. msm_property_install_blob(&c_conn->property_info,
  2544. "ext_hdr_properties",
  2545. DRM_MODE_PROP_IMMUTABLE,
  2546. CONNECTOR_PROP_EXT_HDR_INFO);
  2547. /* set default values to avoid reading uninitialized data */
  2548. msm_property_set_blob(&c_conn->property_info,
  2549. &c_conn->blob_ext_hdr,
  2550. &hdr,
  2551. sizeof(hdr),
  2552. CONNECTOR_PROP_EXT_HDR_INFO);
  2553. if (c_conn->ops.install_properties)
  2554. c_conn->ops.install_properties(display, connector);
  2555. }
  2556. msm_property_install_volatile_range(&c_conn->property_info,
  2557. "hdr_metadata", 0x0, 0, ~0, 0, CONNECTOR_PROP_HDR_METADATA);
  2558. msm_property_install_volatile_range(&c_conn->property_info,
  2559. "RETIRE_FENCE", 0x0, 0, ~0, 0, CONNECTOR_PROP_RETIRE_FENCE);
  2560. msm_property_install_volatile_range(&c_conn->property_info,
  2561. "RETIRE_FENCE_OFFSET", 0x0, 0, ~0, 0,
  2562. CONN_PROP_RETIRE_FENCE_OFFSET);
  2563. msm_property_install_range(&c_conn->property_info, "autorefresh",
  2564. 0x0, 0, AUTOREFRESH_MAX_FRAME_CNT, 0,
  2565. CONNECTOR_PROP_AUTOREFRESH);
  2566. if (connector_type == DRM_MODE_CONNECTOR_DSI) {
  2567. if (sde_kms->catalog->has_qsync && dsi_display && dsi_display->panel &&
  2568. dsi_display->panel->qsync_caps.qsync_support) {
  2569. msm_property_install_enum(&c_conn->property_info,
  2570. "qsync_mode", 0, 0, e_qsync_mode,
  2571. ARRAY_SIZE(e_qsync_mode), 0,
  2572. CONNECTOR_PROP_QSYNC_MODE);
  2573. if (sde_kms->catalog->has_avr_step)
  2574. msm_property_install_range(&c_conn->property_info,
  2575. "avr_step", 0x0, 0, U32_MAX, 0,
  2576. CONNECTOR_PROP_AVR_STEP);
  2577. }
  2578. msm_property_install_enum(&c_conn->property_info, "dsc_mode", 0,
  2579. 0, e_dsc_mode, ARRAY_SIZE(e_dsc_mode), 0, CONNECTOR_PROP_DSC_MODE);
  2580. if (display_info->capabilities & MSM_DISPLAY_CAP_CMD_MODE)
  2581. msm_property_install_enum(&c_conn->property_info,
  2582. "frame_trigger_mode", 0, 0,
  2583. e_frame_trigger_mode,
  2584. ARRAY_SIZE(e_frame_trigger_mode), 0,
  2585. CONNECTOR_PROP_CMD_FRAME_TRIGGER_MODE);
  2586. if (display_info->capabilities & MSM_DISPLAY_CAP_CMD_MODE &&
  2587. display_info->capabilities & MSM_DISPLAY_CAP_VID_MODE)
  2588. msm_property_install_enum(&c_conn->property_info,
  2589. "panel_mode", 0, 0,
  2590. e_panel_mode,
  2591. ARRAY_SIZE(e_panel_mode), 0,
  2592. CONNECTOR_PROP_SET_PANEL_MODE);
  2593. if (sde_kms->catalog->has_demura) {
  2594. msm_property_install_blob(&c_conn->property_info,
  2595. "DEMURA_PANEL_ID", DRM_MODE_PROP_IMMUTABLE,
  2596. CONNECTOR_PROP_DEMURA_PANEL_ID);
  2597. msm_property_set_blob(&c_conn->property_info,
  2598. &c_conn->blob_panel_id,
  2599. &panel_id,
  2600. sizeof(panel_id),
  2601. CONNECTOR_PROP_DEMURA_PANEL_ID);
  2602. }
  2603. }
  2604. msm_property_install_range(&c_conn->property_info, "bl_scale",
  2605. 0x0, 0, MAX_BL_SCALE_LEVEL, MAX_BL_SCALE_LEVEL,
  2606. CONNECTOR_PROP_BL_SCALE);
  2607. msm_property_install_range(&c_conn->property_info, "sv_bl_scale",
  2608. 0x0, 0, U32_MAX, MAX_SV_BL_SCALE_LEVEL,
  2609. CONNECTOR_PROP_SV_BL_SCALE);
  2610. c_conn->bl_scale_dirty = false;
  2611. c_conn->bl_scale = MAX_BL_SCALE_LEVEL;
  2612. c_conn->bl_scale_sv = MAX_SV_BL_SCALE_LEVEL;
  2613. if (connector_type == DRM_MODE_CONNECTOR_DisplayPort)
  2614. msm_property_install_range(&c_conn->property_info,
  2615. "supported_colorspaces",
  2616. DRM_MODE_PROP_IMMUTABLE, 0, 0xffff, 0,
  2617. CONNECTOR_PROP_SUPPORTED_COLORSPACES);
  2618. /* enum/bitmask properties */
  2619. msm_property_install_enum(&c_conn->property_info, "topology_name",
  2620. DRM_MODE_PROP_IMMUTABLE, 0, e_topology_name,
  2621. ARRAY_SIZE(e_topology_name), 0,
  2622. CONNECTOR_PROP_TOPOLOGY_NAME);
  2623. msm_property_install_enum(&c_conn->property_info, "topology_control",
  2624. 0, 1, e_topology_control,
  2625. ARRAY_SIZE(e_topology_control), 0,
  2626. CONNECTOR_PROP_TOPOLOGY_CONTROL);
  2627. msm_property_install_enum(&c_conn->property_info, "LP",
  2628. 0, 0, e_power_mode,
  2629. ARRAY_SIZE(e_power_mode), 0,
  2630. CONNECTOR_PROP_LP);
  2631. return 0;
  2632. }
  2633. struct drm_connector *sde_connector_init(struct drm_device *dev,
  2634. struct drm_encoder *encoder,
  2635. struct drm_panel *panel,
  2636. void *display,
  2637. const struct sde_connector_ops *ops,
  2638. int connector_poll,
  2639. int connector_type)
  2640. {
  2641. struct msm_drm_private *priv;
  2642. struct sde_kms *sde_kms;
  2643. struct sde_connector *c_conn = NULL;
  2644. struct msm_display_info display_info;
  2645. int rc;
  2646. if (!dev || !dev->dev_private || !encoder) {
  2647. SDE_ERROR("invalid argument(s), dev %pK, enc %pK\n",
  2648. dev, encoder);
  2649. return ERR_PTR(-EINVAL);
  2650. }
  2651. priv = dev->dev_private;
  2652. if (!priv->kms) {
  2653. SDE_ERROR("invalid kms reference\n");
  2654. return ERR_PTR(-EINVAL);
  2655. }
  2656. c_conn = kzalloc(sizeof(*c_conn), GFP_KERNEL);
  2657. if (!c_conn) {
  2658. SDE_ERROR("failed to alloc sde connector\n");
  2659. return ERR_PTR(-ENOMEM);
  2660. }
  2661. memset(&display_info, 0, sizeof(display_info));
  2662. rc = drm_connector_init(dev,
  2663. &c_conn->base,
  2664. &sde_connector_ops,
  2665. connector_type);
  2666. if (rc)
  2667. goto error_free_conn;
  2668. spin_lock_init(&c_conn->event_lock);
  2669. c_conn->panel = panel;
  2670. c_conn->connector_type = connector_type;
  2671. c_conn->encoder = encoder;
  2672. c_conn->display = display;
  2673. c_conn->dpms_mode = DRM_MODE_DPMS_ON;
  2674. c_conn->lp_mode = 0;
  2675. c_conn->last_panel_power_mode = SDE_MODE_DPMS_ON;
  2676. sde_kms = to_sde_kms(priv->kms);
  2677. if (sde_kms->vbif[VBIF_NRT]) {
  2678. c_conn->aspace[SDE_IOMMU_DOMAIN_UNSECURE] =
  2679. sde_kms->aspace[MSM_SMMU_DOMAIN_NRT_UNSECURE];
  2680. c_conn->aspace[SDE_IOMMU_DOMAIN_SECURE] =
  2681. sde_kms->aspace[MSM_SMMU_DOMAIN_NRT_SECURE];
  2682. } else {
  2683. c_conn->aspace[SDE_IOMMU_DOMAIN_UNSECURE] =
  2684. sde_kms->aspace[MSM_SMMU_DOMAIN_UNSECURE];
  2685. c_conn->aspace[SDE_IOMMU_DOMAIN_SECURE] =
  2686. sde_kms->aspace[MSM_SMMU_DOMAIN_SECURE];
  2687. }
  2688. if (ops)
  2689. c_conn->ops = *ops;
  2690. if (ops && ops->atomic_best_encoder && ops->atomic_check)
  2691. c_conn->base.helper_private = &sde_connector_helper_ops_v2;
  2692. else
  2693. c_conn->base.helper_private = &sde_connector_helper_ops;
  2694. c_conn->base.polled = connector_poll;
  2695. c_conn->base.interlace_allowed = 0;
  2696. c_conn->base.doublescan_allowed = 0;
  2697. snprintf(c_conn->name,
  2698. SDE_CONNECTOR_NAME_SIZE,
  2699. "conn%u",
  2700. c_conn->base.base.id);
  2701. c_conn->retire_fence = sde_fence_init(c_conn->name,
  2702. c_conn->base.base.id);
  2703. if (IS_ERR(c_conn->retire_fence)) {
  2704. rc = PTR_ERR(c_conn->retire_fence);
  2705. SDE_ERROR("failed to init fence, %d\n", rc);
  2706. goto error_cleanup_conn;
  2707. }
  2708. mutex_init(&c_conn->lock);
  2709. rc = drm_connector_attach_encoder(&c_conn->base, encoder);
  2710. if (rc) {
  2711. SDE_ERROR("failed to attach encoder to connector, %d\n", rc);
  2712. goto error_cleanup_fence;
  2713. }
  2714. rc = sde_backlight_setup(c_conn, dev);
  2715. if (rc) {
  2716. SDE_ERROR("failed to setup backlight, rc=%d\n", rc);
  2717. goto error_cleanup_fence;
  2718. }
  2719. /* create properties */
  2720. msm_property_init(&c_conn->property_info, &c_conn->base.base, dev,
  2721. priv->conn_property, c_conn->property_data,
  2722. CONNECTOR_PROP_COUNT, CONNECTOR_PROP_BLOBCOUNT,
  2723. sizeof(struct sde_connector_state));
  2724. if (c_conn->ops.post_init) {
  2725. rc = c_conn->ops.post_init(&c_conn->base, display);
  2726. if (rc) {
  2727. SDE_ERROR("post-init failed, %d\n", rc);
  2728. goto error_cleanup_fence;
  2729. }
  2730. }
  2731. rc = sde_connector_get_info(&c_conn->base, &display_info);
  2732. if (!rc && (connector_type == DRM_MODE_CONNECTOR_DSI) &&
  2733. (display_info.capabilities & MSM_DISPLAY_CAP_VID_MODE))
  2734. sde_connector_register_event(&c_conn->base,
  2735. SDE_CONN_EVENT_VID_FIFO_OVERFLOW,
  2736. sde_connector_handle_disp_recovery,
  2737. c_conn);
  2738. rc = _sde_connector_install_properties(dev, sde_kms, c_conn,
  2739. connector_type, display, &display_info);
  2740. if (rc)
  2741. goto error_cleanup_fence;
  2742. if (connector_type == DRM_MODE_CONNECTOR_DSI &&
  2743. sde_kms->catalog->has_demura) {
  2744. rc = sde_connector_register_event(&c_conn->base,
  2745. SDE_CONN_EVENT_PANEL_ID,
  2746. sde_connector_handle_panel_id, c_conn);
  2747. if (rc)
  2748. SDE_ERROR("register panel id event err %d\n", rc);
  2749. }
  2750. rc = msm_property_install_get_status(&c_conn->property_info);
  2751. if (rc) {
  2752. SDE_ERROR("failed to create one or more properties\n");
  2753. goto error_destroy_property;
  2754. }
  2755. _sde_connector_lm_preference(c_conn, sde_kms,
  2756. display_info.display_type);
  2757. SDE_DEBUG("connector %d attach encoder %d\n",
  2758. c_conn->base.base.id, encoder->base.id);
  2759. INIT_DELAYED_WORK(&c_conn->status_work,
  2760. sde_connector_check_status_work);
  2761. return &c_conn->base;
  2762. error_destroy_property:
  2763. if (c_conn->blob_caps)
  2764. drm_property_blob_put(c_conn->blob_caps);
  2765. if (c_conn->blob_hdr)
  2766. drm_property_blob_put(c_conn->blob_hdr);
  2767. if (c_conn->blob_dither)
  2768. drm_property_blob_put(c_conn->blob_dither);
  2769. if (c_conn->blob_mode_info)
  2770. drm_property_blob_put(c_conn->blob_mode_info);
  2771. if (c_conn->blob_ext_hdr)
  2772. drm_property_blob_put(c_conn->blob_ext_hdr);
  2773. msm_property_destroy(&c_conn->property_info);
  2774. error_cleanup_fence:
  2775. mutex_destroy(&c_conn->lock);
  2776. sde_fence_deinit(c_conn->retire_fence);
  2777. error_cleanup_conn:
  2778. drm_connector_cleanup(&c_conn->base);
  2779. error_free_conn:
  2780. kfree(c_conn);
  2781. return ERR_PTR(rc);
  2782. }
  2783. static int _sde_conn_enable_hw_recovery(struct drm_connector *connector)
  2784. {
  2785. struct sde_connector *c_conn;
  2786. if (!connector) {
  2787. SDE_ERROR("invalid connector\n");
  2788. return -EINVAL;
  2789. }
  2790. c_conn = to_sde_connector(connector);
  2791. if (c_conn->encoder)
  2792. sde_encoder_enable_recovery_event(c_conn->encoder);
  2793. return 0;
  2794. }
  2795. int sde_connector_register_custom_event(struct sde_kms *kms,
  2796. struct drm_connector *conn_drm, u32 event, bool val)
  2797. {
  2798. int ret = -EINVAL;
  2799. struct sde_connector *c_conn;
  2800. switch (event) {
  2801. case DRM_EVENT_SYS_BACKLIGHT:
  2802. ret = 0;
  2803. break;
  2804. case DRM_EVENT_DIMMING_BL:
  2805. if (!conn_drm) {
  2806. SDE_ERROR("invalid connector\n");
  2807. return -EINVAL;
  2808. }
  2809. c_conn = to_sde_connector(conn_drm);
  2810. c_conn->dimming_bl_notify_enabled = val;
  2811. ret = 0;
  2812. break;
  2813. case DRM_EVENT_PANEL_DEAD:
  2814. ret = 0;
  2815. break;
  2816. case DRM_EVENT_SDE_HW_RECOVERY:
  2817. ret = _sde_conn_enable_hw_recovery(conn_drm);
  2818. break;
  2819. default:
  2820. break;
  2821. }
  2822. return ret;
  2823. }
  2824. int sde_connector_event_notify(struct drm_connector *connector, uint32_t type,
  2825. uint32_t len, uint32_t val)
  2826. {
  2827. struct drm_event event;
  2828. int ret;
  2829. if (!connector) {
  2830. SDE_ERROR("invalid connector\n");
  2831. return -EINVAL;
  2832. }
  2833. switch (type) {
  2834. case DRM_EVENT_SYS_BACKLIGHT:
  2835. case DRM_EVENT_DIMMING_BL:
  2836. case DRM_EVENT_PANEL_DEAD:
  2837. case DRM_EVENT_SDE_HW_RECOVERY:
  2838. ret = 0;
  2839. break;
  2840. default:
  2841. SDE_ERROR("connector %d, Unsupported event %d\n",
  2842. connector->base.id, type);
  2843. return -EINVAL;
  2844. }
  2845. event.type = type;
  2846. event.length = len;
  2847. msm_mode_object_event_notify(&connector->base, connector->dev, &event,
  2848. (u8 *)&val);
  2849. SDE_EVT32(connector->base.id, type, len, val);
  2850. SDE_DEBUG("connector:%d hw recovery event(%d) value (%d) notified\n",
  2851. connector->base.id, type, val);
  2852. return ret;
  2853. }