arch/blackfin/lib/kgdb.c

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