sde_dbg.c 80 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
  4. * Copyright (c) 2009-2021, The Linux Foundation. All rights reserved.
  5. */
  6. #define pr_fmt(fmt) "[drm:%s:%d] " fmt, __func__, __LINE__
  7. #include <linux/delay.h>
  8. #include <linux/spinlock.h>
  9. #include <linux/ktime.h>
  10. #include <linux/debugfs.h>
  11. #include <linux/uaccess.h>
  12. #include <linux/dma-buf.h>
  13. #include <linux/slab.h>
  14. #include <linux/list_sort.h>
  15. #include <linux/pm.h>
  16. #include <linux/pm_runtime.h>
  17. #include <linux/devcoredump.h>
  18. #include "sde_dbg.h"
  19. #include "sde/sde_hw_catalog.h"
  20. #include "sde/sde_kms.h"
  21. #define SDE_DBG_BASE_MAX 10
  22. #define DEFAULT_PANIC 1
  23. #define DEFAULT_BASE_REG_CNT DEFAULT_MDSS_HW_BLOCK_SIZE
  24. #define GROUP_BYTES 4
  25. #define ROW_BYTES 16
  26. #define RANGE_NAME_LEN 40
  27. #define REG_BASE_NAME_LEN 80
  28. #define DBGBUS_NAME_SDE "sde"
  29. #define DBGBUS_NAME_VBIF_RT "vbif_rt"
  30. #define DBGBUS_NAME_DSI "dsi"
  31. #define DBGBUS_NAME_RSC "sde_rsc_wrapper"
  32. #define DBGBUS_NAME_LUTDMA "reg_dma"
  33. #define DBGBUS_NAME_DP "dp_ahb"
  34. /* offsets from LUTDMA top address for the debug buses */
  35. #define LUTDMA_0_DEBUG_BUS_CTRL 0x1e8
  36. #define LUTDMA_0_DEBUG_BUS_STATUS 0x1ec
  37. #define LUTDMA_1_DEBUG_BUS_CTRL 0x5e8
  38. #define LUTDMA_1_DEBUG_BUS_STATUS 0x5ec
  39. /* offsets from sde top address for the debug buses */
  40. #define DBGBUS_SSPP0 0x188
  41. #define DBGBUS_AXI_INTF 0x194
  42. #define DBGBUS_SSPP1 0x298
  43. #define DBGBUS_DSPP 0x348
  44. #define DBGBUS_DSPP_STATUS 0x34C
  45. #define DBGBUS_PERIPH 0x418
  46. /* offsets from DSI CTRL base address for the DSI debug buses */
  47. #define DSI_DEBUG_BUS_CTRL 0x0124
  48. #define DSI_DEBUG_BUS 0x0128
  49. #define TEST_MASK(id, tp) ((id << 4) | (tp << 1) | BIT(0))
  50. #define TEST_EXT_MASK(id, tp) (((tp >> 3) << 24) | (id << 4) \
  51. | ((tp & 0x7) << 1) | BIT(0))
  52. /* following offsets are with respect to MDP VBIF base for DBG BUS access */
  53. #define MMSS_VBIF_CLKON 0x4
  54. #define MMSS_VBIF_TEST_BUS_OUT_CTRL 0x210
  55. #define MMSS_VBIF_TEST_BUS1_CTRL0 0x214
  56. #define MMSS_VBIF_TEST_BUS2_CTRL0 0x21c
  57. #define MMSS_VBIF_TEST_BUS_OUT 0x230
  58. /* Vbif error info */
  59. #define MMSS_VBIF_PND_ERR 0x190
  60. #define MMSS_VBIF_SRC_ERR 0x194
  61. #define MMSS_VBIF_XIN_HALT_CTRL1 0x204
  62. #define MMSS_VBIF_ERR_INFO 0X1a0
  63. #define MMSS_VBIF_ERR_INFO_1 0x1a4
  64. #define MMSS_VBIF_CLIENT_NUM 14
  65. #define RSC_WRAPPER_DEBUG_BUS 0x010
  66. #define RSC_WRAPPER_DEBUG_BUS_DATA 0x014
  67. /* offsets from DP AHB base address for DP debug bus */
  68. #define DPTX_DEBUG_BUS_CTRL 0x88
  69. #define DPTX_DEBUG_BUS_OUTPUT 0x8c
  70. /* print debug ranges in groups of 4 u32s */
  71. #define REG_DUMP_ALIGN 16
  72. #define RSC_DEBUG_MUX_SEL_SDM845 9
  73. #define DBG_CTRL_STOP_FTRACE BIT(0)
  74. #define DBG_CTRL_PANIC_UNDERRUN BIT(1)
  75. #define DBG_CTRL_RESET_HW_PANIC BIT(2)
  76. #define DBG_CTRL_MAX BIT(3)
  77. #define DUMP_BUF_SIZE (4096 * 512)
  78. #define DUMP_CLMN_COUNT 4
  79. #define DUMP_LINE_SIZE 256
  80. #define DUMP_MAX_LINES_PER_BLK 512
  81. #define EXT_TEST_GROUP_SEL_EN 0x7
  82. #define DSPP_DEBUGBUS_CTRL_EN 0x7001
  83. #define SDE_HW_REV_MAJOR(rev) ((rev) >> 28)
  84. #define SDE_DBG_LOG_START "start"
  85. #define SDE_DBG_LOG_END "end"
  86. #define SDE_DBG_LOG_MARKER(name, marker, log) \
  87. if (log) \
  88. dev_info(sde_dbg_base.dev, "======== %s %s dump =========\n", marker, name)
  89. #define SDE_DBG_LOG_ENTRY(off, x0, x4, x8, xc, log) \
  90. if (log) \
  91. dev_info(sde_dbg_base.dev, "0x%lx : %08x %08x %08x %08x\n", off, x0, x4, x8, xc)
  92. #define SDE_DBG_LOG_DUMP_ADDR(name, addr, size, off, log) \
  93. if (log) \
  94. dev_info(sde_dbg_base.dev, "%s: start_addr:0x%pK len:0x%x offset=0x%lx\n", \
  95. name, addr, size, off)
  96. #define SDE_DBG_LOG_DEBUGBUS(name, addr, block_id, test_id, val) \
  97. dev_err(sde_dbg_base.dev, "%s 0x%x %d %d 0x%x\n", name, addr, block_id, test_id, val)
  98. /**
  99. * struct sde_dbg_reg_offset - tracking for start and end of region
  100. * @start: start offset
  101. * @start: end offset
  102. */
  103. struct sde_dbg_reg_offset {
  104. u32 start;
  105. u32 end;
  106. };
  107. /**
  108. * struct sde_dbg_reg_range - register dumping named sub-range
  109. * @head: head of this node
  110. * @reg_dump: address for the mem dump
  111. * @range_name: name of this range
  112. * @offset: offsets for range to dump
  113. * @xin_id: client xin id
  114. */
  115. struct sde_dbg_reg_range {
  116. struct list_head head;
  117. u32 *reg_dump;
  118. char range_name[RANGE_NAME_LEN];
  119. struct sde_dbg_reg_offset offset;
  120. uint32_t xin_id;
  121. };
  122. /**
  123. * struct sde_dbg_reg_base - register region base.
  124. * may sub-ranges: sub-ranges are used for dumping
  125. * or may not have sub-ranges: dumping is base -> max_offset
  126. * @reg_base_head: head of this node
  127. * @sub_range_list: head to the list with dump ranges
  128. * @name: register base name
  129. * @base: base pointer
  130. * @phys_addr: block physical address
  131. * @off: cached offset of region for manual register dumping
  132. * @cnt: cached range of region for manual register dumping
  133. * @max_offset: length of region
  134. * @buf: buffer used for manual register dumping
  135. * @buf_len: buffer length used for manual register dumping
  136. * @reg_dump: address for the mem dump if no ranges used
  137. * @cb: callback for external dump function, null if not defined
  138. * @cb_ptr: private pointer to callback function
  139. * @blk_id: id indicate the HW block
  140. */
  141. struct sde_dbg_reg_base {
  142. struct list_head reg_base_head;
  143. struct list_head sub_range_list;
  144. char name[REG_BASE_NAME_LEN];
  145. void __iomem *base;
  146. unsigned long phys_addr;
  147. size_t off;
  148. size_t cnt;
  149. size_t max_offset;
  150. char *buf;
  151. size_t buf_len;
  152. u32 *reg_dump;
  153. void (*cb)(void *ptr);
  154. void *cb_ptr;
  155. u64 blk_id;
  156. };
  157. struct sde_debug_bus_entry {
  158. u32 wr_addr;
  159. u32 rd_addr;
  160. u32 block_id;
  161. u32 block_id_max;
  162. u32 test_id;
  163. u32 test_id_max;
  164. void (*analyzer)(u32 wr_addr, u32 block_id, u32 test_id, u32 val);
  165. };
  166. struct sde_dbg_dsi_ctrl_list_entry {
  167. const char *name;
  168. void __iomem *base;
  169. struct list_head list;
  170. };
  171. struct sde_dbg_debug_bus_common {
  172. char *name;
  173. u32 entries_size;
  174. u32 limited_entries_size;
  175. u32 *dumped_content;
  176. u32 content_idx;
  177. u32 content_size;
  178. u64 blk_id;
  179. };
  180. struct sde_dbg_sde_debug_bus {
  181. struct sde_dbg_debug_bus_common cmn;
  182. struct sde_debug_bus_entry *entries;
  183. struct sde_debug_bus_entry *limited_entries;
  184. u32 top_blk_off;
  185. u32 (*read_tp)(void __iomem *mem_base, u32 wr_addr, u32 rd_addr, u32 block_id, u32 test_id);
  186. void (*clear_tp)(void __iomem *mem_base, u32 wr_addr);
  187. void (*disable_block)(void __iomem *mem_base, u32 wr_addr);
  188. };
  189. /**
  190. * struct sde_dbg_regbuf - wraps buffer and tracking params for register dumps
  191. * @buf: pointer to allocated memory for storing register dumps in hw recovery
  192. * @buf_size: size of the memory allocated
  193. * @len: size of the dump data valid in the buffer
  194. * @rpos: cursor points to the buffer position read by client
  195. * @dump_done: to indicate if dumping to user memory is complete
  196. * @cur_blk: points to the current sde_dbg_reg_base block
  197. */
  198. struct sde_dbg_regbuf {
  199. char *buf;
  200. int buf_size;
  201. int len;
  202. int rpos;
  203. int dump_done;
  204. struct sde_dbg_reg_base *cur_blk;
  205. };
  206. /**
  207. * struct sde_dbg_base - global sde debug base structure
  208. * @evtlog: event log instance
  209. * @reglog: reg log instance
  210. * @reg_base_list: list of register dumping regions
  211. * @reg_dump_base: base address of register dump region
  212. * @reg_dump_addr: register dump address for a block/range
  213. * @dev: device pointer
  214. * @mutex: mutex to serialize access to serialze dumps, debugfs access
  215. * @req_dump_blks: list of blocks requested for dumping
  216. * @panic_on_err: whether to kernel panic after triggering dump via debugfs
  217. * @dump_work: work struct for deferring register dump work to separate thread
  218. * @work_panic: panic after dump if internal user passed "panic" special region
  219. * @enable_reg_dump: whether to dump registers into memory, kernel log, or both
  220. * @enable_dbgbus_dump: whether to dump dbgbus into memory, kernel log, or both
  221. * @coredump_pending: coredump is pending read from userspace
  222. * @coredump_reading: coredump is in reading stage
  223. * @dbgbus_sde: debug bus structure for the sde
  224. * @dbgbus_vbif_rt: debug bus structure for the realtime vbif
  225. * @dbgbus_dsi: debug bus structure for the dsi
  226. * @dbgbus_rsc: debug bus structure for rscc
  227. * @dbgbus_lutdma: debug bus structure for the lutdma hw
  228. * @dbgbus_dp: debug bus structure for dp
  229. * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped
  230. * @dump_secure: dump entries excluding few as it is in secure-session
  231. * @regbuf: buffer data to track the register dumping in hw recovery
  232. * @sde_dbg_printer: drm printer handle used to print sde_dbg info in devcoredump device
  233. * @cur_evt_index: index used for tracking event logs dump in hw recovery
  234. * @cur_reglog_index: index used for tracking register logs dump in hw recovery
  235. * @dbgbus_dump_idx: index used for tracking dbg-bus dump in hw recovery
  236. * @vbif_dbgbus_dump_idx: index for tracking vbif dumps in hw recovery
  237. * @hw_ownership: indicates if the VM owns the HW resources
  238. */
  239. struct sde_dbg_base {
  240. struct sde_dbg_evtlog *evtlog;
  241. struct sde_dbg_reglog *reglog;
  242. struct list_head reg_base_list;
  243. void *reg_dump_base;
  244. void *reg_dump_addr;
  245. struct device *dev;
  246. struct mutex mutex;
  247. struct sde_dbg_reg_base *req_dump_blks[SDE_DBG_BASE_MAX];
  248. u32 panic_on_err;
  249. struct work_struct dump_work;
  250. bool work_panic;
  251. u32 enable_reg_dump;
  252. u32 enable_dbgbus_dump;
  253. bool coredump_pending;
  254. bool coredump_reading;
  255. struct sde_dbg_sde_debug_bus dbgbus_sde;
  256. struct sde_dbg_sde_debug_bus dbgbus_vbif_rt;
  257. struct sde_dbg_sde_debug_bus dbgbus_dsi;
  258. struct sde_dbg_sde_debug_bus dbgbus_rsc;
  259. struct sde_dbg_sde_debug_bus dbgbus_lutdma;
  260. struct sde_dbg_sde_debug_bus dbgbus_dp;
  261. u64 dump_blk_mask;
  262. bool dump_secure;
  263. u32 debugfs_ctrl;
  264. struct drm_printer *sde_dbg_printer;
  265. struct sde_dbg_regbuf regbuf;
  266. u32 cur_evt_index;
  267. u32 cur_reglog_index;
  268. enum sde_dbg_dump_context dump_mode;
  269. bool hw_ownership;
  270. } sde_dbg_base;
  271. static LIST_HEAD(sde_dbg_dsi_list);
  272. static DEFINE_MUTEX(sde_dbg_dsi_mutex);
  273. /* sde_dbg_base_evtlog - global pointer to main sde event log for macro use */
  274. struct sde_dbg_evtlog *sde_dbg_base_evtlog;
  275. /* sde_dbg_base_reglog - global pointer to main sde reg log for macro use */
  276. struct sde_dbg_reglog *sde_dbg_base_reglog;
  277. static void _sde_debug_bus_xbar_dump(u32 wr_addr, u32 block_id, u32 test_id, u32 val)
  278. {
  279. SDE_DBG_LOG_DEBUGBUS("xbar", wr_addr, block_id, test_id, val);
  280. }
  281. static void _sde_debug_bus_lm_dump(u32 wr_addr, u32 block_id, u32 test_id, u32 val)
  282. {
  283. if (!(val & 0xFFF000))
  284. return;
  285. SDE_DBG_LOG_DEBUGBUS("lm", wr_addr, block_id, test_id, val);
  286. }
  287. static void _sde_debug_bus_ppb0_dump(u32 wr_addr, u32 block_id, u32 test_id, u32 val)
  288. {
  289. if (!(val & BIT(15)))
  290. return;
  291. SDE_DBG_LOG_DEBUGBUS("pp0", wr_addr, block_id, test_id, val);
  292. }
  293. static void _sde_debug_bus_ppb1_dump(u32 wr_addr, u32 block_id, u32 test_id, u32 val)
  294. {
  295. if (!(val & BIT(15)))
  296. return;
  297. SDE_DBG_LOG_DEBUGBUS("pp1", wr_addr, block_id, test_id, val);
  298. }
  299. static struct sde_debug_bus_entry dbg_bus_sde_limited[] = {
  300. { DBGBUS_SSPP0, DBGBUS_DSPP_STATUS, 0, 9, 0, 8 },
  301. { DBGBUS_SSPP0, DBGBUS_DSPP_STATUS, 20, 34, 0, 8 },
  302. { DBGBUS_SSPP0, DBGBUS_DSPP_STATUS, 60, 4, 0, 8 },
  303. { DBGBUS_SSPP0, DBGBUS_DSPP_STATUS, 70, 4, 0, 8 },
  304. { DBGBUS_SSPP1, DBGBUS_DSPP_STATUS, 0, 9, 0, 8 },
  305. { DBGBUS_SSPP1, DBGBUS_DSPP_STATUS, 20, 34, 0, 8 },
  306. { DBGBUS_SSPP1, DBGBUS_DSPP_STATUS, 60, 4, 0, 8 },
  307. { DBGBUS_SSPP1, DBGBUS_DSPP_STATUS, 70, 4, 0, 8 },
  308. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 0, 1, 0, 8 },
  309. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 9, 1, 0, 8 },
  310. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 13, 2, 0, 8 },
  311. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 19, 2, 0, 8 },
  312. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 24, 2, 0, 8 },
  313. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 31, 8, 0, 8 },
  314. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 42, 12, 0, 8 },
  315. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 54, 2, 0, 32 },
  316. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 56, 2, 0, 8 },
  317. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 63, 73, 0, 8 },
  318. { DBGBUS_PERIPH, DBGBUS_DSPP_STATUS, 0, 1, 0, 8 },
  319. { DBGBUS_PERIPH, DBGBUS_DSPP_STATUS, 47, 7, 0, 8 },
  320. { DBGBUS_PERIPH, DBGBUS_DSPP_STATUS, 60, 14, 0, 8 },
  321. { DBGBUS_PERIPH, DBGBUS_DSPP_STATUS, 80, 3, 0, 8 },
  322. };
  323. static struct sde_debug_bus_entry dbg_bus_sde[] = {
  324. { DBGBUS_SSPP0, DBGBUS_DSPP_STATUS, 0, 74, 0, 32 },
  325. { DBGBUS_SSPP1, DBGBUS_DSPP_STATUS, 0, 74, 0, 32 },
  326. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 0, 137, 0, 32 },
  327. { DBGBUS_PERIPH, DBGBUS_DSPP_STATUS, 0, 78, 0, 32 },
  328. { DBGBUS_AXI_INTF, DBGBUS_DSPP_STATUS, 0, 63, 0, 32 },
  329. /* ppb_0 */
  330. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 31, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  331. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 33, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  332. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 35, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  333. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 42, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  334. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 47, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  335. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 49, 1, 0, 1, _sde_debug_bus_ppb0_dump },
  336. /* ppb_1 */
  337. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 32, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  338. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 34, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  339. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 36, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  340. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 43, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  341. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 48, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  342. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 50, 1, 0, 1, _sde_debug_bus_ppb1_dump },
  343. /* crossbar */
  344. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 0, 1, 0, 1, _sde_debug_bus_xbar_dump },
  345. /* blend */
  346. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 63, 1, 7, 1, _sde_debug_bus_lm_dump },
  347. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 70, 1, 7, 1, _sde_debug_bus_lm_dump },
  348. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 77, 1, 7, 1, _sde_debug_bus_lm_dump },
  349. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 110, 1, 7, 1, _sde_debug_bus_lm_dump },
  350. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 96, 1, 7, 1, _sde_debug_bus_lm_dump },
  351. { DBGBUS_DSPP, DBGBUS_DSPP_STATUS, 124, 1, 7, 1, _sde_debug_bus_lm_dump }
  352. };
  353. static struct sde_debug_bus_entry vbif_dbg_bus_limited[] = {
  354. { MMSS_VBIF_TEST_BUS1_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 0, 2, 0, 12},
  355. { MMSS_VBIF_TEST_BUS1_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 4, 6, 0, 12},
  356. { MMSS_VBIF_TEST_BUS1_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 12, 2, 0, 12},
  357. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 0, 2, 0, 16},
  358. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 0, 2, 128, 208},
  359. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 4, 6, 0, 16},
  360. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 4, 6, 128, 208},
  361. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 12, 2, 0, 16},
  362. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 12, 2, 128, 208},
  363. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 16, 2, 0, 16},
  364. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 16, 2, 128, 208},
  365. };
  366. static struct sde_debug_bus_entry vbif_dbg_bus[] = {
  367. { MMSS_VBIF_TEST_BUS1_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 0, 15, 0, 512},
  368. { MMSS_VBIF_TEST_BUS2_CTRL0, MMSS_VBIF_TEST_BUS_OUT, 0, 18, 0, 512},
  369. };
  370. static struct sde_debug_bus_entry dsi_dbg_bus[] = {
  371. {DSI_DEBUG_BUS_CTRL, DSI_DEBUG_BUS, 0, 4, 0, 64},
  372. };
  373. static struct sde_debug_bus_entry rsc_dbg_bus[] = {
  374. {RSC_WRAPPER_DEBUG_BUS, RSC_WRAPPER_DEBUG_BUS_DATA, 0, 1, 0, 16},
  375. };
  376. static struct sde_debug_bus_entry dbg_bus_lutdma[] = {
  377. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 0, 12 },
  378. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 256, 1 },
  379. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 512, 4 },
  380. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 768, 1 },
  381. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 8192, 2 },
  382. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 8448, 1 },
  383. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 8704, 1 },
  384. { LUTDMA_0_DEBUG_BUS_CTRL, LUTDMA_0_DEBUG_BUS_STATUS, 0, 1, 8960, 1 },
  385. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 0, 12 },
  386. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 256, 1 },
  387. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 512, 4 },
  388. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 768, 1 },
  389. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 8192, 2 },
  390. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 8448, 1 },
  391. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 8704, 1 },
  392. { LUTDMA_1_DEBUG_BUS_CTRL, LUTDMA_1_DEBUG_BUS_STATUS, 0, 1, 8960, 1 },
  393. };
  394. static struct sde_debug_bus_entry dp_dbg_bus[] = {
  395. {DPTX_DEBUG_BUS_CTRL, DPTX_DEBUG_BUS_OUTPUT, 0, 1, 0, 145},
  396. };
  397. /**
  398. * _sde_dump_reg - helper function for dumping rotator register set content
  399. * @dump_name: register set name
  400. * @reg_dump_flag: dumping flag controlling in-log/memory dump location
  401. * @base_addr: starting address of io region for calculating offsets to print
  402. * @addr: starting address offset for dumping
  403. * @len_bytes: range of the register set
  404. * @dump_mem: output buffer for memory dump location option
  405. * @from_isr: whether being called from isr context
  406. */
  407. static void _sde_dump_reg(const char *dump_name, u32 reg_dump_flag,
  408. char *base_addr, char *addr, size_t len_bytes, u32 **dump_mem)
  409. {
  410. u32 in_log, in_mem, in_dump, len_align, len_padded;
  411. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  412. u32 *dump_addr = NULL;
  413. char *end_addr;
  414. int i;
  415. if (!len_bytes || !dump_mem)
  416. return;
  417. in_log = (reg_dump_flag & (SDE_DBG_DUMP_IN_LOG | SDE_DBG_DUMP_IN_LOG_LIMITED));
  418. in_mem = (reg_dump_flag & SDE_DBG_DUMP_IN_MEM);
  419. in_dump = (reg_dump_flag & SDE_DBG_DUMP_IN_COREDUMP);
  420. pr_debug("%s: reg_dump_flag=%d in_log=%d in_mem=%d\n",
  421. dump_name, reg_dump_flag, in_log, in_mem);
  422. if (!in_log && !in_mem && !in_dump)
  423. return;
  424. len_align = (len_bytes + REG_DUMP_ALIGN - 1) / REG_DUMP_ALIGN;
  425. len_padded = len_align * REG_DUMP_ALIGN;
  426. end_addr = addr + len_bytes;
  427. *dump_mem = dbg_base->reg_dump_addr;
  428. dbg_base->reg_dump_addr += len_padded;
  429. dump_addr = *dump_mem;
  430. SDE_DBG_LOG_DUMP_ADDR(dump_name, dump_addr, len_padded,
  431. (unsigned long)(addr - base_addr), in_log);
  432. if (in_dump && sde_dbg_base.coredump_reading)
  433. drm_printf(sde_dbg_base.sde_dbg_printer,
  434. "%s: start_addr:0x%pK len:0x%x reg_offset=0x%lx\n",
  435. dump_name, dump_addr, len_padded, (unsigned long)(addr - base_addr));
  436. for (i = 0; i < len_align; i++) {
  437. u32 x0, x4, x8, xc;
  438. x0 = (addr < end_addr) ? readl_relaxed(addr + 0x0) : 0;
  439. x4 = (addr + 0x4 < end_addr) ? readl_relaxed(addr + 0x4) : 0;
  440. x8 = (addr + 0x8 < end_addr) ? readl_relaxed(addr + 0x8) : 0;
  441. xc = (addr + 0xc < end_addr) ? readl_relaxed(addr + 0xc) : 0;
  442. SDE_DBG_LOG_ENTRY((unsigned long)(addr - base_addr), x0, x4, x8, xc, in_log);
  443. if (dump_addr && (in_mem || in_dump) && (!sde_dbg_base.coredump_reading)) {
  444. dump_addr[i * 4] = x0;
  445. dump_addr[i * 4 + 1] = x4;
  446. dump_addr[i * 4 + 2] = x8;
  447. dump_addr[i * 4 + 3] = xc;
  448. }
  449. if (dump_addr && in_dump && sde_dbg_base.coredump_reading)
  450. drm_printf(sde_dbg_base.sde_dbg_printer,
  451. "0x%lx : %08x %08x %08x %08x\n",
  452. (unsigned long)(addr - base_addr),
  453. dump_addr[i * 4],
  454. dump_addr[i * 4 + 1],
  455. dump_addr[i * 4 + 2],
  456. dump_addr[i * 4 + 3]);
  457. addr += REG_DUMP_ALIGN;
  458. }
  459. }
  460. /**
  461. * _sde_dbg_get_dump_range - helper to retrieve dump length for a range node
  462. * @range_node: range node to dump
  463. * @max_offset: max offset of the register base
  464. * @Return: length
  465. */
  466. static u32 _sde_dbg_get_dump_range(struct sde_dbg_reg_offset *range_node,
  467. size_t max_offset)
  468. {
  469. u32 length = 0;
  470. if (range_node->start == 0 && range_node->end == 0) {
  471. length = max_offset;
  472. } else if (range_node->start < max_offset) {
  473. if (range_node->end > max_offset)
  474. length = max_offset - range_node->start;
  475. else if (range_node->start < range_node->end)
  476. length = range_node->end - range_node->start;
  477. }
  478. return length;
  479. }
  480. static u32 _sde_dbg_get_reg_blk_size(struct sde_dbg_reg_base *dbg)
  481. {
  482. u32 len, len_align, len_padded;
  483. u32 size = 0;
  484. struct sde_dbg_reg_range *range_node;
  485. if (!dbg || !dbg->base) {
  486. pr_err("dbg base is null!\n");
  487. return 0;
  488. }
  489. if (!list_empty(&dbg->sub_range_list)) {
  490. list_for_each_entry(range_node, &dbg->sub_range_list, head) {
  491. len = _sde_dbg_get_dump_range(&range_node->offset,
  492. dbg->max_offset);
  493. len_align = (len + REG_DUMP_ALIGN - 1) / REG_DUMP_ALIGN;
  494. len_padded = len_align * REG_DUMP_ALIGN;
  495. size += REG_BASE_NAME_LEN + RANGE_NAME_LEN + len_padded;
  496. }
  497. } else {
  498. len = dbg->max_offset;
  499. len_align = (len + REG_DUMP_ALIGN - 1) / REG_DUMP_ALIGN;
  500. len_padded = len_align * REG_DUMP_ALIGN;
  501. size += REG_BASE_NAME_LEN + RANGE_NAME_LEN + len_padded;
  502. }
  503. return size;
  504. }
  505. static u32 _sde_dbg_get_reg_dump_size(void)
  506. {
  507. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  508. struct sde_dbg_reg_base *blk_base;
  509. u32 size = 0;
  510. list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head)
  511. size += _sde_dbg_get_reg_blk_size(blk_base);
  512. return size;
  513. }
  514. #if IS_ENABLED(CONFIG_QCOM_VA_MINIDUMP)
  515. static void sde_dbg_add_dbg_buses_to_minidump_va(void)
  516. {
  517. static struct sde_dbg_base *dbg = &sde_dbg_base;
  518. sde_mini_dump_add_va_region("sde_dbgbus", dbg->dbgbus_sde.cmn.content_size*sizeof(u32),
  519. dbg->dbgbus_sde.cmn.dumped_content);
  520. sde_mini_dump_add_va_region("vbif_dbgbus", dbg->dbgbus_vbif_rt.cmn.content_size*sizeof(u32),
  521. dbg->dbgbus_vbif_rt.cmn.dumped_content);
  522. sde_mini_dump_add_va_region("dsi_dbgbus", dbg->dbgbus_dsi.cmn.content_size*sizeof(u32),
  523. dbg->dbgbus_dsi.cmn.dumped_content);
  524. sde_mini_dump_add_va_region("lutdma_dbgbus",
  525. dbg->dbgbus_lutdma.cmn.content_size*sizeof(u32),
  526. dbg->dbgbus_lutdma.cmn.dumped_content);
  527. sde_mini_dump_add_va_region("rsc_dbgbus", dbg->dbgbus_rsc.cmn.content_size*sizeof(u32),
  528. dbg->dbgbus_rsc.cmn.dumped_content);
  529. sde_mini_dump_add_va_region("dp_dbgbus", dbg->dbgbus_dp.cmn.content_size*sizeof(u32),
  530. dbg->dbgbus_dp.cmn.dumped_content);
  531. }
  532. static int sde_md_notify_handler(struct notifier_block *this,
  533. unsigned long event, void *ptr)
  534. {
  535. struct device *dev = sde_dbg_base.dev;
  536. struct platform_device *pdev = to_platform_device(dev);
  537. struct drm_device *ddev = platform_get_drvdata(pdev);
  538. struct msm_drm_private *priv = ddev->dev_private;
  539. struct sde_kms *sde_kms = to_sde_kms(priv->kms);
  540. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  541. u32 reg_dump_size = _sde_dbg_get_reg_dump_size();
  542. sde_mini_dump_add_va_region("msm_drm_priv", sizeof(*priv), priv);
  543. sde_mini_dump_add_va_region("sde_evtlog",
  544. sizeof(*sde_dbg_base_evtlog), sde_dbg_base_evtlog);
  545. sde_mini_dump_add_va_region("sde_reglog",
  546. sizeof(*sde_dbg_base_reglog), sde_dbg_base_reglog);
  547. sde_mini_dump_add_va_region("sde_reg_dump", reg_dump_size, dbg_base->reg_dump_base);
  548. sde_dbg_add_dbg_buses_to_minidump_va();
  549. sde_kms_add_data_to_minidump_va(sde_kms);
  550. return 0;
  551. }
  552. static struct notifier_block sde_md_notify_blk = {
  553. .notifier_call = sde_md_notify_handler,
  554. .priority = INT_MAX,
  555. };
  556. static int sde_register_md_panic_notifer()
  557. {
  558. qcom_va_md_register("display", &sde_md_notify_blk);
  559. return 0;
  560. }
  561. void sde_mini_dump_add_va_region(const char *name, u32 size, void *virt_addr)
  562. {
  563. struct va_md_entry md_entry;
  564. int ret;
  565. strlcpy(md_entry.owner, name, sizeof(md_entry.owner));
  566. md_entry.vaddr = (uintptr_t)virt_addr;
  567. md_entry.size = size;
  568. ret = qcom_va_md_add_region(&md_entry);
  569. if (ret < 0)
  570. SDE_ERROR("va minudmp add entry failed for %s, returned %d\n",
  571. name, ret);
  572. return;
  573. }
  574. #else
  575. static int sde_register_md_panic_notifer()
  576. {
  577. return 0;
  578. }
  579. void sde_mini_dump_add_va_region(const char *name, u32 size, void *virt_addr)
  580. {
  581. return;
  582. }
  583. #endif
  584. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 15, 0))
  585. static int _sde_dump_reg_range_cmp(void *priv, const struct list_head *a,
  586. const struct list_head *b)
  587. #else
  588. static int _sde_dump_reg_range_cmp(void *priv, struct list_head *a,
  589. struct list_head *b)
  590. #endif
  591. {
  592. struct sde_dbg_reg_range *ar, *br;
  593. if (!a || !b)
  594. return 0;
  595. ar = container_of(a, struct sde_dbg_reg_range, head);
  596. br = container_of(b, struct sde_dbg_reg_range, head);
  597. return ar->offset.start - br->offset.start;
  598. }
  599. #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 15, 0))
  600. static int _sde_dump_blk_phys_addr_cmp(void *priv, const struct list_head *a,
  601. const struct list_head *b)
  602. #else
  603. static int _sde_dump_blk_phys_addr_cmp(void *priv, struct list_head *a,
  604. struct list_head *b)
  605. #endif
  606. {
  607. struct sde_dbg_reg_base *ar, *br;
  608. if (!a || !b)
  609. return 0;
  610. ar = container_of(a, struct sde_dbg_reg_base, reg_base_head);
  611. br = container_of(b, struct sde_dbg_reg_base, reg_base_head);
  612. return ar->phys_addr - br->phys_addr;
  613. }
  614. static const char *const exclude_modules[] = {
  615. "vbif_rt",
  616. "vbif_nrt",
  617. "wb_2",
  618. NULL
  619. };
  620. static bool is_block_exclude(char **modules, char *name)
  621. {
  622. char **ptr = modules;
  623. while (*ptr != NULL) {
  624. if (!strcmp(name, *ptr))
  625. return true;
  626. ++ptr;
  627. }
  628. return false;
  629. }
  630. /**
  631. * _sde_dump_reg_by_ranges - dump ranges or full range of the register blk base
  632. * @dbg: register blk base structure
  633. * @reg_dump_flag: dump target, memory, kernel log, or both
  634. */
  635. static void _sde_dump_reg_by_ranges(struct sde_dbg_reg_base *dbg, u32 reg_dump_flag)
  636. {
  637. char *addr;
  638. size_t len;
  639. struct sde_dbg_reg_range *range_node;
  640. bool in_log;
  641. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  642. if (!dbg || !(dbg->base || dbg->cb)) {
  643. pr_err("dbg base is null!\n");
  644. return;
  645. }
  646. in_log = (reg_dump_flag & (SDE_DBG_DUMP_IN_LOG | SDE_DBG_DUMP_IN_LOG_LIMITED));
  647. SDE_DBG_LOG_MARKER(dbg->name, SDE_DBG_LOG_START, in_log);
  648. if ((reg_dump_flag & SDE_DBG_DUMP_IN_COREDUMP) && sde_dbg_base.coredump_reading)
  649. drm_printf(sde_dbg_base.sde_dbg_printer,
  650. "%s:=========%s DUMP=========\n", __func__, dbg->name);
  651. if (dbg->cb) {
  652. dbg->cb(dbg->cb_ptr);
  653. /* If there is a list to dump the registers by ranges, use the ranges */
  654. } else if (!list_empty(&dbg->sub_range_list)) {
  655. /* sort the list by start address first */
  656. list_sort(NULL, &dbg->sub_range_list, _sde_dump_reg_range_cmp);
  657. list_for_each_entry(range_node, &dbg->sub_range_list, head) {
  658. len = _sde_dbg_get_dump_range(&range_node->offset, dbg->max_offset);
  659. addr = dbg->base + range_node->offset.start;
  660. pr_debug("%s: range_base=0x%pK start=0x%x end=0x%x\n",
  661. range_node->range_name, addr, range_node->offset.start,
  662. range_node->offset.end);
  663. scnprintf(dbg_base->reg_dump_addr, REG_BASE_NAME_LEN, dbg->name);
  664. dbg_base->reg_dump_addr += REG_BASE_NAME_LEN;
  665. scnprintf(dbg_base->reg_dump_addr, RANGE_NAME_LEN,
  666. range_node->range_name);
  667. dbg_base->reg_dump_addr += RANGE_NAME_LEN;
  668. _sde_dump_reg(range_node->range_name, reg_dump_flag,
  669. dbg->base, addr, len, &range_node->reg_dump);
  670. }
  671. } else {
  672. /* If there is no list to dump ranges, dump all registers */
  673. SDE_DBG_LOG_DUMP_ADDR("base", dbg->base, dbg->max_offset, 0, in_log);
  674. addr = dbg->base;
  675. len = dbg->max_offset;
  676. scnprintf(dbg_base->reg_dump_addr, REG_BASE_NAME_LEN, dbg->name);
  677. dbg_base->reg_dump_addr += REG_BASE_NAME_LEN;
  678. dbg_base->reg_dump_addr += RANGE_NAME_LEN;
  679. _sde_dump_reg(dbg->name, reg_dump_flag, dbg->base, addr, len, &dbg->reg_dump);
  680. }
  681. }
  682. /**
  683. * _sde_dump_reg_mask - dump register regions based on mask
  684. * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped
  685. * @dump_secure: flag to indicate dumping in secure-session
  686. */
  687. static void _sde_dump_reg_mask(u64 dump_blk_mask, bool dump_secure)
  688. {
  689. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  690. struct sde_dbg_reg_base *blk_base;
  691. if (!dump_blk_mask)
  692. return;
  693. list_sort(NULL, &dbg_base->reg_base_list, _sde_dump_blk_phys_addr_cmp);
  694. list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head) {
  695. if ((!(blk_base->blk_id & dump_blk_mask)) || (!strlen(blk_base->name)))
  696. continue;
  697. if (dump_secure && is_block_exclude((char **)exclude_modules, blk_base->name))
  698. continue;
  699. _sde_dump_reg_by_ranges(blk_base, dbg_base->enable_reg_dump);
  700. }
  701. }
  702. /**
  703. * _sde_dump_get_blk_addr - retrieve register block address by name
  704. * @blk_name: register blk name
  705. * @Return: register blk base, or NULL
  706. */
  707. static struct sde_dbg_reg_base *_sde_dump_get_blk_addr(const char *blk_name)
  708. {
  709. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  710. struct sde_dbg_reg_base *blk_base;
  711. list_for_each_entry(blk_base, &dbg_base->reg_base_list, reg_base_head)
  712. if (strlen(blk_base->name) && !strcmp(blk_base->name, blk_name))
  713. return blk_base;
  714. return NULL;
  715. }
  716. static u32 _sde_dbg_cmn_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr, u32 val)
  717. {
  718. writel_relaxed(val, mem_base + wr_addr);
  719. wmb(); /* make sure debug-bus test point is enabled */
  720. return readl_relaxed(mem_base + rd_addr);
  721. }
  722. static void _sde_dbg_cmn_clear_test_point(void __iomem *mem_base, u32 wr_addr)
  723. {
  724. writel_relaxed(0, mem_base + wr_addr);
  725. }
  726. static u32 _sde_dbg_dp_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  727. u32 block_id, u32 test_id)
  728. {
  729. u32 val = (test_id << 4) | BIT(0);
  730. return _sde_dbg_cmn_read_test_point(mem_base, wr_addr, rd_addr, val);
  731. }
  732. static u32 _sde_dbg_rsc_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  733. u32 block_id, u32 test_id)
  734. {
  735. u32 val = ((test_id & 0xf) << 1) | BIT(0);
  736. return _sde_dbg_cmn_read_test_point(mem_base, wr_addr, rd_addr, val);
  737. }
  738. static u32 _sde_dbg_lutdma_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  739. u32 block_id, u32 test_id)
  740. {
  741. u32 val = (BIT(0) | (test_id << 1)) & 0xFFFF;
  742. return _sde_dbg_cmn_read_test_point(mem_base, wr_addr, rd_addr, val);
  743. }
  744. static u32 _sde_dbg_dsi_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  745. u32 block_id, u32 test_id)
  746. {
  747. u32 val = (((block_id & 0x3) << 12) | ((test_id & 0x3f) << 4) | BIT(0));
  748. return _sde_dbg_cmn_read_test_point(mem_base, wr_addr, rd_addr, val);
  749. }
  750. static void _sde_dbg_vbif_disable_block(void __iomem *mem_base, u32 wr_addr)
  751. {
  752. u32 disable_addr;
  753. /* make sure that other bus is off */
  754. disable_addr = (wr_addr == MMSS_VBIF_TEST_BUS1_CTRL0) ?
  755. MMSS_VBIF_TEST_BUS2_CTRL0 : MMSS_VBIF_TEST_BUS1_CTRL0;
  756. writel_relaxed(0, mem_base + disable_addr);
  757. writel_relaxed(BIT(0), mem_base + MMSS_VBIF_TEST_BUS_OUT_CTRL);
  758. }
  759. static u32 _sde_dbg_vbif_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  760. u32 block_id, u32 test_id)
  761. {
  762. writel_relaxed((1 << block_id), mem_base + wr_addr);
  763. writel_relaxed(test_id, mem_base + wr_addr + 0x4);
  764. wmb(); /* make sure debug-bus test point is enabled */
  765. return readl_relaxed(mem_base + rd_addr);
  766. }
  767. static void _sde_dbg_vbif_clear_test_point(void __iomem *mem_base, u32 wr_addr)
  768. {
  769. writel_relaxed(0, mem_base + wr_addr);
  770. writel_relaxed(0, mem_base + wr_addr + 0x4);
  771. }
  772. static u32 _sde_dbg_sde_read_test_point(void __iomem *mem_base, u32 wr_addr, u32 rd_addr,
  773. u32 block_id, u32 test_id)
  774. {
  775. if (block_id > EXT_TEST_GROUP_SEL_EN)
  776. writel_relaxed(TEST_EXT_MASK(block_id, test_id), mem_base + wr_addr);
  777. else
  778. writel_relaxed(TEST_MASK(block_id, test_id), mem_base + wr_addr);
  779. /* keep DSPP test point enabled */
  780. if (wr_addr != DBGBUS_DSPP)
  781. writel_relaxed(DSPP_DEBUGBUS_CTRL_EN, mem_base + DBGBUS_DSPP);
  782. wmb(); /* make sure test bits were written */
  783. return readl_relaxed(mem_base + rd_addr);
  784. }
  785. static void _sde_dbg_sde_clear_test_point(void __iomem *mem_base, u32 wr_addr)
  786. {
  787. writel_relaxed(0x0, mem_base + wr_addr);
  788. if (wr_addr != DBGBUS_DSPP)
  789. writel_relaxed(0x0, mem_base + DBGBUS_DSPP);
  790. }
  791. static void _sde_dbg_dump_vbif_err_info(void __iomem *mem_base)
  792. {
  793. u32 value, d0, d1;
  794. unsigned long reg, reg1, reg2;
  795. int i;
  796. value = readl_relaxed(mem_base + MMSS_VBIF_CLKON);
  797. writel_relaxed(value | BIT(1), mem_base + MMSS_VBIF_CLKON);
  798. wmb(); /* make sure that vbif core is on */
  799. /*
  800. * Extract VBIF error info based on XIN halt and error status.
  801. * If the XIN client is not in HALT state, or an error is detected,
  802. * then retrieve the VBIF error info for it.
  803. */
  804. reg = readl_relaxed(mem_base + MMSS_VBIF_XIN_HALT_CTRL1);
  805. reg1 = readl_relaxed(mem_base + MMSS_VBIF_PND_ERR);
  806. reg2 = readl_relaxed(mem_base + MMSS_VBIF_SRC_ERR);
  807. dev_err(sde_dbg_base.dev, "xin halt:0x%lx, pnd err:0x%lx, src err:0x%lx\n",
  808. reg, reg1, reg2);
  809. reg >>= 16;
  810. reg &= ~(reg1 | reg2);
  811. for (i = 0; i < MMSS_VBIF_CLIENT_NUM; i++) {
  812. if (!test_bit(0, &reg)) {
  813. writel_relaxed(i, mem_base + MMSS_VBIF_ERR_INFO);
  814. wmb(); /* make sure reg write goes through */
  815. d0 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO);
  816. d1 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO_1);
  817. dev_err(sde_dbg_base.dev, "Client:%d, errinfo=0x%x, errinfo1=0x%x\n",
  818. i, d0, d1);
  819. }
  820. reg >>= 1;
  821. }
  822. }
  823. static bool _is_dbg_bus_limited_valid(struct sde_dbg_sde_debug_bus *bus,
  824. u32 wr_addr, u32 block_id, u32 test_id)
  825. {
  826. struct sde_debug_bus_entry *entry;
  827. u32 block_id_max, test_id_max;
  828. int i;
  829. if (!bus->limited_entries || !bus->cmn.limited_entries_size)
  830. return true;
  831. for (i = 0; i < bus->cmn.limited_entries_size; i++) {
  832. entry = bus->limited_entries + i;
  833. block_id_max = entry->block_id + entry->block_id_max;
  834. test_id_max = entry->test_id + entry->test_id_max;
  835. if ((wr_addr == entry->wr_addr)
  836. && ((block_id >= entry->block_id) && (block_id < block_id_max))
  837. && ((test_id >= entry->test_id) && (test_id < test_id_max)))
  838. return true;
  839. }
  840. return false;
  841. }
  842. static void _sde_dbg_dump_bus_entry(struct sde_dbg_sde_debug_bus *bus,
  843. struct sde_debug_bus_entry *entries, u32 bus_size,
  844. void __iomem *mem_base, u32 *dump_addr, u32 enable_mask)
  845. {
  846. u32 status = 0;
  847. int i, j, k;
  848. bool in_mem, in_log, in_dump, in_log_limited;
  849. struct sde_debug_bus_entry *entry;
  850. if (!bus->read_tp || !bus->clear_tp)
  851. return;
  852. in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM);
  853. in_log = (enable_mask & SDE_DBG_DUMP_IN_LOG);
  854. in_log_limited = (enable_mask & SDE_DBG_DUMP_IN_LOG_LIMITED);
  855. in_dump = (enable_mask & SDE_DBG_DUMP_IN_COREDUMP);
  856. for (k = 0; k < bus_size; k++) {
  857. entry = entries + k;
  858. if (bus->disable_block)
  859. bus->disable_block(mem_base, entry->wr_addr);
  860. for (i = entry->block_id; i < (entry->block_id + entry->block_id_max); i++) {
  861. for (j = entry->test_id; j < (entry->test_id + entry->test_id_max); j++) {
  862. status = bus->read_tp(mem_base, entry->wr_addr,
  863. entry->rd_addr, i, j);
  864. if (!entry->analyzer && (in_log || (in_log_limited &&
  865. _is_dbg_bus_limited_valid(bus, entry->wr_addr, i, j))))
  866. SDE_DBG_LOG_ENTRY(0, entry->wr_addr, i, j, status, true);
  867. if (dump_addr && (in_mem || in_dump) && (!sde_dbg_base.coredump_reading)) {
  868. *dump_addr++ = entry->wr_addr;
  869. *dump_addr++ = i;
  870. *dump_addr++ = j;
  871. *dump_addr++ = status;
  872. }
  873. if (dump_addr && in_dump && sde_dbg_base.coredump_reading) {
  874. drm_printf(sde_dbg_base.sde_dbg_printer, "%08x %08x %08x %08x\n",
  875. *dump_addr, *(dump_addr + 1), *(dump_addr + 2), *(dump_addr + 3));
  876. dump_addr += 4;
  877. }
  878. if (entry->analyzer)
  879. entry->analyzer(entry->wr_addr, i, j, status);
  880. }
  881. }
  882. /* Disable debug bus once we are done */
  883. bus->clear_tp(mem_base, entry->wr_addr);
  884. }
  885. }
  886. static void _sde_dbg_dump_sde_dbg_bus(struct sde_dbg_sde_debug_bus *bus, u32 enable_mask)
  887. {
  888. bool in_mem, in_dump, in_log;
  889. u32 **dump_mem = NULL;
  890. u32 *dump_addr = NULL;
  891. int i, list_size = 0;
  892. void __iomem *mem_base = NULL;
  893. struct sde_dbg_reg_base *reg_base;
  894. struct sde_debug_bus_entry *entries;
  895. u32 bus_size;
  896. char name[20];
  897. reg_base = _sde_dump_get_blk_addr(bus->cmn.name);
  898. if (!reg_base || !reg_base->base) {
  899. pr_err("unable to find mem_base for %s\n", bus->cmn.name);
  900. return;
  901. }
  902. in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM);
  903. in_dump = (enable_mask & SDE_DBG_DUMP_IN_COREDUMP);
  904. in_log = (enable_mask & (SDE_DBG_DUMP_IN_LOG | SDE_DBG_DUMP_IN_LOG_LIMITED));
  905. mem_base = reg_base->base;
  906. if (!strcmp(bus->cmn.name, DBGBUS_NAME_SDE))
  907. mem_base += bus->top_blk_off;
  908. if (!strcmp(bus->cmn.name, DBGBUS_NAME_VBIF_RT))
  909. _sde_dbg_dump_vbif_err_info(mem_base);
  910. entries = bus->entries;
  911. bus_size = bus->cmn.entries_size;
  912. dump_mem = &bus->cmn.dumped_content;
  913. if (!dump_mem || !entries || !bus_size)
  914. return;
  915. /* allocate memory for each test id */
  916. for (i = 0; i < bus_size; i++)
  917. list_size += (entries[i].block_id_max * entries[i].test_id_max);
  918. list_size *= sizeof(u32) * DUMP_CLMN_COUNT;
  919. snprintf(name, sizeof(name), "%s-debugbus", bus->cmn.name);
  920. SDE_DBG_LOG_MARKER(name, SDE_DBG_LOG_START, in_log);
  921. if ((in_mem || in_dump) && (!(*dump_mem))) {
  922. *dump_mem = kvzalloc(list_size, GFP_KERNEL);
  923. bus->cmn.content_size = list_size / sizeof(u32);
  924. }
  925. dump_addr = *dump_mem;
  926. SDE_DBG_LOG_DUMP_ADDR(bus->cmn.name, dump_addr, list_size, 0, in_log);
  927. _sde_dbg_dump_bus_entry(bus, entries, bus_size, mem_base, dump_addr, enable_mask);
  928. }
  929. static void _sde_dbg_dump_dsi_dbg_bus(struct sde_dbg_sde_debug_bus *bus, u32 enable_mask)
  930. {
  931. struct sde_dbg_dsi_ctrl_list_entry *ctl_entry;
  932. struct list_head *list;
  933. int list_size = 0;
  934. bool in_mem, in_dump, in_log;
  935. u32 i, dsi_count = 0;
  936. u32 **dump_mem = NULL;
  937. u32 *dump_addr = NULL;
  938. struct sde_debug_bus_entry *entries;
  939. u32 bus_size;
  940. char name[20];
  941. entries = bus->entries;
  942. bus_size = bus->cmn.entries_size;
  943. dump_mem = &bus->cmn.dumped_content;
  944. if (!dump_mem || !entries || !bus_size || list_empty(&sde_dbg_dsi_list))
  945. return;
  946. in_mem = (enable_mask & SDE_DBG_DUMP_IN_MEM);
  947. in_dump = (enable_mask & SDE_DBG_DUMP_IN_COREDUMP);
  948. in_log = (enable_mask & (SDE_DBG_DUMP_IN_LOG | SDE_DBG_DUMP_IN_LOG_LIMITED));
  949. list_for_each(list, &sde_dbg_dsi_list)
  950. dsi_count++;
  951. for (i = 0; i < bus_size; i++)
  952. list_size += (entries[i].block_id_max * entries[i].test_id_max);
  953. list_size *= sizeof(u32) * DUMP_CLMN_COUNT * dsi_count;
  954. snprintf(name, sizeof(name), "%s-debugbus", bus->cmn.name);
  955. SDE_DBG_LOG_MARKER(name, SDE_DBG_LOG_START, in_log);
  956. mutex_lock(&sde_dbg_dsi_mutex);
  957. if ((in_mem || in_dump) && (!(*dump_mem))) {
  958. *dump_mem = kvzalloc(list_size, GFP_KERNEL);
  959. bus->cmn.content_size = list_size / sizeof(u32);
  960. }
  961. dump_addr = *dump_mem;
  962. list_for_each_entry(ctl_entry, &sde_dbg_dsi_list, list) {
  963. SDE_DBG_LOG_DUMP_ADDR(ctl_entry->name, dump_addr, list_size / dsi_count, 0, in_log);
  964. _sde_dbg_dump_bus_entry(bus, entries, bus_size, ctl_entry->base,
  965. dump_addr, enable_mask);
  966. if (dump_addr)
  967. dump_addr += list_size / (sizeof(u32) * dsi_count);
  968. }
  969. mutex_unlock(&sde_dbg_dsi_mutex);
  970. }
  971. void sde_evtlog_dump_all(struct sde_dbg_evtlog *evtlog)
  972. {
  973. char buf[SDE_EVTLOG_BUF_MAX];
  974. bool update_last_entry = true;
  975. u32 in_log, in_mem, in_dump;
  976. u32 log_size = 0;
  977. char *dump_addr = NULL;
  978. int i;
  979. if (!evtlog )
  980. return;
  981. in_log = evtlog->dump_mode & (SDE_DBG_DUMP_IN_LOG | SDE_DBG_DUMP_IN_LOG_LIMITED);
  982. in_mem = evtlog->dump_mode & SDE_DBG_DUMP_IN_MEM;
  983. in_dump = evtlog->dump_mode & SDE_DBG_DUMP_IN_COREDUMP;
  984. log_size = sde_evtlog_count(evtlog);
  985. if (!log_size)
  986. return;
  987. if (!evtlog->dumped_evtlog) {
  988. if (in_mem)
  989. log_size = SDE_EVTLOG_ENTRY;
  990. evtlog->dumped_evtlog = kvzalloc((log_size * SDE_EVTLOG_BUF_MAX), GFP_KERNEL);
  991. evtlog->log_size = log_size;
  992. }
  993. dump_addr = evtlog->dumped_evtlog;
  994. if ((in_mem || in_dump) && dump_addr && (!sde_dbg_base.coredump_reading)) {
  995. while (sde_evtlog_dump_to_buffer(evtlog, dump_addr, SDE_EVTLOG_BUF_MAX,
  996. update_last_entry, true)) {
  997. dump_addr += SDE_EVTLOG_BUF_MAX;
  998. update_last_entry = false;
  999. }
  1000. }
  1001. if (in_dump && dump_addr && sde_dbg_base.coredump_reading) {
  1002. drm_printf(sde_dbg_base.sde_dbg_printer, "===================evtlog================\n");
  1003. for (i = 0; i < evtlog->log_size; i++) {
  1004. drm_printf(sde_dbg_base.sde_dbg_printer, "%s", dump_addr);
  1005. dump_addr += SDE_EVTLOG_BUF_MAX;
  1006. }
  1007. drm_printf(sde_dbg_base.sde_dbg_printer, "\n");
  1008. }
  1009. if (in_log) {
  1010. while (sde_evtlog_dump_to_buffer(evtlog, buf, sizeof(buf),
  1011. update_last_entry, false)) {
  1012. pr_info("%s\n", buf);
  1013. update_last_entry = false;
  1014. }
  1015. }
  1016. }
  1017. /**
  1018. * _sde_dump_array - dump array of register bases
  1019. * @do_panic: whether to trigger a panic after dumping
  1020. * @name: string indicating origin of dump
  1021. * @dump_secure: flag to indicate dumping in secure-session
  1022. * @dump_blk_mask: mask of all the hw blk-ids that has to be dumped
  1023. */
  1024. static void _sde_dump_array(bool do_panic, const char *name, bool dump_secure, u64 dump_blk_mask)
  1025. {
  1026. int rc;
  1027. ktime_t start, end;
  1028. u32 reg_dump_size;
  1029. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  1030. bool skip_power;
  1031. bool coredump_reading;
  1032. u32 in_dump;
  1033. mutex_lock(&dbg_base->mutex);
  1034. reg_dump_size = _sde_dbg_get_reg_dump_size();
  1035. if (!dbg_base->reg_dump_base)
  1036. dbg_base->reg_dump_base = kvzalloc(reg_dump_size, GFP_KERNEL);
  1037. dbg_base->reg_dump_addr = dbg_base->reg_dump_base;
  1038. /*
  1039. * sde power resources are expected to be enabled in this context and might
  1040. * result in deadlock if its called again.
  1041. */
  1042. skip_power = (dbg_base->dump_mode == SDE_DBG_DUMP_CLK_ENABLED_CTX);
  1043. if (sde_evtlog_is_enabled(dbg_base->evtlog, SDE_EVTLOG_ALWAYS))
  1044. sde_evtlog_dump_all(dbg_base->evtlog);
  1045. if (!skip_power) {
  1046. rc = pm_runtime_resume_and_get(dbg_base->dev);
  1047. if (rc < 0) {
  1048. pr_err("failed to enable power resource %d\n", rc);
  1049. return;
  1050. }
  1051. }
  1052. in_dump = (dbg_base->enable_dbgbus_dump & SDE_DBG_DUMP_IN_COREDUMP);
  1053. coredump_reading = sde_dbg_base.coredump_reading;
  1054. start = ktime_get();
  1055. _sde_dump_reg_mask(dump_blk_mask, dump_secure);
  1056. end = ktime_get();
  1057. dev_info(dbg_base->dev,
  1058. "ctx:%d, reg-dump logging time start_us:%llu, end_us:%llu , duration_us:%llu\n",
  1059. dbg_base->dump_mode, ktime_to_us(start), ktime_to_us(end),
  1060. ktime_us_delta(end, start));
  1061. start = ktime_get();
  1062. if (in_dump && coredump_reading)
  1063. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_sde ==============\n");
  1064. if (dump_blk_mask & SDE_DBG_SDE_DBGBUS)
  1065. _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_sde, dbg_base->enable_dbgbus_dump);
  1066. if (in_dump && coredump_reading)
  1067. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_lutdma ==============\n");
  1068. if (dump_blk_mask & SDE_DBG_LUTDMA_DBGBUS)
  1069. _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_lutdma, dbg_base->enable_dbgbus_dump);
  1070. if (in_dump && coredump_reading)
  1071. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_rsc ==============\n");
  1072. if (dump_blk_mask & SDE_DBG_RSC_DBGBUS)
  1073. _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_rsc, dbg_base->enable_dbgbus_dump);
  1074. if (in_dump && coredump_reading)
  1075. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_vbif_rt ==============\n");
  1076. if (dump_blk_mask & SDE_DBG_VBIF_RT_DBGBUS)
  1077. _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_vbif_rt, dbg_base->enable_dbgbus_dump);
  1078. if (in_dump && coredump_reading)
  1079. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_dsi ==============\n");
  1080. if (dump_blk_mask & SDE_DBG_DSI_DBGBUS)
  1081. _sde_dbg_dump_dsi_dbg_bus(&dbg_base->dbgbus_dsi, dbg_base->enable_dbgbus_dump);
  1082. if (in_dump && coredump_reading)
  1083. drm_printf(dbg_base->sde_dbg_printer, "============== dump dbgbus_dp ==============\n");
  1084. if (dump_blk_mask & SDE_DBG_DP_DBGBUS)
  1085. _sde_dbg_dump_sde_dbg_bus(&dbg_base->dbgbus_dp, dbg_base->enable_dbgbus_dump);
  1086. end = ktime_get();
  1087. dev_info(dbg_base->dev,
  1088. "debug-bus logging time start_us:%llu, end_us:%llu , duration_us:%llu\n",
  1089. ktime_to_us(start), ktime_to_us(end), ktime_us_delta(end, start));
  1090. if (!skip_power)
  1091. pm_runtime_put_sync(dbg_base->dev);
  1092. if (do_panic && dbg_base->panic_on_err && (!in_dump))
  1093. panic(name);
  1094. mutex_unlock(&dbg_base->mutex);
  1095. }
  1096. #ifdef CONFIG_DEV_COREDUMP
  1097. static ssize_t sde_devcoredump_read(char *buffer, loff_t offset,
  1098. size_t count, void *data, size_t datalen)
  1099. {
  1100. struct drm_print_iterator iter;
  1101. struct drm_printer p;
  1102. iter.data = buffer;
  1103. iter.offset = 0;
  1104. iter.start = offset;
  1105. iter.remain = count;
  1106. p = drm_coredump_printer(&iter);
  1107. drm_printf(&p, "---\n");
  1108. drm_printf(&p, "module: " KBUILD_MODNAME "\n");
  1109. drm_printf(&p, "sde devcoredump\n");
  1110. sde_dbg_base.sde_dbg_printer = &p;
  1111. sde_dbg_base.coredump_reading = true;
  1112. _sde_dump_array(false, "devcoredump", sde_dbg_base.dump_secure,
  1113. sde_dbg_base.dump_blk_mask);
  1114. return count - iter.remain;
  1115. }
  1116. static void sde_devcoredump_free(void *data)
  1117. {
  1118. if (sde_dbg_base.evtlog->dumped_evtlog) {
  1119. kvfree(sde_dbg_base.evtlog->dumped_evtlog);
  1120. sde_dbg_base.evtlog->dumped_evtlog = NULL;
  1121. }
  1122. sde_dbg_base.coredump_reading = false;
  1123. sde_dbg_base.coredump_pending = false;
  1124. }
  1125. #endif /* CONFIG_DEV_COREDUMP */
  1126. /**
  1127. * _sde_dump_work - deferred dump work function
  1128. * @work: work structure
  1129. */
  1130. static void _sde_dump_work(struct work_struct *work)
  1131. {
  1132. _sde_dump_array(sde_dbg_base.work_panic, "evtlog_workitem",
  1133. sde_dbg_base.dump_secure, sde_dbg_base.dump_blk_mask);
  1134. #ifdef CONFIG_DEV_COREDUMP
  1135. if (sde_dbg_base.enable_reg_dump & SDE_DBG_DUMP_IN_COREDUMP) {
  1136. dev_coredumpm(sde_dbg_base.dev, THIS_MODULE, &sde_dbg_base, 0, GFP_KERNEL,
  1137. sde_devcoredump_read, sde_devcoredump_free);
  1138. sde_dbg_base.coredump_pending = true;
  1139. }
  1140. #endif
  1141. }
  1142. void sde_dbg_dump(enum sde_dbg_dump_context dump_mode, const char *name, u64 dump_blk_mask, ...)
  1143. {
  1144. int i = 0;
  1145. bool do_panic = false;
  1146. bool dump_secure = false;
  1147. va_list args;
  1148. char *str = NULL;
  1149. if (!sde_evtlog_is_enabled(sde_dbg_base.evtlog, SDE_EVTLOG_ALWAYS))
  1150. return;
  1151. /*
  1152. * if dump work is pending
  1153. * if there is a coredump pending return immediately till dump
  1154. * if read by userspace or timeout happens
  1155. */
  1156. if (((dump_mode == SDE_DBG_DUMP_IRQ_CTX) && work_pending(&sde_dbg_base.dump_work)) ||
  1157. sde_dbg_base.coredump_pending) {
  1158. pr_debug("dump is pending , dump flag: %d \n", sde_dbg_base.enable_reg_dump);
  1159. return;
  1160. }
  1161. sde_dbg_base.dump_mode = dump_mode;
  1162. va_start(args, dump_blk_mask);
  1163. while ((str = va_arg(args, char*))) {
  1164. if (i++ >= SDE_EVTLOG_MAX_DATA) {
  1165. pr_err("could not parse all dump arguments\n");
  1166. break;
  1167. }
  1168. if (!strcmp(str, "panic"))
  1169. do_panic = true;
  1170. else if (!strcmp(str, "secure"))
  1171. dump_secure = true;
  1172. }
  1173. va_end(args);
  1174. #ifdef CONFIG_DEV_COREDUMP
  1175. /*
  1176. * if CONFIG_DEV_COREDUMP is defined put all the mode control in one flag
  1177. * to simplify the control logic of enable/disable devcoredump.
  1178. */
  1179. if (sde_dbg_base.enable_reg_dump != SDE_DBG_DEFAULT_DUMP_MODE) {
  1180. sde_dbg_base.evtlog->dump_mode = sde_dbg_base.enable_reg_dump;
  1181. sde_dbg_base.enable_dbgbus_dump = sde_dbg_base.enable_reg_dump;
  1182. }
  1183. #endif
  1184. if (dump_mode == SDE_DBG_DUMP_IRQ_CTX) {
  1185. /* schedule work to dump later */
  1186. sde_dbg_base.work_panic = do_panic;
  1187. sde_dbg_base.dump_blk_mask = dump_blk_mask;
  1188. schedule_work(&sde_dbg_base.dump_work);
  1189. } else {
  1190. _sde_dump_array(do_panic, name, dump_secure, dump_blk_mask);
  1191. #ifdef CONFIG_DEV_COREDUMP
  1192. if (sde_dbg_base.enable_reg_dump & SDE_DBG_DUMP_IN_COREDUMP) {
  1193. dev_coredumpm(sde_dbg_base.dev, THIS_MODULE, &sde_dbg_base, 0, GFP_KERNEL,
  1194. sde_devcoredump_read, sde_devcoredump_free);
  1195. sde_dbg_base.coredump_pending = true;
  1196. }
  1197. #endif
  1198. }
  1199. }
  1200. void sde_dbg_ctrl(const char *name, ...)
  1201. {
  1202. int i = 0;
  1203. va_list args;
  1204. char *blk_name = NULL;
  1205. /* no debugfs controlled events are enabled, just return */
  1206. if (!sde_dbg_base.debugfs_ctrl)
  1207. return;
  1208. va_start(args, name);
  1209. while ((blk_name = va_arg(args, char*))) {
  1210. if (i++ >= SDE_EVTLOG_MAX_DATA) {
  1211. pr_err("could not parse all dbg arguments\n");
  1212. break;
  1213. }
  1214. if (IS_ERR_OR_NULL(blk_name))
  1215. break;
  1216. if (!strcmp(blk_name, "stop_ftrace") &&
  1217. sde_dbg_base.debugfs_ctrl & DBG_CTRL_STOP_FTRACE) {
  1218. pr_debug("tracing off\n");
  1219. tracing_off();
  1220. }
  1221. if (!strcmp(blk_name, "panic_underrun") &&
  1222. sde_dbg_base.debugfs_ctrl & DBG_CTRL_PANIC_UNDERRUN) {
  1223. pr_err("panic underrun\n");
  1224. SDE_DBG_DUMP_WQ(SDE_DBG_BUILT_IN_ALL, "panic");
  1225. }
  1226. if (!strcmp(blk_name, "reset_hw_panic") &&
  1227. sde_dbg_base.debugfs_ctrl & DBG_CTRL_RESET_HW_PANIC) {
  1228. pr_debug("reset hw panic\n");
  1229. panic("reset_hw");
  1230. }
  1231. }
  1232. va_end(args);
  1233. }
  1234. #if IS_ENABLED(CONFIG_DEBUG_FS)
  1235. /*
  1236. * sde_dbg_debugfs_open - debugfs open handler for evtlog dump
  1237. * @inode: debugfs inode
  1238. * @file: file handle
  1239. */
  1240. static int sde_dbg_debugfs_open(struct inode *inode, struct file *file)
  1241. {
  1242. if (!inode || !file)
  1243. return -EINVAL;
  1244. /* non-seekable */
  1245. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1246. file->private_data = inode->i_private;
  1247. mutex_lock(&sde_dbg_base.mutex);
  1248. sde_dbg_base.cur_evt_index = 0;
  1249. sde_dbg_base.evtlog->first = (u32)atomic_add_return(0, &sde_dbg_base.evtlog->curr) + 1;
  1250. sde_dbg_base.evtlog->last =
  1251. sde_dbg_base.evtlog->first + SDE_EVTLOG_ENTRY;
  1252. mutex_unlock(&sde_dbg_base.mutex);
  1253. return 0;
  1254. }
  1255. /*
  1256. * sde_dbg_reg_base_open - debugfs open handler for reg base
  1257. * @inode: debugfs inode
  1258. * @file: file handle
  1259. */
  1260. static int sde_dbg_reg_base_open(struct inode *inode, struct file *file)
  1261. {
  1262. char base_name[64] = {0};
  1263. struct sde_dbg_reg_base *reg_base = NULL;
  1264. if (!inode || !file)
  1265. return -EINVAL;
  1266. snprintf(base_name, sizeof(base_name), "%s",
  1267. file->f_path.dentry->d_iname);
  1268. base_name[strlen(file->f_path.dentry->d_iname) - 4] = '\0';
  1269. reg_base = _sde_dump_get_blk_addr(base_name);
  1270. if (!reg_base) {
  1271. pr_err("error: unable to locate base %s\n",
  1272. base_name);
  1273. return -EINVAL;
  1274. }
  1275. /* non-seekable */
  1276. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1277. file->private_data = reg_base;
  1278. return 0;
  1279. }
  1280. /**
  1281. * sde_evtlog_dump_read - debugfs read handler for evtlog dump
  1282. * @file: file handler
  1283. * @buff: user buffer content for debugfs
  1284. * @count: size of user buffer
  1285. * @ppos: position offset of user buffer
  1286. */
  1287. static ssize_t sde_evtlog_dump_read(struct file *file, char __user *buff,
  1288. size_t count, loff_t *ppos)
  1289. {
  1290. ssize_t len = 0;
  1291. char evtlog_buf[SDE_EVTLOG_BUF_MAX];
  1292. if (!buff || !ppos)
  1293. return -EINVAL;
  1294. mutex_lock(&sde_dbg_base.mutex);
  1295. len = sde_evtlog_dump_to_buffer(sde_dbg_base.evtlog,
  1296. evtlog_buf, SDE_EVTLOG_BUF_MAX,
  1297. !sde_dbg_base.cur_evt_index, true);
  1298. sde_dbg_base.cur_evt_index++;
  1299. mutex_unlock(&sde_dbg_base.mutex);
  1300. if (len < 0 || len > count) {
  1301. pr_err("len is more than user buffer size\n");
  1302. return 0;
  1303. }
  1304. if (copy_to_user(buff, evtlog_buf, len))
  1305. return -EFAULT;
  1306. *ppos += len;
  1307. return len;
  1308. }
  1309. /**
  1310. * sde_evtlog_dump_write - debugfs write handler for evtlog dump
  1311. * @file: file handler
  1312. * @user_buf: user buffer content from debugfs
  1313. * @count: size of user buffer
  1314. * @ppos: position offset of user buffer
  1315. */
  1316. static ssize_t sde_evtlog_dump_write(struct file *file,
  1317. const char __user *user_buf, size_t count, loff_t *ppos)
  1318. {
  1319. _sde_dump_array(sde_dbg_base.panic_on_err, "dump_debugfs", false,
  1320. sde_dbg_base.dump_blk_mask);
  1321. return count;
  1322. }
  1323. static const struct file_operations sde_evtlog_fops = {
  1324. .open = sde_dbg_debugfs_open,
  1325. .read = sde_evtlog_dump_read,
  1326. .write = sde_evtlog_dump_write,
  1327. };
  1328. /**
  1329. * sde_dbg_ctrl_read - debugfs read handler for debug ctrl read
  1330. * @file: file handler
  1331. * @buff: user buffer content for debugfs
  1332. * @count: size of user buffer
  1333. * @ppos: position offset of user buffer
  1334. */
  1335. static ssize_t sde_dbg_ctrl_read(struct file *file, char __user *buff,
  1336. size_t count, loff_t *ppos)
  1337. {
  1338. ssize_t len = 0;
  1339. char buf[24] = {'\0'};
  1340. if (!buff || !ppos)
  1341. return -EINVAL;
  1342. if (*ppos)
  1343. return 0; /* the end */
  1344. len = snprintf(buf, sizeof(buf), "0x%x\n", sde_dbg_base.debugfs_ctrl);
  1345. pr_debug("%s: ctrl:0x%x len:0x%zx\n",
  1346. __func__, sde_dbg_base.debugfs_ctrl, len);
  1347. if (len < 0 || len >= sizeof(buf))
  1348. return 0;
  1349. if ((count < sizeof(buf)) || copy_to_user(buff, buf, len)) {
  1350. pr_err("error copying the buffer! count:0x%zx\n", count);
  1351. return -EFAULT;
  1352. }
  1353. *ppos += len; /* increase offset */
  1354. return len;
  1355. }
  1356. /**
  1357. * sde_dbg_ctrl_write - debugfs read handler for debug ctrl write
  1358. * @file: file handler
  1359. * @user_buf: user buffer content from debugfs
  1360. * @count: size of user buffer
  1361. * @ppos: position offset of user buffer
  1362. */
  1363. static ssize_t sde_dbg_ctrl_write(struct file *file,
  1364. const char __user *user_buf, size_t count, loff_t *ppos)
  1365. {
  1366. u32 dbg_ctrl = 0;
  1367. char buf[24];
  1368. if (!file) {
  1369. pr_err("DbgDbg: %s: error no file --\n", __func__);
  1370. return -EINVAL;
  1371. }
  1372. if (count >= sizeof(buf))
  1373. return -EFAULT;
  1374. if (copy_from_user(buf, user_buf, count))
  1375. return -EFAULT;
  1376. buf[count] = 0; /* end of string */
  1377. if (kstrtouint(buf, 0, &dbg_ctrl)) {
  1378. pr_err("%s: error in the number of bytes\n", __func__);
  1379. return -EFAULT;
  1380. }
  1381. pr_debug("dbg_ctrl_read:0x%x\n", dbg_ctrl);
  1382. sde_dbg_base.debugfs_ctrl = dbg_ctrl;
  1383. return count;
  1384. }
  1385. static const struct file_operations sde_dbg_ctrl_fops = {
  1386. .open = sde_dbg_debugfs_open,
  1387. .read = sde_dbg_ctrl_read,
  1388. .write = sde_dbg_ctrl_write,
  1389. };
  1390. static int sde_recovery_regdump_open(struct inode *inode, struct file *file)
  1391. {
  1392. if (!inode || !file)
  1393. return -EINVAL;
  1394. /* non-seekable */
  1395. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1396. file->private_data = inode->i_private;
  1397. /* initialize to start position */
  1398. sde_dbg_base.regbuf.rpos = 0;
  1399. sde_dbg_base.regbuf.cur_blk = NULL;
  1400. sde_dbg_base.regbuf.dump_done = false;
  1401. return 0;
  1402. }
  1403. static ssize_t _sde_dbg_dump_reg_rows(u32 reg_start,
  1404. void *start, int count, char *buf, int buflen)
  1405. {
  1406. int i;
  1407. int len = 0;
  1408. u32 *addr;
  1409. u32 reg_offset = 0;
  1410. int rows = min(count / DUMP_CLMN_COUNT, DUMP_MAX_LINES_PER_BLK);
  1411. if (!start || !buf) {
  1412. pr_err("invalid address for dump\n");
  1413. return len;
  1414. }
  1415. if (buflen < PAGE_SIZE) {
  1416. pr_err("buffer too small for dump\n");
  1417. return len;
  1418. }
  1419. for (i = 0; i < rows; i++) {
  1420. addr = start + (i * DUMP_CLMN_COUNT * sizeof(u32));
  1421. reg_offset = reg_start + (i * DUMP_CLMN_COUNT * sizeof(u32));
  1422. if (buflen < (len + DUMP_LINE_SIZE))
  1423. break;
  1424. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1425. "0x%.8X | %.8X %.8X %.8X %.8X\n",
  1426. reg_offset, addr[0], addr[1], addr[2], addr[3]);
  1427. }
  1428. return len;
  1429. }
  1430. static int _sde_dbg_recovery_dump_sub_blk(struct sde_dbg_reg_range *sub_blk,
  1431. char *buf, int buflen)
  1432. {
  1433. int count = 0;
  1434. int len = 0;
  1435. if (!sub_blk || (buflen < PAGE_SIZE)) {
  1436. pr_err("invalid params buflen:%d subblk valid:%d\n",
  1437. buflen, sub_blk != NULL);
  1438. return len;
  1439. }
  1440. count = (sub_blk->offset.end - sub_blk->offset.start) / (sizeof(u32));
  1441. if (count < DUMP_CLMN_COUNT) {
  1442. pr_err("invalid count for register dumps :%d\n", count);
  1443. return len;
  1444. }
  1445. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1446. "------------------------------------------\n");
  1447. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1448. "**** sub block [%s] - size:%d ****\n",
  1449. sub_blk->range_name, count);
  1450. len += _sde_dbg_dump_reg_rows(sub_blk->offset.start, sub_blk->reg_dump,
  1451. count, buf + len, buflen - len);
  1452. return len;
  1453. }
  1454. static int _sde_dbg_recovery_dump_reg_blk(struct sde_dbg_reg_base *blk,
  1455. char *buf, int buf_size, int *out_len)
  1456. {
  1457. int ret = 0;
  1458. int len = 0;
  1459. struct sde_dbg_reg_range *sub_blk;
  1460. if (buf_size < PAGE_SIZE) {
  1461. pr_err("buffer too small for dump\n");
  1462. return len;
  1463. }
  1464. if (!blk || !strlen(blk->name)) {
  1465. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1466. "Found one invalid block - skip dump\n");
  1467. *out_len = len;
  1468. return len;
  1469. }
  1470. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1471. "******************************************\n");
  1472. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1473. "==========================================\n");
  1474. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1475. "****** DUMP of %s block (0x%08x) ******\n",
  1476. blk->name, blk->phys_addr);
  1477. len += snprintf(buf + len, DUMP_LINE_SIZE,
  1478. "count:%ld max-off:0x%lx has_sub_blk:%d\n",
  1479. blk->cnt, blk->max_offset,
  1480. !list_empty(&blk->sub_range_list));
  1481. if (list_empty(&blk->sub_range_list)) {
  1482. len += _sde_dbg_dump_reg_rows(0, blk->reg_dump,
  1483. blk->max_offset / sizeof(u32), buf + len,
  1484. buf_size - len);
  1485. } else {
  1486. list_for_each_entry(sub_blk, &blk->sub_range_list, head)
  1487. len += _sde_dbg_recovery_dump_sub_blk(sub_blk,
  1488. buf + len, buf_size - len);
  1489. }
  1490. *out_len = len;
  1491. return ret;
  1492. }
  1493. static ssize_t sde_recovery_regdump_read(struct file *file, char __user *ubuf,
  1494. size_t count, loff_t *ppos)
  1495. {
  1496. ssize_t len = 0;
  1497. int usize = 0;
  1498. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  1499. struct sde_dbg_regbuf *rbuf = &dbg_base->regbuf;
  1500. mutex_lock(&sde_dbg_base.mutex);
  1501. if (!sde_dbg_base.hw_ownership) {
  1502. pr_debug("op not supported due to HW unavailablity\n");
  1503. len = -EOPNOTSUPP;
  1504. goto err;
  1505. }
  1506. if (!rbuf->dump_done && !rbuf->cur_blk) {
  1507. if (!rbuf->buf)
  1508. rbuf->buf = kvzalloc(DUMP_BUF_SIZE, GFP_KERNEL);
  1509. if (!rbuf->buf) {
  1510. len = -ENOMEM;
  1511. goto err;
  1512. }
  1513. rbuf->rpos = 0;
  1514. rbuf->len = 0;
  1515. rbuf->buf_size = DUMP_BUF_SIZE;
  1516. rbuf->cur_blk = list_first_entry(&dbg_base->reg_base_list,
  1517. struct sde_dbg_reg_base, reg_base_head);
  1518. if (rbuf->cur_blk)
  1519. _sde_dbg_recovery_dump_reg_blk(rbuf->cur_blk,
  1520. rbuf->buf,
  1521. rbuf->buf_size,
  1522. &rbuf->len);
  1523. pr_debug("dumping done for blk:%s len:%d\n", rbuf->cur_blk ?
  1524. rbuf->cur_blk->name : "unknown", rbuf->len);
  1525. } else if (rbuf->len == rbuf->rpos && rbuf->cur_blk) {
  1526. rbuf->rpos = 0;
  1527. rbuf->len = 0;
  1528. rbuf->buf_size = DUMP_BUF_SIZE;
  1529. if (rbuf->cur_blk == list_last_entry(&dbg_base->reg_base_list,
  1530. struct sde_dbg_reg_base, reg_base_head))
  1531. rbuf->cur_blk = NULL;
  1532. else
  1533. rbuf->cur_blk = list_next_entry(rbuf->cur_blk,
  1534. reg_base_head);
  1535. if (rbuf->cur_blk)
  1536. _sde_dbg_recovery_dump_reg_blk(rbuf->cur_blk,
  1537. rbuf->buf,
  1538. rbuf->buf_size,
  1539. &rbuf->len);
  1540. pr_debug("dumping done for blk:%s len:%d\n", rbuf->cur_blk ?
  1541. rbuf->cur_blk->name : "unknown", rbuf->len);
  1542. }
  1543. if ((rbuf->len - rbuf->rpos) > 0) {
  1544. usize = ((rbuf->len - rbuf->rpos) > count) ?
  1545. count : rbuf->len - rbuf->rpos;
  1546. if (copy_to_user(ubuf, rbuf->buf + rbuf->rpos, usize)) {
  1547. len = -EFAULT;
  1548. goto err;
  1549. }
  1550. len = usize;
  1551. rbuf->rpos += usize;
  1552. *ppos += usize;
  1553. }
  1554. if (!len && rbuf->buf)
  1555. rbuf->dump_done = true;
  1556. err:
  1557. mutex_unlock(&sde_dbg_base.mutex);
  1558. return len;
  1559. }
  1560. static const struct file_operations sde_recovery_reg_fops = {
  1561. .open = sde_recovery_regdump_open,
  1562. .read = sde_recovery_regdump_read,
  1563. };
  1564. #ifndef CONFIG_DEV_COREDUMP
  1565. static ssize_t sde_recovery_dbgbus_dump_read(struct file *file,
  1566. char __user *buff,
  1567. size_t count, loff_t *ppos)
  1568. {
  1569. ssize_t len = 0;
  1570. char log_buf[SDE_EVTLOG_BUF_MAX];
  1571. u32 *data;
  1572. struct sde_dbg_debug_bus_common *cmn = file->private_data;
  1573. u32 entry_size = DUMP_CLMN_COUNT;
  1574. u32 max_size = min_t(size_t, count, SDE_EVTLOG_BUF_MAX);
  1575. memset(log_buf, 0, sizeof(log_buf));
  1576. mutex_lock(&sde_dbg_base.mutex);
  1577. if (!sde_dbg_base.hw_ownership) {
  1578. pr_debug("op not supported due to HW unavailablity\n");
  1579. len = -EOPNOTSUPP;
  1580. goto dump_done;
  1581. }
  1582. if (!cmn->dumped_content || !cmn->entries_size)
  1583. goto dump_done;
  1584. if (cmn->content_idx < cmn->content_size) {
  1585. data = &cmn->dumped_content[cmn->content_idx];
  1586. len = scnprintf(log_buf, max_size,
  1587. "0x%.8lX | %.8X %.8X %.8X %.8X\n",
  1588. cmn->content_idx * sizeof(*data),
  1589. data[0], data[1], data[2], data[3]);
  1590. cmn->content_idx += entry_size;
  1591. if (copy_to_user(buff, log_buf, len)) {
  1592. len = -EFAULT;
  1593. goto dump_done;
  1594. }
  1595. *ppos += len;
  1596. }
  1597. dump_done:
  1598. mutex_unlock(&sde_dbg_base.mutex);
  1599. return len;
  1600. }
  1601. static int sde_recovery_dbgbus_dump_open(struct inode *inode, struct file *file)
  1602. {
  1603. if (!inode || !file)
  1604. return -EINVAL;
  1605. /* non-seekable */
  1606. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1607. file->private_data = (void *)&sde_dbg_base.dbgbus_sde.cmn;
  1608. mutex_lock(&sde_dbg_base.mutex);
  1609. sde_dbg_base.dbgbus_sde.cmn.content_idx = 0;
  1610. mutex_unlock(&sde_dbg_base.mutex);
  1611. return 0;
  1612. }
  1613. static const struct file_operations sde_recovery_dbgbus_fops = {
  1614. .open = sde_recovery_dbgbus_dump_open,
  1615. .read = sde_recovery_dbgbus_dump_read,
  1616. };
  1617. static int sde_recovery_vbif_dbgbus_dump_open(struct inode *inode,
  1618. struct file *file)
  1619. {
  1620. if (!inode || !file)
  1621. return -EINVAL;
  1622. /* non-seekable */
  1623. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1624. file->private_data = (void *)&sde_dbg_base.dbgbus_vbif_rt.cmn;
  1625. mutex_lock(&sde_dbg_base.mutex);
  1626. sde_dbg_base.dbgbus_vbif_rt.cmn.content_idx = 0;
  1627. mutex_unlock(&sde_dbg_base.mutex);
  1628. return 0;
  1629. }
  1630. static const struct file_operations sde_recovery_vbif_dbgbus_fops = {
  1631. .open = sde_recovery_vbif_dbgbus_dump_open,
  1632. .read = sde_recovery_dbgbus_dump_read,
  1633. };
  1634. static int sde_recovery_dsi_dbgbus_dump_open(struct inode *inode,
  1635. struct file *file)
  1636. {
  1637. if (!inode || !file)
  1638. return -EINVAL;
  1639. /* non-seekable */
  1640. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1641. file->private_data = (void *)&sde_dbg_base.dbgbus_dsi.cmn;
  1642. mutex_lock(&sde_dbg_base.mutex);
  1643. sde_dbg_base.dbgbus_dsi.cmn.content_idx = 0;
  1644. mutex_unlock(&sde_dbg_base.mutex);
  1645. return 0;
  1646. }
  1647. static const struct file_operations sde_recovery_dsi_dbgbus_fops = {
  1648. .open = sde_recovery_dsi_dbgbus_dump_open,
  1649. .read = sde_recovery_dbgbus_dump_read,
  1650. };
  1651. static int sde_recovery_rsc_dbgbus_dump_open(struct inode *inode,
  1652. struct file *file)
  1653. {
  1654. if (!inode || !file)
  1655. return -EINVAL;
  1656. /* non-seekable */
  1657. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1658. file->private_data = (void *)&sde_dbg_base.dbgbus_rsc.cmn;
  1659. mutex_lock(&sde_dbg_base.mutex);
  1660. sde_dbg_base.dbgbus_rsc.cmn.content_idx = 0;
  1661. mutex_unlock(&sde_dbg_base.mutex);
  1662. return 0;
  1663. }
  1664. static const struct file_operations sde_recovery_rsc_dbgbus_fops = {
  1665. .open = sde_recovery_rsc_dbgbus_dump_open,
  1666. .read = sde_recovery_dbgbus_dump_read,
  1667. };
  1668. static int sde_recovery_lutdma_dbgbus_dump_open(struct inode *inode,
  1669. struct file *file)
  1670. {
  1671. if (!inode || !file)
  1672. return -EINVAL;
  1673. /* non-seekable */
  1674. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1675. file->private_data = (void *)&sde_dbg_base.dbgbus_lutdma.cmn;
  1676. mutex_lock(&sde_dbg_base.mutex);
  1677. sde_dbg_base.dbgbus_lutdma.cmn.content_idx = 0;
  1678. mutex_unlock(&sde_dbg_base.mutex);
  1679. return 0;
  1680. }
  1681. static const struct file_operations sde_recovery_lutdma_dbgbus_fops = {
  1682. .open = sde_recovery_lutdma_dbgbus_dump_open,
  1683. .read = sde_recovery_dbgbus_dump_read,
  1684. };
  1685. static int sde_recovery_dp_dbgbus_dump_open(struct inode *inode,
  1686. struct file *file)
  1687. {
  1688. if (!inode || !file)
  1689. return -EINVAL;
  1690. /* non-seekable */
  1691. file->f_mode &= ~(FMODE_LSEEK | FMODE_PREAD | FMODE_PWRITE);
  1692. file->private_data = (void *)&sde_dbg_base.dbgbus_dp.cmn;
  1693. mutex_lock(&sde_dbg_base.mutex);
  1694. sde_dbg_base.dbgbus_dp.cmn.content_idx = 0;
  1695. mutex_unlock(&sde_dbg_base.mutex);
  1696. return 0;
  1697. }
  1698. static const struct file_operations sde_recovery_dp_dbgbus_fops = {
  1699. .open = sde_recovery_dp_dbgbus_dump_open,
  1700. .read = sde_recovery_dbgbus_dump_read,
  1701. };
  1702. #endif
  1703. /**
  1704. * sde_dbg_reg_base_release - release allocated reg dump file private data
  1705. * @inode: debugfs inode
  1706. * @file: file handle
  1707. * @Return: 0 on success
  1708. */
  1709. static int sde_dbg_reg_base_release(struct inode *inode, struct file *file)
  1710. {
  1711. struct sde_dbg_reg_base *dbg;
  1712. if (!file)
  1713. return -EINVAL;
  1714. dbg = file->private_data;
  1715. if (!dbg)
  1716. return -ENODEV;
  1717. mutex_lock(&sde_dbg_base.mutex);
  1718. if (dbg && dbg->buf) {
  1719. kfree(dbg->buf);
  1720. dbg->buf_len = 0;
  1721. dbg->buf = NULL;
  1722. }
  1723. mutex_unlock(&sde_dbg_base.mutex);
  1724. return 0;
  1725. }
  1726. /**
  1727. * sde_dbg_reg_base_is_valid_range - verify if requested memory range is valid
  1728. * @off: address offset in bytes
  1729. * @cnt: memory size in bytes
  1730. * Return: true if valid; false otherwise
  1731. */
  1732. static bool sde_dbg_reg_base_is_valid_range(
  1733. struct sde_dbg_reg_base *base,
  1734. u32 off, u32 cnt)
  1735. {
  1736. struct sde_dbg_reg_range *node;
  1737. pr_debug("check offset=0x%x cnt=0x%x\n", off, cnt);
  1738. list_for_each_entry(node, &base->sub_range_list, head) {
  1739. pr_debug("%s: start=0x%x end=0x%x\n", node->range_name,
  1740. node->offset.start, node->offset.end);
  1741. if (node->offset.start <= off
  1742. && off <= node->offset.end
  1743. && off + cnt <= node->offset.end) {
  1744. pr_debug("valid range requested\n");
  1745. return true;
  1746. }
  1747. }
  1748. pr_err("invalid range requested\n");
  1749. return false;
  1750. }
  1751. /**
  1752. * sde_dbg_reg_base_offset_write - set new offset and len to debugfs reg base
  1753. * @file: file handler
  1754. * @user_buf: user buffer content from debugfs
  1755. * @count: size of user buffer
  1756. * @ppos: position offset of user buffer
  1757. */
  1758. static ssize_t sde_dbg_reg_base_offset_write(struct file *file,
  1759. const char __user *user_buf, size_t count, loff_t *ppos)
  1760. {
  1761. struct sde_dbg_reg_base *dbg;
  1762. u32 off = 0;
  1763. u32 cnt = DEFAULT_BASE_REG_CNT;
  1764. char buf[24];
  1765. int rc;
  1766. if (!file)
  1767. return -EINVAL;
  1768. dbg = file->private_data;
  1769. if (!dbg)
  1770. return -ENODEV;
  1771. if (count >= sizeof(buf))
  1772. return -EFAULT;
  1773. if (copy_from_user(buf, user_buf, count))
  1774. return -EFAULT;
  1775. buf[count] = 0; /* end of string */
  1776. if (sscanf(buf, "%5x %x", &off, &cnt) != 2)
  1777. return -EFAULT;
  1778. if (off > dbg->max_offset)
  1779. return -EINVAL;
  1780. if (off % sizeof(u32))
  1781. return -EINVAL;
  1782. if (cnt > (dbg->max_offset - off))
  1783. cnt = dbg->max_offset - off;
  1784. if (cnt == 0)
  1785. return -EINVAL;
  1786. if (!list_empty(&dbg->sub_range_list)) {
  1787. rc = sde_dbg_reg_base_is_valid_range(dbg, off, cnt);
  1788. if (!rc)
  1789. return -EINVAL;
  1790. }
  1791. mutex_lock(&sde_dbg_base.mutex);
  1792. dbg->off = off;
  1793. dbg->cnt = cnt;
  1794. mutex_unlock(&sde_dbg_base.mutex);
  1795. pr_debug("offset=%x cnt=%x\n", off, cnt);
  1796. return count;
  1797. }
  1798. /**
  1799. * sde_dbg_reg_base_offset_read - read current offset and len of register base
  1800. * @file: file handler
  1801. * @user_buf: user buffer content from debugfs
  1802. * @count: size of user buffer
  1803. * @ppos: position offset of user buffer
  1804. */
  1805. static ssize_t sde_dbg_reg_base_offset_read(struct file *file,
  1806. char __user *buff, size_t count, loff_t *ppos)
  1807. {
  1808. struct sde_dbg_reg_base *dbg;
  1809. int len = 0;
  1810. char buf[24] = {'\0'};
  1811. if (!file)
  1812. return -EINVAL;
  1813. dbg = file->private_data;
  1814. if (!dbg)
  1815. return -ENODEV;
  1816. if (!ppos)
  1817. return -EINVAL;
  1818. if (*ppos)
  1819. return 0; /* the end */
  1820. mutex_lock(&sde_dbg_base.mutex);
  1821. if (dbg->off % sizeof(u32)) {
  1822. mutex_unlock(&sde_dbg_base.mutex);
  1823. return -EFAULT;
  1824. }
  1825. len = snprintf(buf, sizeof(buf), "0x%08zx %zx\n", dbg->off, dbg->cnt);
  1826. if (len < 0 || len >= sizeof(buf)) {
  1827. mutex_unlock(&sde_dbg_base.mutex);
  1828. return 0;
  1829. }
  1830. if ((count < sizeof(buf)) || copy_to_user(buff, buf, len)) {
  1831. mutex_unlock(&sde_dbg_base.mutex);
  1832. return -EFAULT;
  1833. }
  1834. *ppos += len; /* increase offset */
  1835. mutex_unlock(&sde_dbg_base.mutex);
  1836. return len;
  1837. }
  1838. #if IS_ENABLED(CONFIG_DYNAMIC_DEBUG)
  1839. /**
  1840. * sde_dbg_reg_base_reg_write - write to reg base hw at offset a given value
  1841. * @file: file handler
  1842. * @user_buf: user buffer content from debugfs
  1843. * @count: size of user buffer
  1844. * @ppos: position offset of user buffer
  1845. */
  1846. static ssize_t sde_dbg_reg_base_reg_write(struct file *file,
  1847. const char __user *user_buf, size_t count, loff_t *ppos)
  1848. {
  1849. struct sde_dbg_reg_base *dbg;
  1850. size_t off;
  1851. u32 data, cnt;
  1852. char buf[24];
  1853. int rc;
  1854. if (!file)
  1855. return -EINVAL;
  1856. dbg = file->private_data;
  1857. if (!dbg)
  1858. return -ENODEV;
  1859. if (count >= sizeof(buf))
  1860. return -EFAULT;
  1861. if (copy_from_user(buf, user_buf, count))
  1862. return -EFAULT;
  1863. buf[count] = 0; /* end of string */
  1864. cnt = sscanf(buf, "%zx %x", &off, &data);
  1865. if (cnt < 2)
  1866. return -EFAULT;
  1867. if (off % sizeof(u32))
  1868. return -EFAULT;
  1869. mutex_lock(&sde_dbg_base.mutex);
  1870. if (!sde_dbg_base.hw_ownership) {
  1871. pr_debug("op not supported due to hw unavailablity\n");
  1872. count = -EOPNOTSUPP;
  1873. goto end;
  1874. }
  1875. if (off >= dbg->max_offset) {
  1876. count = -EFAULT;
  1877. goto end;
  1878. }
  1879. if (!list_empty(&dbg->sub_range_list)) {
  1880. rc = sde_dbg_reg_base_is_valid_range(dbg, off, cnt);
  1881. if (!rc) {
  1882. count = -EINVAL;
  1883. goto end;
  1884. }
  1885. }
  1886. rc = pm_runtime_resume_and_get(sde_dbg_base.dev);
  1887. if (rc < 0) {
  1888. pr_err("failed to enable power resource %d\n", rc);
  1889. count = rc;
  1890. goto end;
  1891. }
  1892. writel_relaxed(data, dbg->base + off);
  1893. pm_runtime_put_sync(sde_dbg_base.dev);
  1894. pr_debug("addr=%zx data=%x\n", off, data);
  1895. end:
  1896. mutex_unlock(&sde_dbg_base.mutex);
  1897. return count;
  1898. }
  1899. #endif /* CONFIG_DYNAMIC_DEBUG */
  1900. /**
  1901. * sde_dbg_reg_base_reg_read - read len from reg base hw at current offset
  1902. * @file: file handler
  1903. * @user_buf: user buffer content from debugfs
  1904. * @count: size of user buffer
  1905. * @ppos: position offset of user buffer
  1906. */
  1907. static ssize_t sde_dbg_reg_base_reg_read(struct file *file,
  1908. char __user *user_buf, size_t count, loff_t *ppos)
  1909. {
  1910. struct sde_dbg_reg_base *dbg;
  1911. size_t len;
  1912. int rc;
  1913. if (!file)
  1914. return -EINVAL;
  1915. dbg = file->private_data;
  1916. if (!dbg) {
  1917. pr_err("invalid handle\n");
  1918. return -ENODEV;
  1919. }
  1920. if (!ppos)
  1921. return -EINVAL;
  1922. mutex_lock(&sde_dbg_base.mutex);
  1923. if (!sde_dbg_base.hw_ownership) {
  1924. pr_debug("op not supported due to hw unavailablity\n");
  1925. len = -EOPNOTSUPP;
  1926. goto end;
  1927. }
  1928. if (!dbg->buf) {
  1929. char dump_buf[64];
  1930. char *ptr;
  1931. int cnt, tot;
  1932. dbg->buf_len = sizeof(dump_buf) *
  1933. DIV_ROUND_UP(dbg->cnt, ROW_BYTES);
  1934. dbg->buf = kzalloc(dbg->buf_len, GFP_KERNEL);
  1935. if (!dbg->buf) {
  1936. len = -ENOMEM;
  1937. goto end;
  1938. }
  1939. if (dbg->off % sizeof(u32)) {
  1940. len = -EFAULT;
  1941. goto end;
  1942. }
  1943. ptr = dbg->base + dbg->off;
  1944. tot = 0;
  1945. rc = pm_runtime_resume_and_get(sde_dbg_base.dev);
  1946. if (rc < 0) {
  1947. pr_err("failed to enable power resource %d\n", rc);
  1948. len = rc;
  1949. goto end;
  1950. }
  1951. for (cnt = dbg->cnt; cnt > 0; cnt -= ROW_BYTES) {
  1952. hex_dump_to_buffer(ptr, min(cnt, ROW_BYTES),
  1953. ROW_BYTES, GROUP_BYTES, dump_buf,
  1954. sizeof(dump_buf), false);
  1955. len = scnprintf(dbg->buf + tot, dbg->buf_len - tot,
  1956. "0x%08x: %s\n",
  1957. ((int) (unsigned long) ptr) -
  1958. ((int) (unsigned long) dbg->base),
  1959. dump_buf);
  1960. ptr += ROW_BYTES;
  1961. tot += len;
  1962. if (tot >= dbg->buf_len)
  1963. break;
  1964. }
  1965. pm_runtime_put_sync(sde_dbg_base.dev);
  1966. dbg->buf_len = tot;
  1967. }
  1968. if (*ppos >= dbg->buf_len) {
  1969. len = 0; /* done reading */
  1970. goto end;
  1971. }
  1972. len = min(count, dbg->buf_len - (size_t) *ppos);
  1973. if (copy_to_user(user_buf, dbg->buf + *ppos, len)) {
  1974. pr_err("failed to copy to user\n");
  1975. len = -EFAULT;
  1976. goto end;
  1977. }
  1978. *ppos += len; /* increase offset */
  1979. end:
  1980. mutex_unlock(&sde_dbg_base.mutex);
  1981. return len;
  1982. }
  1983. static const struct file_operations sde_off_fops = {
  1984. .open = sde_dbg_reg_base_open,
  1985. .release = sde_dbg_reg_base_release,
  1986. .read = sde_dbg_reg_base_offset_read,
  1987. .write = sde_dbg_reg_base_offset_write,
  1988. };
  1989. static const struct file_operations sde_reg_fops = {
  1990. .open = sde_dbg_reg_base_open,
  1991. .release = sde_dbg_reg_base_release,
  1992. .read = sde_dbg_reg_base_reg_read,
  1993. #ifdef CONFIG_DYNAMIC_DEBUG
  1994. .write = sde_dbg_reg_base_reg_write,
  1995. #endif
  1996. };
  1997. int sde_dbg_debugfs_register(struct device *dev)
  1998. {
  1999. static struct sde_dbg_base *dbg = &sde_dbg_base;
  2000. struct sde_dbg_reg_base *blk_base;
  2001. char debug_name[80] = "";
  2002. struct dentry *debugfs_root = NULL;
  2003. struct platform_device *pdev = to_platform_device(dev);
  2004. struct drm_device *ddev = platform_get_drvdata(pdev);
  2005. struct msm_drm_private *priv = NULL;
  2006. if (!ddev || !ddev->dev_private) {
  2007. pr_err("Invalid drm device node\n");
  2008. return -EINVAL;
  2009. }
  2010. priv = ddev->dev_private;
  2011. debugfs_root = debugfs_create_dir("debug", ddev->primary->debugfs_root);
  2012. if (IS_ERR_OR_NULL(debugfs_root)) {
  2013. pr_err("debugfs_root create_dir fail, error %ld\n", PTR_ERR(debugfs_root));
  2014. priv->debug_root = NULL;
  2015. return -EINVAL;
  2016. }
  2017. priv->debug_root = debugfs_root;
  2018. debugfs_create_file("dbg_ctrl", 0600, debugfs_root, NULL, &sde_dbg_ctrl_fops);
  2019. debugfs_create_file("dump", 0600, debugfs_root, NULL, &sde_evtlog_fops);
  2020. debugfs_create_file("recovery_reg", 0400, debugfs_root, NULL, &sde_recovery_reg_fops);
  2021. debugfs_create_u32("enable", 0600, debugfs_root, &(sde_dbg_base.evtlog->enable));
  2022. debugfs_create_u32("panic", 0600, debugfs_root, &sde_dbg_base.panic_on_err);
  2023. debugfs_create_u32("reg_dump", 0600, debugfs_root, &sde_dbg_base.enable_reg_dump);
  2024. debugfs_create_u64("reg_dump_blk_mask", 0600, debugfs_root, &sde_dbg_base.dump_blk_mask);
  2025. #ifndef CONFIG_DEV_COREDUMP
  2026. debugfs_create_u32("evtlog_dump", 0600, debugfs_root, &(sde_dbg_base.evtlog->dump_mode));
  2027. debugfs_create_u32("dbgbus_dump", 0600, debugfs_root, &sde_dbg_base.enable_dbgbus_dump);
  2028. if (dbg->dbgbus_sde.entries)
  2029. debugfs_create_file("recovery_dbgbus", 0400, debugfs_root, NULL,
  2030. &sde_recovery_dbgbus_fops);
  2031. if (dbg->dbgbus_vbif_rt.entries)
  2032. debugfs_create_file("recovery_vbif_dbgbus", 0400, debugfs_root,
  2033. NULL, &sde_recovery_vbif_dbgbus_fops);
  2034. if (dbg->dbgbus_dsi.entries)
  2035. debugfs_create_file("recovery_dsi_dbgbus", 0400, debugfs_root,
  2036. NULL, &sde_recovery_dsi_dbgbus_fops);
  2037. if (dbg->dbgbus_rsc.entries)
  2038. debugfs_create_file("recovery_rsc_dbgbus", 0400, debugfs_root,
  2039. NULL, &sde_recovery_rsc_dbgbus_fops);
  2040. if (dbg->dbgbus_lutdma.entries)
  2041. debugfs_create_file("recovery_lutdma_dbgbus", 0400, debugfs_root,
  2042. NULL, &sde_recovery_lutdma_dbgbus_fops);
  2043. if (dbg->dbgbus_dp.entries)
  2044. debugfs_create_file("recovery_dp_dbgbus", 0400, debugfs_root,
  2045. NULL, &sde_recovery_dp_dbgbus_fops);
  2046. #endif
  2047. list_for_each_entry(blk_base, &dbg->reg_base_list, reg_base_head) {
  2048. snprintf(debug_name, sizeof(debug_name), "%s_off", blk_base->name);
  2049. debugfs_create_file(debug_name, 0600, debugfs_root, blk_base, &sde_off_fops);
  2050. snprintf(debug_name, sizeof(debug_name), "%s_reg", blk_base->name);
  2051. debugfs_create_file(debug_name, 0400, debugfs_root, blk_base, &sde_reg_fops);
  2052. }
  2053. return 0;
  2054. }
  2055. #else
  2056. int sde_dbg_debugfs_register(struct device *dev)
  2057. {
  2058. return 0;
  2059. }
  2060. #endif /* CONFIG_DEBUG_FS */
  2061. static void _sde_dbg_debugfs_destroy(void)
  2062. {
  2063. }
  2064. void sde_dbg_init_dbg_buses(u32 hw_rev)
  2065. {
  2066. static struct sde_dbg_base *dbg = &sde_dbg_base;
  2067. memset(&dbg->dbgbus_sde, 0, sizeof(dbg->dbgbus_sde));
  2068. memset(&dbg->dbgbus_vbif_rt, 0, sizeof(dbg->dbgbus_vbif_rt));
  2069. memset(&dbg->dbgbus_dsi, 0, sizeof(dbg->dbgbus_dsi));
  2070. memset(&dbg->dbgbus_rsc, 0, sizeof(dbg->dbgbus_rsc));
  2071. memset(&dbg->dbgbus_dp, 0, sizeof(dbg->dbgbus_dp));
  2072. dbg->dbgbus_sde.entries = dbg_bus_sde;
  2073. dbg->dbgbus_sde.cmn.entries_size = ARRAY_SIZE(dbg_bus_sde);
  2074. dbg->dbgbus_sde.limited_entries = dbg_bus_sde_limited;
  2075. dbg->dbgbus_sde.cmn.limited_entries_size = ARRAY_SIZE(dbg_bus_sde_limited);
  2076. dbg->dbgbus_sde.cmn.name = DBGBUS_NAME_SDE;
  2077. dbg->dbgbus_sde.cmn.blk_id = SDE_DBG_SDE_DBGBUS;
  2078. dbg->dbgbus_sde.read_tp = _sde_dbg_sde_read_test_point;
  2079. dbg->dbgbus_sde.clear_tp = _sde_dbg_sde_clear_test_point;
  2080. dbg->dbgbus_vbif_rt.entries = vbif_dbg_bus;
  2081. dbg->dbgbus_vbif_rt.cmn.entries_size = ARRAY_SIZE(vbif_dbg_bus);
  2082. dbg->dbgbus_vbif_rt.limited_entries = vbif_dbg_bus_limited;
  2083. dbg->dbgbus_vbif_rt.cmn.limited_entries_size = ARRAY_SIZE(vbif_dbg_bus_limited);
  2084. dbg->dbgbus_vbif_rt.cmn.name = DBGBUS_NAME_VBIF_RT;
  2085. dbg->dbgbus_vbif_rt.cmn.blk_id = SDE_DBG_VBIF_RT_DBGBUS;
  2086. dbg->dbgbus_vbif_rt.read_tp = _sde_dbg_vbif_read_test_point;
  2087. dbg->dbgbus_vbif_rt.clear_tp = _sde_dbg_vbif_clear_test_point;
  2088. dbg->dbgbus_vbif_rt.disable_block = _sde_dbg_vbif_disable_block;
  2089. dbg->dbgbus_dsi.entries = dsi_dbg_bus;
  2090. dbg->dbgbus_dsi.cmn.entries_size = ARRAY_SIZE(dsi_dbg_bus);
  2091. dbg->dbgbus_dsi.cmn.name = DBGBUS_NAME_DSI;
  2092. dbg->dbgbus_dsi.cmn.blk_id = SDE_DBG_DSI_DBGBUS;
  2093. dbg->dbgbus_dsi.read_tp = _sde_dbg_dsi_read_test_point;
  2094. dbg->dbgbus_dsi.clear_tp = _sde_dbg_cmn_clear_test_point;
  2095. dbg->dbgbus_rsc.entries = rsc_dbg_bus;
  2096. dbg->dbgbus_rsc.cmn.entries_size = ARRAY_SIZE(rsc_dbg_bus);
  2097. dbg->dbgbus_rsc.cmn.name = DBGBUS_NAME_RSC;
  2098. dbg->dbgbus_rsc.cmn.blk_id = SDE_DBG_RSC_DBGBUS;
  2099. dbg->dbgbus_rsc.read_tp = _sde_dbg_rsc_read_test_point;
  2100. dbg->dbgbus_rsc.clear_tp = _sde_dbg_cmn_clear_test_point;
  2101. dbg->dbgbus_dp.entries = dp_dbg_bus;
  2102. dbg->dbgbus_dp.cmn.entries_size = ARRAY_SIZE(dp_dbg_bus);
  2103. dbg->dbgbus_dp.cmn.name = DBGBUS_NAME_DP;
  2104. dbg->dbgbus_dp.cmn.blk_id = SDE_DBG_DP_DBGBUS;
  2105. dbg->dbgbus_dp.read_tp = _sde_dbg_dp_read_test_point;
  2106. dbg->dbgbus_dp.clear_tp = _sde_dbg_cmn_clear_test_point;
  2107. dbg->dbgbus_lutdma.entries = dbg_bus_lutdma;
  2108. dbg->dbgbus_lutdma.cmn.name = DBGBUS_NAME_LUTDMA;
  2109. dbg->dbgbus_lutdma.cmn.blk_id = SDE_DBG_LUTDMA_DBGBUS;
  2110. dbg->dbgbus_lutdma.cmn.entries_size = ARRAY_SIZE(dbg_bus_lutdma);
  2111. dbg->dbgbus_lutdma.read_tp = _sde_dbg_lutdma_read_test_point;
  2112. dbg->dbgbus_lutdma.clear_tp = _sde_dbg_cmn_clear_test_point;
  2113. }
  2114. int sde_dbg_init(struct device *dev)
  2115. {
  2116. if (!dev) {
  2117. pr_err("invalid params\n");
  2118. return -EINVAL;
  2119. }
  2120. mutex_init(&sde_dbg_base.mutex);
  2121. INIT_LIST_HEAD(&sde_dbg_base.reg_base_list);
  2122. sde_dbg_base.dev = dev;
  2123. sde_dbg_base.evtlog = sde_evtlog_init();
  2124. if (IS_ERR_OR_NULL(sde_dbg_base.evtlog))
  2125. return PTR_ERR(sde_dbg_base.evtlog);
  2126. sde_dbg_base_evtlog = sde_dbg_base.evtlog;
  2127. sde_dbg_base.reglog = sde_reglog_init();
  2128. if (IS_ERR_OR_NULL(sde_dbg_base.reglog))
  2129. return PTR_ERR(sde_dbg_base.reglog);
  2130. sde_dbg_base_reglog = sde_dbg_base.reglog;
  2131. INIT_WORK(&sde_dbg_base.dump_work, _sde_dump_work);
  2132. sde_dbg_base.work_panic = false;
  2133. sde_dbg_base.coredump_reading = false;
  2134. sde_dbg_base.panic_on_err = DEFAULT_PANIC;
  2135. sde_dbg_base.enable_reg_dump = SDE_DBG_DEFAULT_DUMP_MODE;
  2136. sde_dbg_base.enable_dbgbus_dump = SDE_DBG_DEFAULT_DUMP_MODE;
  2137. sde_dbg_base.dump_blk_mask = SDE_DBG_BUILT_IN_ALL;
  2138. memset(&sde_dbg_base.regbuf, 0, sizeof(sde_dbg_base.regbuf));
  2139. sde_register_md_panic_notifer();
  2140. pr_info("evtlog_status: enable:%d, panic:%d, dump:%d\n",
  2141. sde_dbg_base.evtlog->enable, sde_dbg_base.panic_on_err,
  2142. sde_dbg_base.enable_reg_dump);
  2143. return 0;
  2144. }
  2145. static void sde_dbg_reg_base_destroy(void)
  2146. {
  2147. struct sde_dbg_reg_range *range_node, *range_tmp;
  2148. struct sde_dbg_reg_base *blk_base, *blk_tmp;
  2149. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  2150. if (!dbg_base)
  2151. return;
  2152. list_for_each_entry_safe(blk_base, blk_tmp, &dbg_base->reg_base_list,
  2153. reg_base_head) {
  2154. list_for_each_entry_safe(range_node, range_tmp,
  2155. &blk_base->sub_range_list, head) {
  2156. list_del(&range_node->head);
  2157. kfree(range_node);
  2158. }
  2159. list_del(&blk_base->reg_base_head);
  2160. kfree(blk_base);
  2161. }
  2162. kvfree(dbg_base->reg_dump_base);
  2163. }
  2164. static void sde_dbg_dsi_ctrl_destroy(void)
  2165. {
  2166. struct sde_dbg_dsi_ctrl_list_entry *entry, *tmp;
  2167. mutex_lock(&sde_dbg_dsi_mutex);
  2168. list_for_each_entry_safe(entry, tmp, &sde_dbg_dsi_list, list) {
  2169. list_del(&entry->list);
  2170. kfree(entry);
  2171. }
  2172. mutex_unlock(&sde_dbg_dsi_mutex);
  2173. }
  2174. static void sde_dbg_buses_destroy(void)
  2175. {
  2176. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  2177. kvfree(dbg_base->dbgbus_sde.cmn.dumped_content);
  2178. kvfree(dbg_base->dbgbus_vbif_rt.cmn.dumped_content);
  2179. kvfree(dbg_base->dbgbus_dsi.cmn.dumped_content);
  2180. kvfree(dbg_base->dbgbus_lutdma.cmn.dumped_content);
  2181. kvfree(dbg_base->dbgbus_rsc.cmn.dumped_content);
  2182. kvfree(dbg_base->dbgbus_dp.cmn.dumped_content);
  2183. }
  2184. /**
  2185. * sde_dbg_destroy - destroy sde debug facilities
  2186. */
  2187. void sde_dbg_destroy(void)
  2188. {
  2189. kvfree(sde_dbg_base.regbuf.buf);
  2190. memset(&sde_dbg_base.regbuf, 0, sizeof(sde_dbg_base.regbuf));
  2191. _sde_dbg_debugfs_destroy();
  2192. sde_dbg_base_evtlog = NULL;
  2193. sde_evtlog_destroy(sde_dbg_base.evtlog);
  2194. sde_dbg_base.evtlog = NULL;
  2195. sde_reglog_destroy(sde_dbg_base.reglog);
  2196. sde_dbg_base.reglog = NULL;
  2197. sde_dbg_reg_base_destroy();
  2198. sde_dbg_dsi_ctrl_destroy();
  2199. sde_dbg_buses_destroy();
  2200. mutex_destroy(&sde_dbg_base.mutex);
  2201. }
  2202. int sde_dbg_dsi_ctrl_register(void __iomem *base, const char *name)
  2203. {
  2204. struct sde_dbg_dsi_ctrl_list_entry *entry;
  2205. entry = kzalloc(sizeof(*entry), GFP_KERNEL);
  2206. if (!entry)
  2207. return -ENOMEM;
  2208. entry->name = name;
  2209. entry->base = base;
  2210. mutex_lock(&sde_dbg_dsi_mutex);
  2211. list_add_tail(&entry->list, &sde_dbg_dsi_list);
  2212. mutex_unlock(&sde_dbg_dsi_mutex);
  2213. pr_debug("registered DSI CTRL %s for debugbus support\n", entry->name);
  2214. return 0;
  2215. }
  2216. int sde_dbg_reg_register_base(const char *name, void __iomem *base, size_t max_offset,
  2217. unsigned long phys_addr, u64 blk_id)
  2218. {
  2219. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  2220. struct sde_dbg_reg_base *reg_base;
  2221. if (!name || !strlen(name)) {
  2222. pr_err("no debug name provided\n");
  2223. return -EINVAL;
  2224. }
  2225. reg_base = kzalloc(sizeof(*reg_base), GFP_KERNEL);
  2226. if (!reg_base)
  2227. return -ENOMEM;
  2228. strlcpy(reg_base->name, name, sizeof(reg_base->name));
  2229. reg_base->base = base;
  2230. reg_base->phys_addr = phys_addr;
  2231. reg_base->max_offset = max_offset;
  2232. reg_base->off = 0;
  2233. reg_base->cnt = DEFAULT_BASE_REG_CNT;
  2234. reg_base->reg_dump = NULL;
  2235. reg_base->blk_id = blk_id;
  2236. /* Initialize list to make sure check for null list will be valid */
  2237. INIT_LIST_HEAD(&reg_base->sub_range_list);
  2238. pr_debug("%s base: %pK max_offset 0x%zX\n", reg_base->name,
  2239. reg_base->base, reg_base->max_offset);
  2240. list_add(&reg_base->reg_base_head, &dbg_base->reg_base_list);
  2241. return 0;
  2242. }
  2243. int sde_dbg_reg_register_cb(const char *name, void (*cb)(void *), void *ptr)
  2244. {
  2245. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  2246. struct sde_dbg_reg_base *reg_base;
  2247. if (!name || !strlen(name)) {
  2248. pr_err("no debug name provided\n");
  2249. return -EINVAL;
  2250. }
  2251. reg_base = kzalloc(sizeof(*reg_base), GFP_KERNEL);
  2252. if (!reg_base)
  2253. return -ENOMEM;
  2254. strlcpy(reg_base->name, name, sizeof(reg_base->name));
  2255. reg_base->base = NULL;
  2256. reg_base->max_offset = 0;
  2257. reg_base->off = 0;
  2258. reg_base->cnt = DEFAULT_BASE_REG_CNT;
  2259. reg_base->reg_dump = NULL;
  2260. reg_base->cb = cb;
  2261. reg_base->cb_ptr = ptr;
  2262. /* Initialize list to make sure check for null list will be valid */
  2263. INIT_LIST_HEAD(&reg_base->sub_range_list);
  2264. pr_debug("%s cb: %pK cb_ptr: %pK\n", reg_base->name,
  2265. reg_base->cb, reg_base->cb_ptr);
  2266. list_add(&reg_base->reg_base_head, &dbg_base->reg_base_list);
  2267. return 0;
  2268. }
  2269. void sde_dbg_reg_unregister_cb(const char *name, void (*cb)(void *), void *ptr)
  2270. {
  2271. struct sde_dbg_base *dbg_base = &sde_dbg_base;
  2272. struct sde_dbg_reg_base *reg_base;
  2273. if (!dbg_base)
  2274. return;
  2275. list_for_each_entry(reg_base, &dbg_base->reg_base_list, reg_base_head) {
  2276. if (strlen(reg_base->name) &&
  2277. !strcmp(reg_base->name, name)) {
  2278. pr_debug("%s cb: %pK cb_ptr: %pK\n", reg_base->name,
  2279. reg_base->cb, reg_base->cb_ptr);
  2280. list_del(&reg_base->reg_base_head);
  2281. kfree(reg_base);
  2282. break;
  2283. }
  2284. }
  2285. }
  2286. void sde_dbg_reg_register_dump_range(const char *base_name,
  2287. const char *range_name, u32 offset_start, u32 offset_end,
  2288. uint32_t xin_id)
  2289. {
  2290. struct sde_dbg_reg_base *reg_base;
  2291. struct sde_dbg_reg_range *range;
  2292. reg_base = _sde_dump_get_blk_addr(base_name);
  2293. if (!reg_base) {
  2294. pr_err("error: for range %s unable to locate base %s\n",
  2295. range_name, base_name);
  2296. return;
  2297. }
  2298. if (!range_name || strlen(range_name) == 0) {
  2299. pr_err("%pS: bad range name, base_name %s, offset_start 0x%X, end 0x%X\n",
  2300. __builtin_return_address(0), base_name,
  2301. offset_start, offset_end);
  2302. return;
  2303. }
  2304. if (offset_end - offset_start < REG_DUMP_ALIGN ||
  2305. offset_start > offset_end) {
  2306. pr_err("%pS: bad range, base_name %s, range_name %s, offset_start 0x%X, end 0x%X\n",
  2307. __builtin_return_address(0), base_name,
  2308. range_name, offset_start, offset_end);
  2309. return;
  2310. }
  2311. range = kzalloc(sizeof(*range), GFP_KERNEL);
  2312. if (!range)
  2313. return;
  2314. strlcpy(range->range_name, range_name, sizeof(range->range_name));
  2315. range->offset.start = offset_start;
  2316. range->offset.end = offset_end;
  2317. range->xin_id = xin_id;
  2318. list_add_tail(&range->head, &reg_base->sub_range_list);
  2319. pr_debug("base %s, range %s, start 0x%X, end 0x%X\n",
  2320. base_name, range->range_name,
  2321. range->offset.start, range->offset.end);
  2322. }
  2323. void sde_dbg_set_hw_ownership_status(bool enable)
  2324. {
  2325. mutex_lock(&sde_dbg_base.mutex);
  2326. sde_dbg_base.hw_ownership = enable;
  2327. mutex_unlock(&sde_dbg_base.mutex);
  2328. }
  2329. void sde_dbg_set_sde_top_offset(u32 blk_off)
  2330. {
  2331. sde_dbg_base.dbgbus_sde.top_blk_off = blk_off;
  2332. }