kgdb.c 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423
  1. /*
  2. * U-Boot - architecture specific kgdb code
  3. *
  4. * Copyright 2009 Analog Devices Inc.
  5. *
  6. * Licensed under the GPL-2 or later.
  7. */
  8. #include <common.h>
  9. #include <command.h>
  10. #include <kgdb.h>
  11. #include <asm/processor.h>
  12. #include <asm/mach-common/bits/core.h>
  13. #include "kgdb.h"
  14. #include <asm/deferred.h>
  15. #include <asm/traps.h>
  16. #include <asm/signal.h>
  17. void kgdb_enter(struct pt_regs *regs, kgdb_data *kdp)
  18. {
  19. /* disable interrupts */
  20. disable_interrupts();
  21. /* reply to host that an exception has occurred */
  22. kdp->sigval = kgdb_trap(regs);
  23. /* send the PC and the Stack Pointer */
  24. kdp->nregs = 2;
  25. kdp->regs[0].num = BFIN_PC;
  26. kdp->regs[0].val = regs->pc;
  27. kdp->regs[1].num = BFIN_SP;
  28. kdp->regs[1].val = (unsigned long)regs;
  29. }
  30. void kgdb_exit(struct pt_regs *regs, kgdb_data *kdp)
  31. {
  32. if (kdp->extype & KGDBEXIT_WITHADDR)
  33. printf("KGDBEXIT_WITHADDR\n");
  34. switch (kdp->extype & KGDBEXIT_TYPEMASK) {
  35. case KGDBEXIT_KILL:
  36. printf("KGDBEXIT_KILL:\n");
  37. break;
  38. case KGDBEXIT_CONTINUE:
  39. /* Make sure the supervisor single step bit is clear */
  40. regs->syscfg &= ~1;
  41. break;
  42. case KGDBEXIT_SINGLE:
  43. /* set the supervisor single step bit */
  44. regs->syscfg |= 1;
  45. break;
  46. default:
  47. printf("KGDBEXIT : %d\n", kdp->extype);
  48. }
  49. /* enable interrupts */
  50. enable_interrupts();
  51. }
  52. int kgdb_trap(struct pt_regs *regs)
  53. {
  54. /* ipend doesn't get filled in properly */
  55. switch (regs->seqstat & EXCAUSE) {
  56. case VEC_EXCPT01:
  57. return SIGTRAP;
  58. case VEC_EXCPT03:
  59. return SIGSEGV;
  60. case VEC_EXCPT02:
  61. return SIGTRAP;
  62. case VEC_EXCPT04 ... VEC_EXCPT15:
  63. return SIGILL;
  64. case VEC_STEP:
  65. return SIGTRAP;
  66. case VEC_OVFLOW:
  67. return SIGTRAP;
  68. case VEC_UNDEF_I:
  69. return SIGILL;
  70. case VEC_ILGAL_I:
  71. return SIGILL;
  72. case VEC_CPLB_VL:
  73. return SIGSEGV;
  74. case VEC_MISALI_D:
  75. return SIGBUS;
  76. case VEC_UNCOV:
  77. return SIGILL;
  78. case VEC_CPLB_MHIT:
  79. return SIGSEGV;
  80. case VEC_MISALI_I:
  81. return SIGBUS;
  82. case VEC_CPLB_I_VL:
  83. return SIGBUS;
  84. case VEC_CPLB_I_MHIT:
  85. return SIGSEGV;
  86. default:
  87. return SIGBUS;
  88. }
  89. }
  90. /*
  91. * getregs - gets the pt_regs, and gives them to kgdb's buffer
  92. */
  93. int kgdb_getregs(struct pt_regs *regs, char *buf, int max)
  94. {
  95. unsigned long *gdb_regs = (unsigned long *)buf;
  96. if (max < NUMREGBYTES)
  97. kgdb_error(KGDBERR_NOSPACE);
  98. if ((unsigned long)gdb_regs & 3)
  99. kgdb_error(KGDBERR_ALIGNFAULT);
  100. gdb_regs[BFIN_R0] = regs->r0;
  101. gdb_regs[BFIN_R1] = regs->r1;
  102. gdb_regs[BFIN_R2] = regs->r2;
  103. gdb_regs[BFIN_R3] = regs->r3;
  104. gdb_regs[BFIN_R4] = regs->r4;
  105. gdb_regs[BFIN_R5] = regs->r5;
  106. gdb_regs[BFIN_R6] = regs->r6;
  107. gdb_regs[BFIN_R7] = regs->r7;
  108. gdb_regs[BFIN_P0] = regs->p0;
  109. gdb_regs[BFIN_P1] = regs->p1;
  110. gdb_regs[BFIN_P2] = regs->p2;
  111. gdb_regs[BFIN_P3] = regs->p3;
  112. gdb_regs[BFIN_P4] = regs->p4;
  113. gdb_regs[BFIN_P5] = regs->p5;
  114. gdb_regs[BFIN_SP] = (unsigned long)regs;
  115. gdb_regs[BFIN_FP] = regs->fp;
  116. gdb_regs[BFIN_I0] = regs->i0;
  117. gdb_regs[BFIN_I1] = regs->i1;
  118. gdb_regs[BFIN_I2] = regs->i2;
  119. gdb_regs[BFIN_I3] = regs->i3;
  120. gdb_regs[BFIN_M0] = regs->m0;
  121. gdb_regs[BFIN_M1] = regs->m1;
  122. gdb_regs[BFIN_M2] = regs->m2;
  123. gdb_regs[BFIN_M3] = regs->m3;
  124. gdb_regs[BFIN_B0] = regs->b0;
  125. gdb_regs[BFIN_B1] = regs->b1;
  126. gdb_regs[BFIN_B2] = regs->b2;
  127. gdb_regs[BFIN_B3] = regs->b3;
  128. gdb_regs[BFIN_L0] = regs->l0;
  129. gdb_regs[BFIN_L1] = regs->l1;
  130. gdb_regs[BFIN_L2] = regs->l2;
  131. gdb_regs[BFIN_L3] = regs->l3;
  132. gdb_regs[BFIN_A0_DOT_X] = regs->a0x;
  133. gdb_regs[BFIN_A0_DOT_W] = regs->a0w;
  134. gdb_regs[BFIN_A1_DOT_X] = regs->a1x;
  135. gdb_regs[BFIN_A1_DOT_W] = regs->a1w;
  136. gdb_regs[BFIN_ASTAT] = regs->astat;
  137. gdb_regs[BFIN_RETS] = regs->rets;
  138. gdb_regs[BFIN_LC0] = regs->lc0;
  139. gdb_regs[BFIN_LT0] = regs->lt0;
  140. gdb_regs[BFIN_LB0] = regs->lb0;
  141. gdb_regs[BFIN_LC1] = regs->lc1;
  142. gdb_regs[BFIN_LT1] = regs->lt1;
  143. gdb_regs[BFIN_LB1] = regs->lb1;
  144. gdb_regs[BFIN_CYCLES] = 0;
  145. gdb_regs[BFIN_CYCLES2] = 0;
  146. gdb_regs[BFIN_USP] = regs->usp;
  147. gdb_regs[BFIN_SEQSTAT] = regs->seqstat;
  148. gdb_regs[BFIN_SYSCFG] = regs->syscfg;
  149. gdb_regs[BFIN_RETI] = regs->pc;
  150. gdb_regs[BFIN_RETX] = regs->retx;
  151. gdb_regs[BFIN_RETN] = regs->retn;
  152. gdb_regs[BFIN_RETE] = regs->rete;
  153. gdb_regs[BFIN_PC] = regs->pc;
  154. gdb_regs[BFIN_CC] = 0;
  155. gdb_regs[BFIN_EXTRA1] = 0;
  156. gdb_regs[BFIN_EXTRA2] = 0;
  157. gdb_regs[BFIN_EXTRA3] = 0;
  158. gdb_regs[BFIN_IPEND] = regs->ipend;
  159. return NUMREGBYTES;
  160. }
  161. /*
  162. * putreg - put kgdb's reg (regno) into the pt_regs
  163. */
  164. void kgdb_putreg(struct pt_regs *regs, int regno, char *buf, int length)
  165. {
  166. unsigned long *ptr = (unsigned long *)buf;
  167. if (regno < 0 || regno > BFIN_NUM_REGS)
  168. kgdb_error(KGDBERR_BADPARAMS);
  169. if (length < 4)
  170. kgdb_error(KGDBERR_NOSPACE);
  171. if ((unsigned long)ptr & 3)
  172. kgdb_error(KGDBERR_ALIGNFAULT);
  173. switch (regno) {
  174. case BFIN_R0:
  175. regs->r0 = *ptr;
  176. break;
  177. case BFIN_R1:
  178. regs->r1 = *ptr;
  179. break;
  180. case BFIN_R2:
  181. regs->r2 = *ptr;
  182. break;
  183. case BFIN_R3:
  184. regs->r3 = *ptr;
  185. break;
  186. case BFIN_R4:
  187. regs->r4 = *ptr;
  188. break;
  189. case BFIN_R5:
  190. regs->r5 = *ptr;
  191. break;
  192. case BFIN_R6:
  193. regs->r6 = *ptr;
  194. break;
  195. case BFIN_R7:
  196. regs->r7 = *ptr;
  197. break;
  198. case BFIN_P0:
  199. regs->p0 = *ptr;
  200. break;
  201. case BFIN_P1:
  202. regs->p1 = *ptr;
  203. break;
  204. case BFIN_P2:
  205. regs->p2 = *ptr;
  206. break;
  207. case BFIN_P3:
  208. regs->p3 = *ptr;
  209. break;
  210. case BFIN_P4:
  211. regs->p4 = *ptr;
  212. break;
  213. case BFIN_P5:
  214. regs->p5 = *ptr;
  215. break;
  216. case BFIN_SP:
  217. regs->reserved = *ptr;
  218. break;
  219. case BFIN_FP:
  220. regs->fp = *ptr;
  221. break;
  222. case BFIN_I0:
  223. regs->i0 = *ptr;
  224. break;
  225. case BFIN_I1:
  226. regs->i1 = *ptr;
  227. break;
  228. case BFIN_I2:
  229. regs->i2 = *ptr;
  230. break;
  231. case BFIN_I3:
  232. regs->i3 = *ptr;
  233. break;
  234. case BFIN_M0:
  235. regs->m0 = *ptr;
  236. break;
  237. case BFIN_M1:
  238. regs->m1 = *ptr;
  239. break;
  240. case BFIN_M2:
  241. regs->m2 = *ptr;
  242. break;
  243. case BFIN_M3:
  244. regs->m3 = *ptr;
  245. break;
  246. case BFIN_B0:
  247. regs->b0 = *ptr;
  248. break;
  249. case BFIN_B1:
  250. regs->b1 = *ptr;
  251. break;
  252. case BFIN_B2:
  253. regs->b2 = *ptr;
  254. break;
  255. case BFIN_B3:
  256. regs->b3 = *ptr;
  257. break;
  258. case BFIN_L0:
  259. regs->l0 = *ptr;
  260. break;
  261. case BFIN_L1:
  262. regs->l1 = *ptr;
  263. break;
  264. case BFIN_L2:
  265. regs->l2 = *ptr;
  266. break;
  267. case BFIN_L3:
  268. regs->l3 = *ptr;
  269. break;
  270. case BFIN_A0_DOT_X:
  271. regs->a0x = *ptr;
  272. break;
  273. case BFIN_A0_DOT_W:
  274. regs->a0w = *ptr;
  275. break;
  276. case BFIN_A1_DOT_X:
  277. regs->a1x = *ptr;
  278. break;
  279. case BFIN_A1_DOT_W:
  280. regs->a1w = *ptr;
  281. break;
  282. case BFIN_ASTAT:
  283. regs->astat = *ptr;
  284. break;
  285. case BFIN_RETS:
  286. regs->rets = *ptr;
  287. break;
  288. case BFIN_LC0:
  289. regs->lc0 = *ptr;
  290. break;
  291. case BFIN_LT0:
  292. regs->lt0 = *ptr;
  293. break;
  294. case BFIN_LB0:
  295. regs->lb0 = *ptr;
  296. break;
  297. case BFIN_LC1:
  298. regs->lc1 = *ptr;
  299. break;
  300. case BFIN_LT1:
  301. regs->lt1 = *ptr;
  302. break;
  303. case BFIN_LB1:
  304. regs->lb1 = *ptr;
  305. break;
  306. /*
  307. BFIN_CYCLES,
  308. BFIN_CYCLES2,
  309. BFIN_USP,
  310. BFIN_SEQSTAT,
  311. BFIN_SYSCFG,
  312. */
  313. case BFIN_RETX:
  314. regs->retx = *ptr;
  315. break;
  316. case BFIN_RETN:
  317. regs->retn = *ptr;
  318. break;
  319. case BFIN_RETE:
  320. regs->rete = *ptr;
  321. break;
  322. case BFIN_PC:
  323. regs->pc = *ptr;
  324. break;
  325. default:
  326. kgdb_error(KGDBERR_BADPARAMS);
  327. }
  328. }
  329. void kgdb_putregs(struct pt_regs *regs, char *buf, int length)
  330. {
  331. unsigned long *gdb_regs = (unsigned long *)buf;
  332. if (length != BFIN_NUM_REGS)
  333. kgdb_error(KGDBERR_NOSPACE);
  334. if ((unsigned long)gdb_regs & 3)
  335. kgdb_error(KGDBERR_ALIGNFAULT);
  336. regs->r0 = gdb_regs[BFIN_R0];
  337. regs->r1 = gdb_regs[BFIN_R1];
  338. regs->r2 = gdb_regs[BFIN_R2];
  339. regs->r3 = gdb_regs[BFIN_R3];
  340. regs->r4 = gdb_regs[BFIN_R4];
  341. regs->r5 = gdb_regs[BFIN_R5];
  342. regs->r6 = gdb_regs[BFIN_R6];
  343. regs->r7 = gdb_regs[BFIN_R7];
  344. regs->p0 = gdb_regs[BFIN_P0];
  345. regs->p1 = gdb_regs[BFIN_P1];
  346. regs->p2 = gdb_regs[BFIN_P2];
  347. regs->p3 = gdb_regs[BFIN_P3];
  348. regs->p4 = gdb_regs[BFIN_P4];
  349. regs->p5 = gdb_regs[BFIN_P5];
  350. regs->fp = gdb_regs[BFIN_FP];
  351. /* regs->sp = gdb_regs[BFIN_ ]; */
  352. regs->i0 = gdb_regs[BFIN_I0];
  353. regs->i1 = gdb_regs[BFIN_I1];
  354. regs->i2 = gdb_regs[BFIN_I2];
  355. regs->i3 = gdb_regs[BFIN_I3];
  356. regs->m0 = gdb_regs[BFIN_M0];
  357. regs->m1 = gdb_regs[BFIN_M1];
  358. regs->m2 = gdb_regs[BFIN_M2];
  359. regs->m3 = gdb_regs[BFIN_M3];
  360. regs->b0 = gdb_regs[BFIN_B0];
  361. regs->b1 = gdb_regs[BFIN_B1];
  362. regs->b2 = gdb_regs[BFIN_B2];
  363. regs->b3 = gdb_regs[BFIN_B3];
  364. regs->l0 = gdb_regs[BFIN_L0];
  365. regs->l1 = gdb_regs[BFIN_L1];
  366. regs->l2 = gdb_regs[BFIN_L2];
  367. regs->l3 = gdb_regs[BFIN_L3];
  368. regs->a0x = gdb_regs[BFIN_A0_DOT_X];
  369. regs->a0w = gdb_regs[BFIN_A0_DOT_W];
  370. regs->a1x = gdb_regs[BFIN_A1_DOT_X];
  371. regs->a1w = gdb_regs[BFIN_A1_DOT_W];
  372. regs->rets = gdb_regs[BFIN_RETS];
  373. regs->lc0 = gdb_regs[BFIN_LC0];
  374. regs->lt0 = gdb_regs[BFIN_LT0];
  375. regs->lb0 = gdb_regs[BFIN_LB0];
  376. regs->lc1 = gdb_regs[BFIN_LC1];
  377. regs->lt1 = gdb_regs[BFIN_LT1];
  378. regs->lb1 = gdb_regs[BFIN_LB1];
  379. regs->usp = gdb_regs[BFIN_USP];
  380. regs->syscfg = gdb_regs[BFIN_SYSCFG];
  381. regs->retx = gdb_regs[BFIN_PC];
  382. regs->retn = gdb_regs[BFIN_RETN];
  383. regs->rete = gdb_regs[BFIN_RETE];
  384. regs->pc = gdb_regs[BFIN_PC];
  385. #if 0 /* can't change these */
  386. regs->astat = gdb_regs[BFIN_ASTAT];
  387. regs->seqstat = gdb_regs[BFIN_SEQSTAT];
  388. regs->ipend = gdb_regs[BFIN_IPEND];
  389. #endif
  390. }
  391. void kgdb_breakpoint(int argc, char * const argv[])
  392. {
  393. asm volatile ("excpt 0x1\n");
  394. }