LXR linux/arch/nios2/kernel/kgdb.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Nios2 KGDB support
   4 *
   5 * Copyright (C) 2015 Altera Corporation
   6 * Copyright (C) 2011 Tobias Klauser <tklauser@distanz.ch>
   7 *
   8 * Based on the code posted by Kazuyasu on the Altera Forum at:
   9 * http://www.alteraforum.com/forum/showpost.php?p=77003&postcount=20
  10 */
  11#include <linux/ptrace.h>
  12#include <linux/kgdb.h>
  13#include <linux/kdebug.h>
  14#include <linux/io.h>
  15
  16static int wait_for_remote_debugger;
  17
  18struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] =
  19{
  20        { "zero", GDB_SIZEOF_REG, -1 },
  21        { "at", GDB_SIZEOF_REG, offsetof(struct pt_regs, r1) },
  22        { "r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r2) },
  23        { "r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r3) },
  24        { "r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r4) },
  25        { "r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r5) },
  26        { "r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r6) },
  27        { "r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r7) },
  28        { "r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r8) },
  29        { "r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r9) },
  30        { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10) },
  31        { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11) },
  32        { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12) },
  33        { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13) },
  34        { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14) },
  35        { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15) },
  36        { "r16", GDB_SIZEOF_REG, -1 },
  37        { "r17", GDB_SIZEOF_REG, -1 },
  38        { "r18", GDB_SIZEOF_REG, -1 },
  39        { "r19", GDB_SIZEOF_REG, -1 },
  40        { "r20", GDB_SIZEOF_REG, -1 },
  41        { "r21", GDB_SIZEOF_REG, -1 },
  42        { "r22", GDB_SIZEOF_REG, -1 },
  43        { "r23", GDB_SIZEOF_REG, -1 },
  44        { "et", GDB_SIZEOF_REG, -1 },
  45        { "bt", GDB_SIZEOF_REG, -1 },
  46        { "gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp) },
  47        { "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, sp) },
  48        { "fp", GDB_SIZEOF_REG, offsetof(struct pt_regs, fp) },
  49        { "ea", GDB_SIZEOF_REG, -1 },
  50        { "ba", GDB_SIZEOF_REG, -1 },
  51        { "ra", GDB_SIZEOF_REG, offsetof(struct pt_regs, ra) },
  52        { "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, ea) },
  53        { "status", GDB_SIZEOF_REG, -1 },
  54        { "estatus", GDB_SIZEOF_REG, offsetof(struct pt_regs, estatus) },
  55        { "bstatus", GDB_SIZEOF_REG, -1 },
  56        { "ienable", GDB_SIZEOF_REG, -1 },
  57        { "ipending", GDB_SIZEOF_REG, -1},
  58        { "cpuid", GDB_SIZEOF_REG, -1 },
  59        { "ctl6", GDB_SIZEOF_REG, -1 },
  60        { "exception", GDB_SIZEOF_REG, -1 },
  61        { "pteaddr", GDB_SIZEOF_REG, -1 },
  62        { "tlbacc", GDB_SIZEOF_REG, -1 },
  63        { "tlbmisc", GDB_SIZEOF_REG, -1 },
  64        { "eccinj", GDB_SIZEOF_REG, -1 },
  65        { "badaddr", GDB_SIZEOF_REG, -1 },
  66        { "config", GDB_SIZEOF_REG, -1 },
  67        { "mpubase", GDB_SIZEOF_REG, -1 },
  68        { "mpuacc", GDB_SIZEOF_REG, -1 },
  69};
  70
  71char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs)
  72{
  73        if (regno >= DBG_MAX_REG_NUM || regno < 0)
  74                return NULL;
  75
  76        if (dbg_reg_def[regno].offset != -1)
  77                memcpy(mem, (void *)regs + dbg_reg_def[regno].offset,
  78                       dbg_reg_def[regno].size);
  79        else
  80                memset(mem, 0, dbg_reg_def[regno].size);
  81
  82        return dbg_reg_def[regno].name;
  83}
  84
  85int dbg_set_reg(int regno, void *mem, struct pt_regs *regs)
  86{
  87        if (regno >= DBG_MAX_REG_NUM || regno < 0)
  88                return -EINVAL;
  89
  90        if (dbg_reg_def[regno].offset != -1)
  91                memcpy((void *)regs + dbg_reg_def[regno].offset, mem,
  92                       dbg_reg_def[regno].size);
  93
  94        return 0;
  95}
  96
  97void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
  98{
  99        memset((char *)gdb_regs, 0, NUMREGBYTES);
 100        gdb_regs[GDB_SP] = p->thread.kregs->sp;
 101        gdb_regs[GDB_PC] = p->thread.kregs->ea;
 102}
 103
 104void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
 105{
 106        regs->ea = pc;
 107}
 108
 109int kgdb_arch_handle_exception(int vector, int signo, int err_code,
 110                                char *remcom_in_buffer, char *remcom_out_buffer,
 111                                struct pt_regs *regs)
 112{
 113        char *ptr;
 114        unsigned long addr;
 115
 116        switch (remcom_in_buffer[0]) {
 117        case 's':
 118        case 'c':
 119                /* handle the optional parameters */
 120                ptr = &remcom_in_buffer[1];
 121                if (kgdb_hex2long(&ptr, &addr))
 122                        regs->ea = addr;
 123
 124                return 0;
 125        }
 126
 127        return -1; /* this means that we do not want to exit from the handler */
 128}
 129
 130asmlinkage void kgdb_breakpoint_c(struct pt_regs *regs)
 131{
 132        /*
 133         * The breakpoint entry code has moved the PC on by 4 bytes, so we must
 134         * move it back.  This could be done on the host but we do it here
 135         */
 136        if (!wait_for_remote_debugger)
 137                regs->ea -= 4;
 138        else    /* pass the first trap 30 code */
 139                wait_for_remote_debugger = 0;
 140
 141        kgdb_handle_exception(30, SIGTRAP, 0, regs);
 142}
 143
 144int kgdb_arch_init(void)
 145{
 146        wait_for_remote_debugger = 1;
 147        return 0;
 148}
 149
 150void kgdb_arch_exit(void)
 151{
 152        /* Nothing to do */
 153}
 154
 155const struct kgdb_arch arch_kgdb_ops = {
 156        /* Breakpoint instruction: trap 30 */
 157        .gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 },
 158};
 159