sde_connector.c 79 KB

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