sde_dbg.c 69 KB

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