URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

Compare Revisions

This comparison shows the changes necessary to convert path
```
/or1k/trunk/ecos-2.0/packages/cygmon
```
from Rev 1254 to Rev 1765
↔ Reverse comparison
Compare Path: Rev

With Path: Rev

Rev 1254 → Rev 1765

/v2_0/cdl/cygmon.cdl

0,0 → 1,140

/v2_0/ChangeLog

0,0 → 1,252

/v2_0/misc/arm/arm-mon.c

0,0 → 1,281

/v2_0/misc/arm/cpu_info.h

0,0 → 1,100

/v2_0/misc/arm/board.h

0,0 → 1,82

/v2_0/misc/arm/cpu.h

0,0 → 1,978

/v2_0/misc/utils.c

0,0 → 1,376

/v2_0/misc/ledit.c

0,0 → 1,604

/v2_0/misc/bsp/arm/gdb-cpu.c

0,0 → 1,208

/v2_0/misc/bsp/arm/gdb.h

0,0 → 1,58

/v2_0/misc/bsp/arm/gdb-cpu.h

0,0 → 1,61

/v2_0/misc/bsp/arm/insn.h

0,0 → 1,482

v2_0/misc/bsp/arm/insn.h Property changes : Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: v2_0/misc/bsp/arm/singlestep.c =================================================================== --- v2_0/misc/bsp/arm/singlestep.c (nonexistent) +++ v2_0/misc/bsp/arm/singlestep.c (revision 1765) @@ -0,0 +1,1320 @@ +//========================================================================== +// +// singlestep.c +// +// ARM(R) specific single-step support. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: ARM(R) specific single-step support. +// Description: ARM is a Registered Trademark of Advanced RISC Machines Limited. +// Other Brands and Trademarks are the property of their +// respective owners. +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include +#include +#include "insn.h" + +#define DEBUG_SINGLESTEP 0 +#define DEBUG_SINGLESTEP_VERBOSE 0 + +/* + * Structure to hold opcodes hoisted when breakpoints are + * set for single-stepping or async interruption. + */ +struct _bp_save { + unsigned long *addr; + unsigned long opcode; +}; + +#define NUM_BREAKS_SAVED 2 +static struct _bp_save _breaks[NUM_BREAKS_SAVED]; + +/* + * Insert a breakpoint at 'pc' using first available + * _bp_save struct. + */ +static void +insert_ss_break(unsigned long *pc) +{ + struct _bp_save *p = _breaks; + union arm_insn inst; + + if (p->addr && (++p)->addr) + return; + + /* + * We can't set a breakpoint at 0 + */ + if (pc == 0) + { +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at <0x%08lx>: Error\n", pc); +#endif /* DEBUG_SINGLESTEP */ + return; + } + + /* + * Make sure we are on a long word boundary. + */ + if (((unsigned long)pc & 0x3) != 0) + { + /* + * All ARM(R) instructions are on a word boundary. + * This would be invalid. Don't set a bkpt here. + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at <0x%08lx>: Error\n", pc); +#endif /* DEBUG_SINGLESTEP */ + return; + } + + + /* + * What is the current instruction + */ + if (bsp_memory_read(pc, 0, ARM_INST_SIZE * 8, 1, &(inst.word)) == 0) + { + /* + * Unable to read this address, probably an invalid address. + * Don't set a breakpoint here, as it will likely cause a bus error + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at <0x%08lx>: Error\n", pc); +#endif /* DEBUG_SINGLESTEP */ + return; + } + + if (inst.word != BREAKPOINT_INSN) + { + /* + * Only insert a breakpoint if we haven't done so already + * + * We may try to insert 2 breakpoints if we to a branch to + * the immediately following instruction. + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at <0x%08lx>: inst <0x%08lx>\n", pc, inst.word); +#endif /* DEBUG_SINGLESTEP */ + + p->addr = pc; + p->opcode = inst.word; + inst.word = BREAKPOINT_INSN; + if (bsp_memory_write(pc, 0, ARM_INST_SIZE * 8, 1, &(inst.word)) == 0) + { + /* + * Unable to write this address, probably an invalid address. + * Don't set a breakpoint here, as it will likely cause a bus error + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at <0x%08lx>: Error\n", pc); +#endif /* DEBUG_SINGLESTEP */ + return; + } + + /* flush icache and dcache, now */ + bsp_flush_dcache((void *)pc, ARM_INST_SIZE); + bsp_flush_icache((void *)pc, ARM_INST_SIZE); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Done setting BP at <0x%08lx>: inst <0x%08lx>\n", pc, *pc); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + } +} + +/* + * Cleanup after a singlestep. + */ +void +bsp_singlestep_cleanup(void *registers) +{ + struct _bp_save *p = _breaks; + int i; + + for (i = 0; i < NUM_BREAKS_SAVED; i++, p++) + { + if (p->addr) + { + unsigned long *old_addr = p->addr; + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Remove BP at <0x%08lx>: inst <0x%08lx>\n", old_addr, *old_addr); +#endif /* DEBUG_SINGLESTEP */ + *(p->addr) = p->opcode; + p->addr = NULL; + + /* flush icache and dcache, now */ + bsp_flush_dcache((void *)old_addr, ARM_INST_SIZE); + bsp_flush_icache((void *)old_addr, ARM_INST_SIZE); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Done removing BP at <0x%08lx>: inst <0x%08lx>\n", old_addr, *old_addr); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + } + } +} + +/* + * Rotate right a value by count + */ +static unsigned long ror(unsigned long value, unsigned count) +{ + while (count-- > 0) + { + if (value & 0x1) + value = (value >> 1) | 0x80000000; + else + value = (value >> 1); + } + + return(value); +} + +/* + * Rotate right a value by 1 with extend + */ +static unsigned long rrx(union arm_psr sr, unsigned long value) +{ + if (sr.psr.c_bit) + value = (value >> 1) | 0x80000000; + else + value = (value >> 1); + + return(value); +} + +/* + * Logical shift left by count + */ +static unsigned long lsl(unsigned long value, unsigned count) +{ + value <<= count; + + return(value); +} + +/* + * Logical shift right by count + */ +static unsigned long lsr(unsigned long value, unsigned count) +{ + value >>= count; + + return(value); +} + +/* + * Arithmetic shift right by count + */ +static unsigned long asr(unsigned long value, unsigned count) +{ + unsigned long sign_ext_mask = 0; + + if (value & 0x80000000) + { + if (count >= sizeof(value)*8) + sign_ext_mask = ~0; + else + sign_ext_mask = (~0 << (sizeof(value)*8 - count)); + } + value = (value >> count) | sign_ext_mask; + + return(value); +} + +/* + * Calculate an immediate shift operand based on input shift operand, + * shift value and register address. + */ +static unsigned long immediate_shift_operand(ex_regs_t *regs, unsigned shift_immediate, + unsigned shift, unsigned Rm) +{ + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *reg_ptr = ®s_array[bsp_regbyte(Rm)]; + unsigned long reg_value = *((unsigned long *)(reg_ptr)); + unsigned long rc = 0; + + BSP_ASSERT((shift_immediate >= 0) && (shift_immediate <= 0x1f)); + BSP_ASSERT((shift >= 0) && (shift <= 0x3)); + BSP_ASSERT((Rm >= 0) && (Rm <= 0xf)); + BSP_ASSERT(bsp_regsize(Rm) == sizeof(unsigned long)); + + /* + * According to the ARM(R) Manual, if Rm is PC then, + * the value used is the address of the current instruction + * plus 8 + */ + if (Rm == REG_PC) + reg_value += 8; + + switch (shift) + { + case SHIFT_LSL: + rc = lsl(reg_value, shift_immediate); + break; + + case SHIFT_LSR: + if (shift_immediate == 0) + { + /* + * Special Case: LSR IMM(0) == 0 + */ + rc = 0; + } else { + rc = lsr(reg_value, shift_immediate); + } + break; + + case SHIFT_ASR: + if (shift_immediate == 0) + { + /* + * Special Case: ASR IMM(0) + */ + if (reg_value & 0x80000000) + { + rc = 0xFFFFFFFF; + } else { + rc = 0; + } + } else { + rc = asr(reg_value, shift_immediate); + } + break; + + case SHIFT_ROR: + if (shift_immediate == 0) + { + /* + * SHIFT_RRX + * Special case: ROR(0) implies RRX + */ + rc = rrx((union arm_psr)(unsigned long)regs->_cpsr, reg_value); + } else { + rc = ror(reg_value, shift_immediate); + } + break; + + default: + BSP_ASSERT(0); + break; + } + + return (rc); +} + +/* + * Calculate a register shift operand based on input shift operand, + * and target registers. + */ +static unsigned long register_shift_operand(ex_regs_t *regs, unsigned Rs, + unsigned shift, unsigned Rm) +{ + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rs_ptr = ®s_array[bsp_regbyte(Rs)]; + unsigned char *Rm_ptr = ®s_array[bsp_regbyte(Rm)]; + unsigned long Rs_val = *((unsigned long *)(Rs_ptr)); + unsigned long Rm_val = *((unsigned long *)(Rm_ptr)); + unsigned long rc = 0; + + /* + * Use only the least significant byte of Rs + */ + Rs_val &= 0xFF; + + BSP_ASSERT((Rs >= 0) && (Rs <= 0xf)); + BSP_ASSERT((shift >= 0) && (shift <= 0x3)); + BSP_ASSERT((Rm >= 0) && (Rm <= 0xf)); + BSP_ASSERT(bsp_regsize(Rs) == sizeof(unsigned long)); + BSP_ASSERT(bsp_regsize(Rm) == sizeof(unsigned long)); + BSP_ASSERT((Rs_val >=0) && (Rs_val <= 0xff)); + + /* + * According to the ARM(R) Manual, if Rm is PC then, + * the value used is the address of the current instruction + * plus 8 + */ + if (Rm == REG_PC) + Rm_val += 8; + + switch (shift) + { + case SHIFT_LSL: rc = lsl(Rm_val, Rs_val); break; + case SHIFT_LSR: rc = lsr(Rm_val, Rs_val); break; + case SHIFT_ASR: rc = asr(Rm_val, Rs_val); break; + case SHIFT_ROR: rc = ror(Rm_val, Rs_val); break; + default: BSP_ASSERT(0); break; + } + + return (rc); +} + +/* + * Calculate a branch exchange operand based on input destination register + */ +static unsigned long branch_exchange_operand(ex_regs_t *regs, unsigned Rm) +{ + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *reg_ptr = ®s_array[bsp_regbyte(Rm)]; + unsigned long reg_value = *((unsigned long *)(reg_ptr)); + + BSP_ASSERT((Rm >= 0) && (Rm <= 0xf)); + BSP_ASSERT(bsp_regsize(Rm) == sizeof(unsigned long)); + + /* + * Clear the low-order bit + */ + return (reg_value & ~0x1); +} + +/* + * Handle a load to the PC + */ +static void handle_pc_load(unsigned size, unsigned long operand) +{ + unsigned long mem_value = 0; + + if (size == LS_SIZE_WORD) + { + if (bsp_memory_read((void*)(operand & ~0x3), 0, 32, 1, &mem_value) == 0) + { + /* + * Unable to read the memory address. + * Don't try any further. + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at *(0x%08lx): Error\n", operand & ~0x3); +#endif /* DEBUG_SINGLESTEP */ + return; + } else { +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at *(0x%08lx): data <0x%08lx>\n", operand & ~0x3, mem_value); +#endif /* DEBUG_SINGLESTEP */ + } + + /* + * Handle rotations if required + */ + switch (operand & 0x3) + { + case 0x0: break; + case 0x1: mem_value = ror(mem_value, 8); break; + case 0x2: mem_value = ror(mem_value, 16); break; + case 0x3: mem_value = ror(mem_value, 24); break; + } + } else { + /* + * Byte load of the PC + */ + if (bsp_memory_read((void*)operand, 0, 8, 1, &mem_value) == 0) + { + /* + * Unable to read the memory address. + * Don't try any further. + */ +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at *(0x%08lx): Error\n", operand & ~0x3); +#endif /* DEBUG_SINGLESTEP */ + return; + } else { +#if DEBUG_SINGLESTEP + bsp_printf("Setting BP at *(0x%08lx): data <0x%08lx>\n", operand & ~0x3, mem_value); +#endif /* DEBUG_SINGLESTEP */ + } + } + + insert_ss_break((unsigned long *)mem_value); +} + +/* + * Calculate a load/store w/ Immediate offset operand based on input + * source register, offset value, and opcode (add/sub) + */ +static unsigned long load_store_immediate_operand(ex_regs_t *regs, + unsigned p_bit, + unsigned u_bit, + unsigned Rn, + unsigned offset) +{ + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *reg_ptr = ®s_array[bsp_regbyte(Rn)]; + unsigned long rc = *((unsigned long *)(reg_ptr)); + + BSP_ASSERT((Rn >= 0) && (Rn <= 0xf)); + BSP_ASSERT(bsp_regsize(Rn) == sizeof(unsigned long)); + BSP_ASSERT((offset >= 0) && (offset <= 0xfff)); + BSP_ASSERT((p_bit >= 0) && (p_bit <= 1)); + BSP_ASSERT((u_bit >= 0) && (u_bit <= 1)); + + /* + * According to the ARM(R) Manual, if Rn is PC then, + * the value used is the address of the current instruction + * plus 8 + */ + if (Rn == REG_PC) + rc += 8; + + /* + * Do the update pre-index update + */ + if (p_bit == LS_INDEX_PRE) + { + if (u_bit == LS_OFFSET_SUB) + rc -= offset; + else /* opcode == LS_OFFSET_ADD */ + rc += offset; + } + + return (rc); +} + +/* + * Calculate a load/store w/ Register offset operand based on input + * source register, offset value, and opcode (add/sub) + * + * This calculates the appropriate pre-indexed operand + */ +static unsigned long load_store_register_operand(ex_regs_t *regs, + unsigned p_bit, + unsigned u_bit, + unsigned Rn, + unsigned Rm, + unsigned shift, + unsigned shift_immed) +{ + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rn_ptr = ®s_array[bsp_regbyte(Rn)]; + unsigned long Rn_val = *((unsigned long *)(Rn_ptr)); + unsigned long rc, index; + + BSP_ASSERT((Rn >= 0) && (Rn <= 0xf)); + BSP_ASSERT((Rm >= 0) && (Rm <= 0xf)); + BSP_ASSERT(bsp_regsize(Rn) == sizeof(unsigned long)); + BSP_ASSERT(bsp_regsize(Rm) == sizeof(unsigned long)); + BSP_ASSERT((p_bit >= 0) && (p_bit <= 1)); + BSP_ASSERT((u_bit >= 0) && (u_bit <= 1)); + BSP_ASSERT((shift >= 0) && (shift <= 0x3)); + BSP_ASSERT((shift_immed >= 0) && (shift_immed <= 0x1F)); + + /* + * According to the ARM(R) Manual, if Rn is PC then + * the value used is the address of the current + * instruction plus 8 + */ + if (Rn == REG_PC) + Rn_val += 8; + + /* + * According to the ARM(R) Manual, if Rm is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ + if (Rm == REG_PC) + return 0; + + index = immediate_shift_operand(regs, shift_immed, shift, Rm); + + rc = Rn_val; + + /* + * Do the update pre-index update + */ + if (p_bit == LS_INDEX_PRE) + { + if (u_bit == LS_OFFSET_SUB) + rc = Rn_val - index; + else /* opcode == LS_OFFSET_ADD */ + rc = Rn_val + index; + } + + return (rc); +} + +/* + * Decode all data processing immediate instructions + */ +static void decode_dpi_inst(ex_regs_t *regs, union arm_insn inst) +{ + if (inst.dpi.Rd == REG_PC) + { + unsigned long operand = ror(inst.dpi.immediate, (inst.dpi.rotate << 1)); + unsigned long *dest = 0; + unsigned carry = ((union arm_psr)(unsigned long)(regs->_cpsr)).psr.c_bit; + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rn_ptr = ®s_array[bsp_regbyte(inst.dpi.Rn)]; + unsigned long Rn_val = *((unsigned long *)(Rn_ptr)); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an data processing immediate instruction.\n"); + bsp_printf("inst.dpi.immediate = 0x%x\n", inst.dpi.immediate); + bsp_printf("inst.dpi.rotate = 0x%x\n", inst.dpi.rotate); + bsp_printf("inst.dpi.Rd = 0x%x\n", inst.dpi.Rd); + bsp_printf("inst.dpi.Rn = 0x%x\n", inst.dpi.Rn); + bsp_printf("inst.dpi.S_bit = 0x%x\n", inst.dpi.S_bit); + bsp_printf("inst.dpi.opcode = 0x%x\n", inst.dpi.opcode); + bsp_printf("inst.dpi.cond = 0x%x\n", inst.dpi.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + /* + * According to the ARM(R) Manual, if Rn is PC then + * the value used is the address of the current + * instruction plus 8 + */ + if (inst.dpi.Rn == REG_PC) + Rn_val += 8; + + switch (inst.dpi.opcode) { + case DP_OPCODE_ADC: dest = (unsigned long *)(Rn_val + operand + carry); break; + case DP_OPCODE_ADD: dest = (unsigned long *)(Rn_val + operand); break; + case DP_OPCODE_AND: dest = (unsigned long *)(Rn_val & operand); break; + case DP_OPCODE_BIC: dest = (unsigned long *)(Rn_val & ~operand); break; + case DP_OPCODE_EOR: dest = (unsigned long *)(Rn_val ^ operand); break; + case DP_OPCODE_MOV: dest = (unsigned long *)operand; break; + case DP_OPCODE_MVN: dest = (unsigned long *)(~operand); break; + case DP_OPCODE_ORR: dest = (unsigned long *)(Rn_val | operand); break; + case DP_OPCODE_RSB: dest = (unsigned long *)(operand - Rn_val); break; + case DP_OPCODE_RSC: dest = (unsigned long *)(operand - Rn_val - !carry); break; + case DP_OPCODE_SBC: dest = (unsigned long *)(Rn_val - operand - !carry); break; + case DP_OPCODE_SUB: dest = (unsigned long *)(Rn_val - operand); break; + default: dest = (unsigned long *)0; break; + } + dest = (unsigned long *)((unsigned long)dest & ~0x3); + insert_ss_break(dest); + } +} + +/* + * Decode all data processing immediate w/ shift instructions + */ +static void decode_dpis_inst(ex_regs_t *regs, union arm_insn inst) +{ + if (inst.dpis.Rd == REG_PC) + { + unsigned long operand = immediate_shift_operand(regs, inst.dpis.shift_immed, + inst.dpis.shift, inst.dpis.Rm); + unsigned long *dest = 0; + unsigned carry = ((union arm_psr)(unsigned long)(regs->_cpsr)).psr.c_bit; + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rn_ptr = ®s_array[bsp_regbyte(inst.dpis.Rn)]; + unsigned long Rn_val = *((unsigned long *)(Rn_ptr)); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an data processing immediate shift instruction.\n"); + bsp_printf("inst.dpis.Rm = 0x%x\n", inst.dpis.Rm); + bsp_printf("inst.dpis.shift = 0x%x\n", inst.dpis.shift); + bsp_printf("inst.dpis.shift_immed = 0x%x\n", inst.dpis.shift_immed); + bsp_printf("inst.dpis.Rd = 0x%x\n", inst.dpis.Rd); + bsp_printf("inst.dpis.Rn = 0x%x\n", inst.dpis.Rn); + bsp_printf("inst.dpis.S_bit = 0x%x\n", inst.dpis.S_bit); + bsp_printf("inst.dpis.opcode = 0x%x\n", inst.dpis.opcode); + bsp_printf("inst.dpis.cond = 0x%x\n", inst.dpis.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + /* + * According to the ARM(R) Manual, if Rn is PC then + * the value used is the address of the current + * instruction plus 8 + */ + if (inst.dpis.Rn == REG_PC) + Rn_val += 8; + + switch (inst.dpis.opcode) { + case DP_OPCODE_ADC: dest = (unsigned long *)(Rn_val + operand + carry); break; + case DP_OPCODE_ADD: dest = (unsigned long *)(Rn_val + operand); break; + case DP_OPCODE_AND: dest = (unsigned long *)(Rn_val & operand); break; + case DP_OPCODE_BIC: dest = (unsigned long *)(Rn_val & ~operand); break; + case DP_OPCODE_EOR: dest = (unsigned long *)(Rn_val ^ operand); break; + case DP_OPCODE_MOV: dest = (unsigned long *)operand; break; + case DP_OPCODE_MVN: dest = (unsigned long *)(~operand); break; + case DP_OPCODE_ORR: dest = (unsigned long *)(Rn_val | operand); break; + case DP_OPCODE_RSB: dest = (unsigned long *)(operand - Rn_val); break; + case DP_OPCODE_RSC: dest = (unsigned long *)(operand - Rn_val - !carry); break; + case DP_OPCODE_SBC: dest = (unsigned long *)(Rn_val - operand - !carry); break; + case DP_OPCODE_SUB: dest = (unsigned long *)(Rn_val - operand); break; + default: dest = (unsigned long *)0; break; + } + dest = (unsigned long *)((unsigned long)dest & ~0x3); + insert_ss_break(dest); + } +} + +/* + * Decode all data processing register w/ shift instructions + */ +static void decode_dprs_inst(ex_regs_t *regs, union arm_insn inst) +{ + if (inst.dprs.Rd == REG_PC) + { + unsigned long operand = register_shift_operand(regs, inst.dprs.Rs, + inst.dprs.shift, inst.dprs.Rm); + unsigned long *dest = 0; + unsigned carry = ((union arm_psr)(unsigned long)(regs->_cpsr)).psr.c_bit; + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rn_ptr = ®s_array[bsp_regbyte(inst.dprs.Rn)]; + unsigned long Rn_val = *((unsigned long *)(Rn_ptr)); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an data processing register shift instruction.\n"); + bsp_printf("inst.dprs.Rm = 0x%x\n", inst.dprs.Rm); + bsp_printf("inst.dprs.rsv3 = 0x%x\n", inst.dprs.rsv3); + bsp_printf("inst.dprs.shift = 0x%x\n", inst.dprs.shift); + bsp_printf("inst.dprs.rsv2 = 0x%x\n", inst.dprs.rsv2); + bsp_printf("inst.dprs.Rs = 0x%x\n", inst.dprs.Rs); + bsp_printf("inst.dprs.Rd = 0x%x\n", inst.dprs.Rd); + bsp_printf("inst.dprs.Rn = 0x%x\n", inst.dprs.Rn); + bsp_printf("inst.dprs.S_bit = 0x%x\n", inst.dprs.S_bit); + bsp_printf("inst.dprs.opcode = 0x%x\n", inst.dprs.opcode); + bsp_printf("inst.dprs.rsv1 = 0x%x\n", inst.dprs.rsv1); + bsp_printf("inst.dprs.cond = 0x%x\n", inst.dprs.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + /* + * According to the ARM(R) Manual, if Rn is PC then + * the value used is the address of the current + * instruction plus 8 + */ + if (inst.dprs.Rn == REG_PC) + Rn_val += 8; + + switch (inst.dprs.opcode) { + case DP_OPCODE_ADC: dest = (unsigned long *)(Rn_val + operand + carry); break; + case DP_OPCODE_ADD: dest = (unsigned long *)(Rn_val + operand); break; + case DP_OPCODE_AND: dest = (unsigned long *)(Rn_val & operand); break; + case DP_OPCODE_BIC: dest = (unsigned long *)(Rn_val & ~operand); break; + case DP_OPCODE_EOR: dest = (unsigned long *)(Rn_val ^ operand); break; + case DP_OPCODE_MOV: dest = (unsigned long *)operand; break; + case DP_OPCODE_MVN: dest = (unsigned long *)(~operand); break; + case DP_OPCODE_ORR: dest = (unsigned long *)(Rn_val | operand); break; + case DP_OPCODE_RSB: dest = (unsigned long *)(operand - Rn_val); break; + case DP_OPCODE_RSC: dest = (unsigned long *)(operand - Rn_val - !carry); break; + case DP_OPCODE_SBC: dest = (unsigned long *)(Rn_val - operand - !carry); break; + case DP_OPCODE_SUB: dest = (unsigned long *)(Rn_val - operand); break; + default: dest = (unsigned long *)0; break; + } + + dest = (unsigned long *)((unsigned long)dest & ~0x3); + insert_ss_break(dest); + } +} + +/* + * Decode all multiply instructions + */ +static void decode_m_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * According to the ARM(R) Manual, if Rd is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ +} + +/* + * Decode all multiply long instructions + */ +static void decode_ml_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * According to the ARM(R) Manual, if Rd is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ +} + + +/* + * Decode all move from status register instructions + */ +static void decode_mrs_inst(ex_regs_t *regs, union arm_insn inst) +{ +#if 0 + if (inst.mrs.Rd == REG_PC) + { + unsigned long *dest = 0; + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an move from status register instruction.\n"); + bsp_printf("inst.mrs.SBZ = 0x%x\n", inst.mrs.SBZ); + bsp_printf("inst.mrs.Rd = 0x%x\n", inst.mrs.Rd); + bsp_printf("inst.mrs.SBO = 0x%x\n", inst.mrs.SBO); + bsp_printf("inst.mrs.rsv2 = 0x%x\n", inst.mrs.rsv2); + bsp_printf("inst.mrs.R_bit = 0x%x\n", inst.mrs.R_bit); + bsp_printf("inst.mrs.rsv1 = 0x%x\n", inst.mrs.rsv1); + bsp_printf("inst.mrs.cond = 0x%x\n", inst.mrs.cond); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + if (inst.mrs.R_bit == 1) + dest = (unsigned long *)regs->_spsr; + else + dest = (unsigned long *)regs->_cpsr; + + dest = (unsigned long *)((unsigned long)dest & ~0x3); + insert_ss_break(dest); + } +#endif +} + + +/* + * Decode all move immediate to status register instructions + */ +static void decode_misr_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't update the PC w/ this instruction. + * Don't set any more breakpoints + */ +} + + +/* + * Decode all move register to status registers instructions + */ +static void decode_mrsr_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't update the PC w/ this instruction. + * Don't set any more breakpoints + */ +} + + +/* + * Decode all branch/exchange instructions + */ +static void decode_bx_inst(ex_regs_t *regs, union arm_insn inst) +{ + unsigned long operand = branch_exchange_operand(regs, inst.bx.Rm); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an branch/exchange shift instruction.\n"); + bsp_printf("inst.bx.Rm = 0x%x\n", inst.bx.Rm); + bsp_printf("inst.bx.rsv2 = 0x%x\n", inst.bx.rsv2); + bsp_printf("inst.bx.SBO3 = 0x%x\n", inst.bx.SBO3); + bsp_printf("inst.bx.SBO2 = 0x%x\n", inst.bx.SBO2); + bsp_printf("inst.bx.SBO1 = 0x%x\n", inst.bx.SBO1); + bsp_printf("inst.bx.rsv1 = 0x%x\n", inst.bx.rsv1); + bsp_printf("inst.bx.cond = 0x%x\n", inst.bx.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + insert_ss_break((unsigned long *)operand); +} + + +/* + * Decode all load/store immediate offset instructions + */ +static void decode_lsio_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Only support direct loads of the PC + * + * According to the ARM(R) manual, automatic updates of the PC + * are UNPREDICTABLE (ie implementation defined). + */ + if ((inst.lsio.Rd == REG_PC) && (inst.lsio.L_bit == LS_LOAD)) + { + unsigned long operand = load_store_immediate_operand(regs, inst.lsio.P_bit, + inst.lsio.U_bit, inst.lsio.Rn, + inst.lsio.immediate); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an load/store w/ immediate offset instruction.\n"); + bsp_printf("inst.lsio.immediate = 0x%x\n", inst.lsio.immediate); + bsp_printf("inst.lsio.Rd = 0x%x\n", inst.lsio.Rd); + bsp_printf("inst.lsio.Rn = 0x%x\n", inst.lsio.Rn); + bsp_printf("inst.lsio.L_bit = 0x%x\n", inst.lsio.L_bit); + bsp_printf("inst.lsio.W_bit = 0x%x\n", inst.lsio.W_bit); + bsp_printf("inst.lsio.B_bit = 0x%x\n", inst.lsio.B_bit); + bsp_printf("inst.lsio.U_bit = 0x%x\n", inst.lsio.U_bit); + bsp_printf("inst.lsio.P_bit = 0x%x\n", inst.lsio.P_bit); + bsp_printf("inst.lsio.rsv1 = 0x%x\n", inst.lsio.rsv1); + bsp_printf("inst.lsio.cond = 0x%x\n", inst.lsio.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + handle_pc_load(inst.lsio.B_bit, operand); + } +} + + +/* + * Decode all load/store register offset instructions + */ +static void decode_lsro_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Only support direct loads of the PC + * + * According to the ARM(R) manual, automatic updates of the PC + * are UNPREDICTABLE (ie implementation defined). + */ + if ((inst.lsro.Rd == REG_PC) && (inst.lsro.L_bit == LS_LOAD)) + { + unsigned long operand = load_store_register_operand(regs, + inst.lsro.P_bit, + inst.lsro.U_bit, + inst.lsro.Rn, + inst.lsro.Rm, + inst.lsro.shift, + inst.lsro.shift_immed); +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an load/store w/ register offset instruction.\n"); + bsp_printf("inst.lsro.Rm = 0x%x\n", inst.lsro.Rm); + bsp_printf("inst.lsro.rsv2 = 0x%x\n", inst.lsro.rsv2); + bsp_printf("inst.lsro.shift = 0x%x\n", inst.lsro.shift); + bsp_printf("inst.lsro.shift_immed = 0x%x\n", inst.lsro.shift_immed); + bsp_printf("inst.lsro.Rd = 0x%x\n", inst.lsro.Rd); + bsp_printf("inst.lsro.Rn = 0x%x\n", inst.lsro.Rn); + bsp_printf("inst.lsro.L_bit = 0x%x\n", inst.lsro.L_bit); + bsp_printf("inst.lsro.W_bit = 0x%x\n", inst.lsro.W_bit); + bsp_printf("inst.lsro.B_bit = 0x%x\n", inst.lsro.B_bit); + bsp_printf("inst.lsro.U_bit = 0x%x\n", inst.lsro.U_bit); + bsp_printf("inst.lsro.P_bit = 0x%x\n", inst.lsro.P_bit); + bsp_printf("inst.lsro.rsv1 = 0x%x\n", inst.lsro.rsv1); + bsp_printf("inst.lsro.cond = 0x%x\n", inst.lsro.cond); + bsp_printf("operand = 0x%x\n", operand); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + handle_pc_load(inst.lsro.B_bit, operand); + } +} + + +/* + * Decode all load/store halfword/signed byte immediate offset instructions + */ +static void decode_lshwi_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * According to the ARM(R) Manual, if Rd is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ +} + + +/* + * Decode all load/store halfword/signed byte register offset instructions + */ +static void decode_lshwr_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * According to the ARM(R) Manual, if Rd is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ +} + + +/* + * Decode all swap/swap byte instructions + */ +static void decode_swap_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * According to the ARM(R) Manual, if Rd is PC then + * the result is unpredictable. Don't do anything + * here. Just return. + */ +} + + +/* + * Decode all load/store multiple instructions + */ +static void decode_lsm_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Only support direct load multiples where the PC is in the + * register list. + * + * According to the ARM(R) manual, automatic updates of the PC + * are UNPREDICTABLE (ie implementation defined). + */ + if ((inst.lsm.L_bit == LS_LOAD) && (inst.lsm.Reg_List & (0x1 << REG_PC))) + { + unsigned char *regs_array = (unsigned char *)regs; + unsigned char *Rn_ptr = ®s_array[bsp_regbyte(inst.lsm.Rn)]; + unsigned long Rn_val = *((unsigned long *)(Rn_ptr)); + unsigned long offset_to_pc = 0; + int i; + unsigned long **dest = 0; + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Decoded an load multiple instruction.\n"); + bsp_printf("inst.lsm.Reg_List = 0x%x\n", inst.lsm.Reg_List); + + bsp_printf("inst.lsm.Rn = 0x%x\n", inst.lsm.Rn); + bsp_printf("inst.lsm.L_bit = 0x%x\n", inst.lsm.L_bit); + bsp_printf("inst.lsm.W_bit = 0x%x\n", inst.lsm.W_bit); + bsp_printf("inst.lsm.S_bit = 0x%x\n", inst.lsm.S_bit); + bsp_printf("inst.lsm.U_bit = 0x%x\n", inst.lsm.U_bit); + bsp_printf("inst.lsm.P_bit = 0x%x\n", inst.lsm.P_bit); + bsp_printf("inst.lsm.rsv1 = 0x%x\n", inst.lsm.rsv1); + bsp_printf("inst.lsm.cond = 0x%x\n", inst.lsm.cond); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + if (inst.lsm.U_bit == 0) + { + /* + * We are using a ascending stack. + * That means the PC is actually the register + * nearest to Rn currently. + */ + if (inst.lsm.P_bit == 1) + /* + * Using a pre-decrement. + */ + offset_to_pc = -bsp_regsize(REG_PC); + else + offset_to_pc = 0; + } else { + /* + * We are using an descending stack. + * That means the PC is actually the register + * farthest from Rn currently. + * + * Find the number of registers stored before the PC + */ + for (i = 0; i < REG_PC; i++) + { + if ((inst.lsm.Reg_List & (0x1 << i)) != 0) + { + /* + * Bit #i is set. Increment our count. + */ + offset_to_pc += bsp_regsize(i); + } + } + + /* + * Adjust the offset if we do a decrement/increment __BEFORE__ + * the write. + */ + if (inst.lsm.P_bit == 1) + offset_to_pc += bsp_regsize(REG_PC); + } + + /* + * Now let's calculate the real address of the stored PC + * making sure to mask out the two LO bits. + */ + dest = (unsigned long **)((Rn_val + offset_to_pc) & ~0x3); + +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Rn_val = 0x%08lx\n", Rn_val); + bsp_printf("offset_to_pc = 0x%08lx\n", offset_to_pc); + bsp_printf("dest = 0x%08lx\n", dest); + bsp_printf("*dest = 0x%08lx\n", *dest); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + + insert_ss_break(*dest); + } +} + + +/* + * Decode all coprocessor data processing instructions + */ +static void decode_cpdp_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't possibly predict what this instruction will do. + * Don't do anything here. Just return. + */ +} + + +/* + * Decode all coprocessor register transfer instructions + */ +static void decode_cprt_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't possibly predict what this instruction will do. + * Don't do anything here. Just return. + */ +} + + +/* + * Decode all coprocessor load/store instructions + */ +static void decode_cpls_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't possibly predict what this instruction will do. + * Don't do anything here. Just return. + */ +} + + +/* + * Decode all branch/branch w/ link instructions + */ +static void decode_bbl_inst(ex_regs_t *regs, union arm_insn inst) +{ + unsigned long disp = inst.bbl.offset; + + /* + * Sign extend the 24 bit value + */ + if (disp & 0x00800000) + disp |= 0xff000000; + + /* + * Convert to long words + */ + disp <<= 2; + + /* + * Note: when the processor actually executes this instruction, the pc + * will point to the address of the current instruction + 8 because + * of the fetch/decode/execute cycle + */ + disp += 8; + + insert_ss_break((unsigned long *)(regs->_pc + disp)); +} + + +/* + * Decode all swi instructions + */ +static void decode_swi_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't possibly predict where we should set the breakpoint for this. + * Don't do anything here. Just return. + */ +} + + +/* + * Decode all undefined instructions + */ +static void decode_undef_inst(ex_regs_t *regs, union arm_insn inst) +{ + /* + * Can't possibly predict what this instruction will do. + * Don't do anything here. Just return. + */ +} + + +/* + * Set breakpoint instructions for single stepping. + */ +void +bsp_singlestep_setup(void *registers) +{ + ex_regs_t *regs = (ex_regs_t *)registers; + union arm_insn inst; + + if (bsp_memory_read((void*)(regs->_pc), 0, ARM_INST_SIZE * 8, 1, &(inst.word)) == 0) + { + /* + * Unable to read the instruction at the current address. + * Let's not do anything with this. We can't set breakpoints + * so let's get out now. + */ + return; + } + + /* + * Handle the simple case -- linear code + */ + insert_ss_break((unsigned long *)(regs->_pc + ARM_INST_SIZE)); + + /* + * Now, we need to decode the instructions and figure out what + * they would do. + */ + if ((inst.mrs.rsv1 == MRS_RSV1_VALUE) && + (inst.mrs.rsv2 == MRS_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("MRS type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_mrs_inst(regs, inst); + } else if ((inst.misr.rsv1 == MISR_RSV1_VALUE) && + (inst.misr.rsv2 == MISR_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("MISR type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_misr_inst(regs, inst); + } else if ((inst.mrsr.rsv1 == MRSR_RSV1_VALUE) && + (inst.mrsr.rsv2 == MRSR_RSV2_VALUE) && + (inst.mrsr.rsv3 == MRSR_RSV3_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("MRSR type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_mrsr_inst(regs, inst); + } else if (inst.dpi.rsv1 == DPI_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("DPI type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_dpi_inst(regs, inst); + } else if ((inst.bx.rsv1 == BX_RSV1_VALUE) && + (inst.bx.rsv2 == BX_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("BX type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_bx_inst(regs, inst); + } else if ((inst.dpis.rsv1 == DPIS_RSV1_VALUE) && + (inst.dpis.rsv2 == DPIS_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("DPIS type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_dpis_inst(regs, inst); + } else if ((inst.dprs.rsv1 == DPRS_RSV1_VALUE) && + (inst.dprs.rsv2 == DPRS_RSV2_VALUE) && + (inst.dprs.rsv3 == DPRS_RSV3_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("DPRS type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_dprs_inst(regs, inst); + } else if ((inst.m.rsv1 == M_RSV1_VALUE) && + (inst.m.rsv2 == M_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("M type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_m_inst(regs, inst); + } else if ((inst.ml.rsv1 == ML_RSV1_VALUE) && + (inst.ml.rsv2 == ML_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("ML type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_ml_inst(regs, inst); + } else if (inst.lsio.rsv1 == LSIO_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("LSIO type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_lsio_inst(regs, inst); + } else if ((inst.lsro.rsv1 == LSRO_RSV1_VALUE) && + (inst.lsro.rsv2 == LSRO_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("LSRO type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_lsro_inst(regs, inst); + } else if ((inst.lshwi.rsv1 == LSHWI_RSV1_VALUE) && + (inst.lshwi.rsv2 == LSHWI_RSV2_VALUE) && + (inst.lshwi.rsv3 == LSHWI_RSV3_VALUE) && + (inst.lshwi.rsv4 == LSHWI_RSV4_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("LSHWI type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_lshwi_inst(regs, inst); + } else if ((inst.lshwr.rsv1 == LSHWR_RSV1_VALUE) && + (inst.lshwr.rsv2 == LSHWR_RSV2_VALUE) && + (inst.lshwr.rsv3 == LSHWR_RSV3_VALUE) && + (inst.lshwr.rsv4 == LSHWR_RSV4_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("LSHWR type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_lshwr_inst(regs, inst); + } else if ((inst.swap.rsv1 == SWAP_RSV1_VALUE) && + (inst.swap.rsv2 == SWAP_RSV2_VALUE) && + (inst.swap.rsv3 == SWAP_RSV3_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("SWAP type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_swap_inst(regs, inst); + } else if (inst.lsm.rsv1 == LSM_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("LSM type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_lsm_inst(regs, inst); + } else if ((inst.cpdp.rsv1 == CPDP_RSV1_VALUE) && + (inst.cpdp.rsv2 == CPDP_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("CPDP type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_cpdp_inst(regs, inst); + } else if ((inst.cprt.rsv1 == CPRT_RSV1_VALUE) && + (inst.cprt.rsv2 == CPRT_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("CPRT type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_cprt_inst(regs, inst); + } else if (inst.cpls.rsv1 == CPLS_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("CPLS type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_cpls_inst(regs, inst); + } else if (inst.bbl.rsv1 == BBL_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("BBL type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_bbl_inst(regs, inst); + } else if (inst.swi.rsv1 == SWI_RSV1_VALUE) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("SWI type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_swi_inst(regs, inst); + } else if ((inst.undef.rsv1 == UNDEF_RSV1_VALUE) && + (inst.undef.rsv2 == UNDEF_RSV2_VALUE)) { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("UNDEF type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + decode_undef_inst(regs, inst); + } else { +#if DEBUG_SINGLESTEP_VERBOSE + bsp_printf("Unknown instruction type: 0x%08lx\n", inst.word); +#endif /* DEBUG_SINGLESTEP_VERBOSE */ + } +} + +void +bsp_skip_instruction(void *registers) +{ + ex_regs_t *regs = (ex_regs_t *)registers; + regs->_pc += ARM_INST_SIZE; +} Index: v2_0/misc/bsp/dbg-threads-api.h =================================================================== --- v2_0/misc/bsp/dbg-threads-api.h (nonexistent) +++ v2_0/misc/bsp/dbg-threads-api.h (revision 1765) @@ -0,0 +1,148 @@ +#ifndef __BSP_DBG_THREADS_API_H__ +#define __BSP_DBG_THREADS_API_H__ +//========================================================================== +// +// dbg-threads-api.h +// +// +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: These are the calls used to extract operating system +// specific information used in supporting thread aware +// debugging. +// The Operating Environment being debugged needs to supply +// these functions. +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#define has_thread_void 0 +#define has_thread_current 1 +#define has_thread_registers 2 +#define has_thread_reg_change 4 +#define has_thread_list 8 +#define has_thread_info 16 + +typedef unsigned char threadref[8] ; + +struct dbg_capabilities +{ + unsigned long mask1; +}; + +/* fill in the list of thread aware capabilities */ +extern int dbg_thread_capabilities(struct dbg_capabilities *cbp); + + +/* Fill in the identifier of the current thread */ +/* return 1 if defined, 0 if not defined */ +extern int dbg_currthread(threadref *varparm); + +/* get the first or next member of the list of known threads */ +extern int dbg_threadlist(int startflag, + threadref *lastthreadid, + threadref *next_thread); + +/* return 1 if next_threadid has been filled in with a value */ +/* return 0 if there are none or no more */ + +/* The O.S can fill in the following information about a thread when queried. + The structure of thise strings is determined by the O.S. + It is display oriented, so figure out what the users need to see. + Nulls are OK but GDB will fill some not so meaningful data. + These pointers may be in the calles private structures, the info will + get copied immediatly after the call to retreive it. + */ +struct cygmon_thread_debug_info +{ + threadref thread_id ; + int context_exists ; /* To the point where examining its state, + registers and stack makes sense to GDB */ + char * thread_display ; /* As shown in thread status window, name, state */ + char * unique_thread_name ; /* human readable identifier, window label */ + char * more_display ; /* more detailed info about thread. + priority, queuedepth, state, stack usage, statistics */ +} ; + + + + +extern int dbg_threadinfo(threadref *threadid, + struct cygmon_thread_debug_info *info); + +/* Return 1 if threadid is defined and info copied, 0 otherwise */ + +/* The O.S should fillin the array of registers using values from the +saves context. The array MUST be in GDB register save order even if +the saved context is different or smaller. Do not alter the values of +registers which are NOT in the O.S. thread context. Their default values +have already been assigned. +*/ + +extern int dbg_getthreadreg(threadref *osthreadid, + int regcount, /* count of registers in the array */ + void * regval); /* fillin this array */ + + +/* The O.S. should scan through this list of registers which are in +GDB order and the O.S. should replace the values of all registers +which are defined in the saved context of thread or process identified +by osthreadid. Return 0 if the threadis does not map to a known +process or other error. Return 1 if the setting is successful. */ + +extern int dbg_setthreadreg(threadref *osthreadid, + int regcount, /* number of registers */ + void *regval) ; + + +extern int dbg_scheduler(threadref *thread_id, int lock, int mode); + +/* --- EXCEPTION - + The O.S. does not provide this function , it calls this to specify the + location of the dbg_syscall vector + */ +extern void patch_dbg_syscalls(void * vector); + +#endif /* DBG_THREADS_API_INCLUDED */ +#endif // __BSP_DBG_THREADS_API_H__ Index: v2_0/misc/bsp/defs.h =================================================================== --- v2_0/misc/bsp/defs.h (nonexistent) +++ v2_0/misc/bsp/defs.h (revision 1765) @@ -0,0 +1,112 @@ +#ifndef __BSP_DEFS_H__ +#define __BSP_DEFS_H__ +//========================================================================== +// +// defs.h +// +// Definitions of interest to Red Hat BSP. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Definitions of interest to Red Hat BSP. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#define BIT0 0x00000001 +#define BIT1 0x00000002 +#define BIT2 0x00000004 +#define BIT3 0x00000008 +#define BIT4 0x00000010 +#define BIT5 0x00000020 +#define BIT6 0x00000040 +#define BIT7 0x00000080 +#define BIT8 0x00000100 +#define BIT9 0x00000200 +#define BIT10 0x00000400 +#define BIT11 0x00000800 +#define BIT12 0x00001000 +#define BIT13 0x00002000 +#define BIT14 0x00004000 +#define BIT15 0x00008000 +#define BIT16 0x00010000 +#define BIT17 0x00020000 +#define BIT18 0x00040000 +#define BIT19 0x00080000 +#define BIT20 0x00100000 +#define BIT21 0x00200000 +#define BIT22 0x00400000 +#define BIT23 0x00800000 +#define BIT24 0x01000000 +#define BIT25 0x02000000 +#define BIT26 0x04000000 +#define BIT27 0x08000000 +#define BIT28 0x10000000 +#define BIT29 0x20000000 +#define BIT30 0x40000000 +#define BIT31 0x80000000 + +#define SZ_1K 0x00000400 +#define SZ_2K 0x00000800 +#define SZ_4K 0x00001000 +#define SZ_8K 0x00002000 +#define SZ_16K 0x00004000 +#define SZ_32K 0x00008000 +#define SZ_64K 0x00010000 +#define SZ_128K 0x00020000 +#define SZ_256K 0x00040000 +#define SZ_512K 0x00080000 +#define SZ_1M 0x00100000 +#define SZ_2M 0x00200000 +#define SZ_4M 0x00400000 +#define SZ_8M 0x00800000 +#define SZ_16M 0x01000000 +#define SZ_32M 0x02000000 +#define SZ_64M 0x04000000 +#define SZ_128M 0x08000000 +#define SZ_256M 0x10000000 +#define SZ_512M 0x20000000 +#define SZ_1G 0x40000000 + +#endif // __BSP_DEFS_H__

v2_0/misc/bsp/defs.h Property changes : Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: v2_0/misc/bsp/hex-utils.h =================================================================== --- v2_0/misc/bsp/hex-utils.h (nonexistent) +++ v2_0/misc/bsp/hex-utils.h (revision 1765) @@ -0,0 +1,85 @@ +#ifndef __BSP_HEX_UTILS_H__ +#define __BSP_HEX_UTILS_H__ +//========================================================================== +// +// hex-utils.h +// +// Utilities for decoding hexadecimal encoded integers. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Utilities for decoding hexadecimal encoded integers. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#ifndef __ASSEMBLER__ + +/* + * Convert a single hex character to its binary value. + * Returns -1 if given character is not a value hex character. + */ +extern int __hex(char ch); + +/* + * Convert the hex data in 'buf' into 'count' bytes to be placed in 'mem'. + * Returns a pointer to the character in mem AFTER the last byte written. + */ +extern char *__unpack_bytes_to_mem(char *buf, char *mem, int count); + +/* + * While finding valid hex chars, build an unsigned long int. + * Return number of hex chars processed. + */ +extern int __unpack_ulong(char **ptr, unsigned long *val); + +/* + * Unpack 'count' hex characters, forming them into a binary value. + * Return that value as an int. Adjust the source pointer accordingly. + */ +extern int __unpack_nibbles(char **ptr, int count); + +#endif + +#endif // __BSP_HEX_UTILS_H__ Index: v2_0/misc/bsp/common/breakpoint.c =================================================================== --- v2_0/misc/bsp/common/breakpoint.c (nonexistent) +++ v2_0/misc/bsp/common/breakpoint.c (revision 1765) @@ -0,0 +1,97 @@ +//========================================================================== +// +// breakpoint.c +// +// Breakpoint generation. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Breakpoint generation. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include + +#ifndef DEBUG_BREAKPOINT +#define DEBUG_BREAKPOINT 0 +#endif + +#ifdef __ECOS__ +#include +#endif /* __ECOS__ */ + +/* + * Trigger a breakpoint exception. + */ +void +bsp_breakpoint(void) +{ +#if DEBUG_BREAKPOINT + bsp_printf("Before BP\n"); +#endif + +#ifdef __ECOS__ +# ifdef __NEED_UNDERSCORE__ + HAL_BREAKPOINT(_bsp_breakinsn); +# else + HAL_BREAKPOINT(bsp_breakinsn); +# endif +#else +# ifdef __NEED_UNDERSCORE__ + asm volatile (".globl _bsp_breakinsn\n" + "_bsp_breakinsn:\n"); +# else + asm volatile (".globl bsp_breakinsn\n" + "bsp_breakinsn:\n"); +# endif + BREAKPOINT(); +#endif + +#if DEBUG_BREAKPOINT + bsp_printf("After BP\n"); +#endif +} + Index: v2_0/misc/bsp/common/gdb.h =================================================================== --- v2_0/misc/bsp/common/gdb.h (nonexistent) +++ v2_0/misc/bsp/common/gdb.h (revision 1765) @@ -0,0 +1,103 @@ +#ifndef __BSP_COMMON_GDB_H__ +#define __BSP_COMMON_GDB_H__ +//========================================================================== +// +// gdb.h +// +// Definitions for GDB stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Definitions for GDB stub. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include "gdb-cpu.h" +#include + +#ifndef DEBUG_STUB +#define DEBUG_STUB 0 +#endif + +/* + * These need to match the same in devo/gdb/target.h + */ +#define TARGET_SIGNAL_INT 2 +#define TARGET_SIGNAL_ILL 4 +#define TARGET_SIGNAL_TRAP 5 +#define TARGET_SIGNAL_ABRT 6 +#define TARGET_SIGNAL_FPE 8 +#define TARGET_SIGNAL_BUS 10 +#define TARGET_SIGNAL_SEGV 11 + + +/* + * Socket to use for tcp/ip debug channel. + */ +#define GDB_TCP_SOCKET 1000 + + +#ifndef __ASSEMBLER__ + +/* generic gdb protocol handler */ +extern void _bsp_gdb_handler(int exc_nr, void *saved_regs); +extern gdb_data_t _bsp_gdb_data; + + +/* start forming an outgoing gdb packet */ +/* if ack is true, prepend an ack character */ +extern void _gdb_pkt_start(int ack); + +/* Append data to packet using formatted string. */ +extern void _gdb_pkt_append(char *fmt, ...); + +/* Calculate checksum and append to end of packet. */ +extern void _gdb_pkt_end(void); + +/* Send the packet. Blocks waiting for ACK */ +extern void _gdb_pkt_send(void); +#endif + +#endif //__BSP_COMMON_GDB_H__ Index: v2_0/misc/bsp/common/printf.c =================================================================== --- v2_0/misc/bsp/common/printf.c (nonexistent) +++ v2_0/misc/bsp/common/printf.c (revision 1765) @@ -0,0 +1,95 @@ +//========================================================================== +// +// printf.c +// +// Light-weight BSP printf. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Light-weight BSP printf. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include "bsp_if.h" + + +void +bsp_vprintf(const char *fmt, va_list ap) +{ + __vprintf(bsp_console_putc, fmt, ap); +} + + +void +bsp_dvprintf(const char *fmt, va_list ap) +{ + __vprintf(bsp_debug_putc, fmt, ap); +} + + +void +bsp_printf(const char *fmt, ...) +{ + va_list ap; + + va_start (ap, fmt); + __vprintf(bsp_console_putc, fmt, ap); + va_end (ap); +} + + +void +bsp_dprintf(const char *fmt, ...) +{ + va_list ap; + + va_start (ap, fmt); + __vprintf(bsp_debug_putc, fmt, ap); + va_end (ap); +} + + + Index: v2_0/misc/bsp/common/bsp_if.c =================================================================== --- v2_0/misc/bsp/common/bsp_if.c (nonexistent) +++ v2_0/misc/bsp/common/bsp_if.c (revision 1765) @@ -0,0 +1,160 @@ +//========================================================================== +// +// bsp_if.c +// +// Miscellaneous BSP Interfaces. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Miscellaneous BSP Interfaces. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include "bsp_if.h" + +/* + * Install a debug handler. + * Returns old handler being replaced. + */ +bsp_handler_t +bsp_install_dbg_handler(bsp_handler_t new_handler) +{ + bsp_handler_t old_handler; + + old_handler = *bsp_shared_data->__dbg_vector; + *bsp_shared_data->__dbg_vector = new_handler; + + return old_handler; +} + +/* + * Sometimes it is desireable to call the debug handler directly. This routine + * accomplishes that. It is the responsibility of the caller to insure that + * interrupts are disabled before calling this routine. + */ +void +bsp_invoke_dbg_handler(int exc_nr, void *regs) +{ + (*bsp_shared_data->__dbg_vector)(exc_nr, regs); +} + +/* + * Install a 'kill' handler. + * Returns old handler being replaced. + */ +bsp_handler_t +bsp_install_kill_handler(bsp_handler_t new_handler) +{ + bsp_handler_t old_handler; + + old_handler = bsp_shared_data->__kill_vector; + bsp_shared_data->__kill_vector = new_handler; + + return old_handler; +} + + +void * +bsp_cpu_data(void) +{ + return bsp_shared_data->__cpu_data; +} + + +void * +bsp_board_data(void) +{ + return bsp_shared_data->__board_data; +} + + +int +bsp_sysinfo(enum bsp_info_id id, ...) +{ + int retval; + va_list ap; + + va_start (ap, id); + retval = bsp_shared_data->__sysinfo(id, ap); + va_end(ap); + return retval; +} + +int +bsp_set_debug_comm(int id) +{ + return bsp_shared_data->__set_debug_comm(id); +} + +int +bsp_set_console_comm(int id) +{ + return bsp_shared_data->__set_console_comm(id); +} + +int +bsp_set_serial_baud(int id, int baud) +{ + return bsp_shared_data->__set_serial_baud(id, baud); +} + + +#if !defined(NDEBUG) + +void _bsp_assert(const char *file, const int line, const char *condition) +{ + bsp_printf("Assertion \"%s\" failed\n", condition); + bsp_printf("File \"%s\"\n", file); + bsp_printf("Line %d\n", line); +#if defined(PORT_TOGGLE_DEBUG) + PORT_TOGGLE_DEBUG(); +#else + while(1) ; +#endif /* defined(PORT_TOGGLE_DEBUG) */ +} + +#endif /* !defined(NDEBUG) */ + Index: v2_0/misc/bsp/common/console-io.c =================================================================== --- v2_0/misc/bsp/common/console-io.c (nonexistent) +++ v2_0/misc/bsp/common/console-io.c (revision 1765) @@ -0,0 +1,140 @@ +//========================================================================== +// +// console-io.c +// +// BSP Console Channel Interfaces. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: BSP Console Channel Interfaces. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include +#include "bsp_if.h" + +static unsigned char __console_ungetc; + +void +bsp_console_write(const char *p, int len) +{ + struct bsp_comm_procs *com; + + if ((com = bsp_shared_data->__console_procs) != NULL) + com->__write(com->ch_data, p, len); + else + bsp_debug_write(p, len); +} + + +int +bsp_console_read(char *p, int len) +{ + struct bsp_comm_procs *com; + + if (len <= 0) + return 0; + + if ((com = bsp_shared_data->__console_procs) != NULL) { + if (__console_ungetc) { + *p = __console_ungetc; + __console_ungetc = 0; + return 1; + } + return com->__read(com->ch_data, p, len); + } else + return bsp_debug_read(p, len); +} + +/*#define PRINTABLE_ONLY*/ +#ifdef PRINTABLE_ONLY +#include +#endif /* PRINTABLE_ONLY */ + +void +bsp_console_putc(char ch) +{ + struct bsp_comm_procs *com; + +#ifdef PRINTABLE_ONLY + if ((!isprint(ch)) && (!isspace(ch))) + ch = '.'; +#endif /* PRINTABLE_ONLY */ + + if ((com = bsp_shared_data->__console_procs) != NULL) + com->__putc(com->ch_data, ch); + else + bsp_debug_putc(ch); +} + +int +bsp_console_getc(void) +{ + struct bsp_comm_procs *com; + int ch; + + if ((com = bsp_shared_data->__console_procs) != NULL) { + if (__console_ungetc) { + ch = __console_ungetc; + __console_ungetc = 0; + return ch; + } + return com->__getc(com->ch_data); + } else + return bsp_debug_getc(); +} + + +void +bsp_console_ungetc(char ch) +{ + if (bsp_shared_data->__console_procs != NULL) + __console_ungetc = (unsigned char)ch; + else + bsp_debug_ungetc(ch); +} + + Index: v2_0/misc/bsp/common/bsp_if.h =================================================================== --- v2_0/misc/bsp/common/bsp_if.h (nonexistent) +++ v2_0/misc/bsp/common/bsp_if.h (revision 1765) @@ -0,0 +1,433 @@ +#ifndef __BSP_COMMON_BSP_IF_H__ +#define __BSP_COMMON_BSP_IF_H__ +//========================================================================== +// +// bsp_if.h +// +// BSP interface definitions. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: BSP interface definitions. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include + +/* + * Maximum number of interrupt controllers supported by + * this bsp. + */ +#define BSP_MAX_IRQ_CONTROLLERS 8 + +#ifndef __ASSEMBLER__ + + +/* + * Interrupt controller abstraction. + * Each interrupt controller on a given board should be described using + * this data structure. + */ +struct bsp_irq_controller { + /* + * First and last irqs handled by this controller. + */ + short first; + short last; + + /* + * pointer to array of bsp_vec struct pointers. These are + * the heads of the linked list of ISRs for each irq handled + * by this controller. + */ + bsp_vec_t **vec_list; + + /* + * Pointer to initialization routine which is run once at boot time. + */ + void (*init)(const struct bsp_irq_controller *__ic); + + /* + * Pointer to routines used to disable and enable interrupts handled + * by this controller. + */ + int (*disable)(const struct bsp_irq_controller *__ic, + int __irq_nr); + void (*enable)(const struct bsp_irq_controller *__ic, + int __irq_nr); +}; + + +/* + * Board specific code needs to provide at least one communication channel + * for use as the debug and console (stdio) channel. For each channel, + * there must be a set of function vectors for the common BSP code to + * control the channel. + */ +struct bsp_comm_procs { + /* + * Implementation dependent data pointer passed to the following procs. + */ + void *ch_data; + + /* + * Write a buffer of the given length. All of buffer is sent before + * the write call returns. + */ + void (*__write)(void *ch_data, const char *buf, int len); + + /* + * Fill a buffer with up to the given length. Returns the actual number + * of characters read. + */ + int (*__read)(void *ch_data, char *buf, int len); + + /* + * Send a single character. + */ + void (*__putc)(void *ch_data, char ch); + + /* + * Read a single character. If no character is immediately available, will + * block until one becomes available. + */ + int (*__getc)(void *ch_data); + + /* + * Catchall comm port control. + */ + int (*__control)(void *ch_data, int func, ...); + + /* + * For serial ports, the control function may be used to set and get the + * current baud rate. Usage: + * + * err = (*__control)(COMMCTL_SETBAUD, int bits_per_second); + * err => Zero if successful, -1 if error. + * + * baud = (*__control)(COMMCTL_GETBAUD); + * baud => -1 if error, current baud otherwise. + */ +#define COMMCTL_SETBAUD 0 +#define COMMCTL_GETBAUD 1 + + /* + * Install and remove debugger interrupt handlers. These are the receiver + * interrupt routines which are used to change control from a running + * program to the debugger stub. + */ +#define COMMCTL_INSTALL_DBG_ISR 2 +#define COMMCTL_REMOVE_DBG_ISR 3 + + /* + * Disable comm port interrupt. Returns TRUE if interrupt was enabled, + * FALSE otherwise. + */ +#define COMMCTL_IRQ_DISABLE 4 + /* + * Enable comm port interrupt. + */ +#define COMMCTL_IRQ_ENABLE 5 +}; + + +/* + * The board specific code uses this data structure to provide information + * about and procedure vectors for each supported communication channel. + * See _bsp_comm_list below. + */ +struct bsp_comm_channel { + struct bsp_comm_info info; + struct bsp_comm_procs procs; +}; + + +/* + * Number to place in the version field. If structure is changed + * in a way which is not backwards compatible, this number should + * be incremented. + */ +#define BSP_SHARED_DATA_VERSION 2 + +/* + * Clients of this BSP will need to have access to BSP functions and + * data structures. Because, the client and the BSP may not be linked + * together, a structure of vectors is used to gain this access. A + * pointer to this structure can be gotten via a syscall. This syscall + * is made automatically from within the crt0.o file. + */ +typedef struct { + int version; /* version number for future expansion */ + + /* + * Pointer to the array of pointers to interrupt controller descriptors. + */ + const struct bsp_irq_controller **__ictrl_table; + + /* + * Pointer to the array of exception vectors. + */ + bsp_vec_t **__exc_table; + + /* + * Pointer to debug handler vector. + */ + bsp_handler_t *__dbg_vector; + + /* + * User hook to catch debugger 'kill' command. + */ + bsp_handler_t __kill_vector; + + /* + * Vectored functions for console and debug i/o. + */ + struct bsp_comm_procs *__console_procs; + struct bsp_comm_procs *__debug_procs; + + /* + * Vectored cache control functions. + */ + void (*__flush_dcache)(void *__p, int __nbytes); + void (*__flush_icache)(void *__p, int __nbytes); + + /* + * Generic data pointers + */ + void *__cpu_data; + void *__board_data; + + /* + * General BSP information access. + * See bsp.h for details. + */ + int (*__sysinfo)(enum bsp_info_id __id, va_list __ap); + + /* + * Set or get active debug and console channels. + * Returns -1 if unsucessful. + * If the passed in __comm_id is -1, then the id of the current channel + * is returned. + */ + int (*__set_debug_comm)(int __comm_id); + int (*__set_console_comm)(int __comm_id); + + /* + * Set or get the current baud rate of a serial comm channel. + * Returns -1 on if unsuccessful. + * If the given baud is -1, then the current baudrate is returned. + */ + int (*__set_serial_baud)(int __comm_id, int baud); + + /* + * Debug agent data. + */ + void *__dbg_data; + + /* + * Reset function + * We want to avoid calling this with a trap since + * we may be calling it from SWI mode (in cygmon). + * That is problematic, as nested SWI's are not + * very good. + */ + void (*__reset)(void); + + /* + * TRUE if console interrupt detected during program output. + */ + int __console_interrupt_flag; + +} bsp_shared_t; + + +extern bsp_shared_t *bsp_shared_data; + +/* + * Platform info which may be overriden/modified by arch/board specific code. + */ +extern struct bsp_platform_info _bsp_platform_info; + +/* + * Cache info which may be overriden/modified by arch/board specific code. + */ +extern struct bsp_cachesize_info _bsp_dcache_info; +extern struct bsp_cachesize_info _bsp_icache_info; +extern struct bsp_cachesize_info _bsp_scache_info; + +/* + * Array of comm channel descriptors which must be provided by board specific + * code. + */ +extern struct bsp_comm_channel _bsp_comm_list[]; + +/* + * Number of comm channel descriptors which must be provided by board specific + * code. + */ +extern int _bsp_num_comms; + + +/* + * Array of memory region descriptors which must be provided by board specific + * code. + */ +extern struct bsp_mem_info _bsp_memory_list[]; + +/* + * Number of memory region descriptors which must be provided by board specific + * code. + */ +extern int _bsp_num_mem_regions; + +/* + * In order to construct the above _bsp_memory_list, some board specific + * code may have to size RAM regions. To do this easily and reliably, + * the code needs to run from ROM before .bss and .data sections are + * initialized. This leads to the problem of where to store the results + * of the memory sizing tests. In this case, the _bsp_init_stack routine + * which sizes memory and sets up the stack will place the board-specific + * information on the stack and return with the stack pointer pointing to + * a pointer to the information. That is, addr_of_info = *(void **)sp. + * The architecture specific code will then copy that pointer to the + * _bsp_ram_info_ptr variable after initializing the .data and .bss sections. + */ +extern void *_bsp_ram_info_ptr; + +/* + * Generic bsp initialization. Called by low level startup code + */ +extern void _bsp_init(void); + +/* + * Initialize board communication in polling mode. This enables + * debugging printf for later initializations. Interrupts for + * comm channels may be set up later in _bsp_board_init(). + */ +extern void _bsp_init_board_comm(void); + +/* + * Make generic BSP aware of CPU/MCU specific interrupt controllers. + */ +extern void _bsp_install_cpu_irq_controllers(void); + +/* + * Make generic BSP aware of board specific interrupt controllers. + */ +extern void _bsp_install_board_irq_controllers(void); + +/* + * Callback used by above two routines to install a single + * interrupt controller. + */ +extern void _bsp_install_irq_controller(const struct bsp_irq_controller *__ic); + +/* + * Generic exception dispatch routine. Usually called from asm-level + * exception handler to call vectors in vector chain for the given + * exception number. Stops traversing vector chain when a called + * vector returns a non-zero value. If no vector returns non-zero, + * a default error message and register dump is printed. + */ +extern int _bsp_exc_dispatch(int __exc_number, void *__regs); + + +/* + * Architecture specific routine to dump register values. + */ +extern void _bsp_dump_regs(void *__regs); + + +/* + * Generic syscall handler called by architecture specific handler. + * Returns non-zero if given 'func' number was handled by the generic + * code, zero otherwise. If handled, the syscall error is returned + * via the err_ptr. + */ +extern int _bsp_do_syscall(int __func, + long __arg1, long __arg2, long __arg3, long __arg4, + int *__err_ptr); + + +extern void _bsp_cpu_init(void); +extern void _bsp_board_init(void); + + +/* + * General interface for getting certain BSP parameters. + * See bsp.h for details. + */ +extern int _bsp_sysinfo(enum bsp_info_id __id, va_list __ap); + +/* + * Called from comm channel when a connection to host is closed. + */ +extern void _bsp_dbg_connect_abort(void); + + +/* + * Pointer to a network channel. NULL if no network channel + * exists. + */ +extern struct bsp_comm_channel *_bsp_net_channel; + + +/* + * Formatted output primitive. + */ +extern void __vprintf(void (*putc_func)(char c), const char *fmt0, va_list ap); + + + +#endif /* !__ASSEMBLER__ */ + +/* + * SYSCALL number to use to get pointer to above bsp_shared_t structure. + */ +#define BSP_GET_SHARED 0xbaad + +#endif // __BSP_COMMON_BSP_IF_H__ + + Index: v2_0/misc/bsp/common/bsp_cache.c =================================================================== --- v2_0/misc/bsp/common/bsp_cache.c (nonexistent) +++ v2_0/misc/bsp/common/bsp_cache.c (revision 1765) @@ -0,0 +1,70 @@ +//========================================================================== +// +// bsp_cache.c +// +// BSP Cache Interfaces. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: BSP Cache Interfaces. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include "bsp_if.h" + +void +bsp_flush_dcache(void *p, int nbytes) +{ + bsp_shared_data->__flush_dcache(p, nbytes); +} + + +void +bsp_flush_icache(void *p, int nbytes) +{ + bsp_shared_data->__flush_icache(p, nbytes); +} + + Index: v2_0/misc/bsp/common/syscall.c =================================================================== --- v2_0/misc/bsp/common/syscall.c (nonexistent) +++ v2_0/misc/bsp/common/syscall.c (revision 1765) @@ -0,0 +1,218 @@ +//========================================================================== +// +// syscall.c +// +// Minimal generic syscall support. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Minimal generic syscall support. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include +#include +#include +#include "bsp_if.h" +#include "syscall.h" + +/* + * read -- read bytes from the serial port. Ignore fd, since + * we only have stdin. + */ +static int +sys_read(int fd, char *buf, int nbytes) +{ + int i = 0; + + for (i = 0; i < nbytes; i++) { + *(buf + i) = bsp_console_getc(); + if ((*(buf + i) == '\n') || (*(buf + i) == '\r')) { + (*(buf + i + 1)) = 0; + break; + } + } + return (i); +} + + +/* + * write -- write bytes to the serial port. Ignore fd, since + * stdout and stderr are the same. Since we have no filesystem, + * open will only return an error. + */ +static int +sys_write(int fd, char *buf, int nbytes) +{ +#define WBUFSIZE 256 + char ch, lbuf[WBUFSIZE]; + int i, tosend; + + tosend = nbytes; + + while (tosend > 0) { + for (i = 0; tosend > 0 && i < (WBUFSIZE-2); tosend--) { + ch = *buf++; + if (ch == '\n') + lbuf[i++] = '\r'; + lbuf[i++] = ch; + } + bsp_console_write(lbuf, i); + } + + return (nbytes); +} + + +/* + * open -- open a file descriptor. We don't have a filesystem, so + * we return an error. + */ +static int +sys_open (const char *buf, int flags, int mode) +{ + return (-EIO); +} + + +/* + * close -- We don't need to do anything, but pretend we did. + */ +static int +sys_close(int fd) +{ + return (0); +} + + +/* + * lseek -- Since a serial port is non-seekable, we return an error. + */ +static int +sys_lseek(int fd, int offset, int whence) +{ +#ifdef ESPIPE + return (-ESPIPE); +#else + return (-EIO); +#endif +} + + +/* + * Generic syscall handler. + * + * Returns 0 if syscall number is not handled by this + * module, 1 otherwise. This allows applications to + * extend the syscall handler by using exception chaining. + */ +int +_bsp_do_syscall(int func, /* syscall function number */ + long arg1, long arg2, /* up to four args. */ + long arg3, long arg4, + int *retval) /* syscall return value */ +{ + int err = 0; + + switch (func) { + + case SYS_read: + err = sys_read((int)arg1, (char *)arg2, (int)arg3); + break; + + case SYS_write: + err = sys_write((int)arg1, (char *)arg2, (int)arg3); + break; + + case SYS_open: + err = sys_open((const char *)arg1, (int)arg2, (int)arg3); + break; + + case SYS_close: + err = sys_close((int)arg1); + break; + + case SYS_lseek: + err = sys_lseek((int)arg1, (int)arg2, (int)arg3); + break; + + case BSP_GET_SHARED: + *(bsp_shared_t **)arg1 = bsp_shared_data; + break; + + case SYS_meminfo: + { + // Return the top and size of memory. + struct bsp_mem_info mem; + int i; + unsigned long u, totmem, topmem, numbanks; + + i = totmem = topmem = numbanks = 0; + while (bsp_sysinfo(BSP_INFO_MEMORY, i++, &mem) == 0) + { + if (mem.kind == BSP_MEM_RAM) + { + numbanks++; + totmem += mem.nbytes; + u = (unsigned long)mem.virt_start + mem.nbytes; + if (u > topmem) + topmem = u; + } + } + *(unsigned long *)arg1 = totmem; + *(unsigned long *)arg2 = topmem; + *retval = numbanks; + } + return 1; + break; + + default: + return 0; + } + + *retval = err; + return 1; +} + + Index: v2_0/misc/bsp/common/singlestep.c =================================================================== --- v2_0/misc/bsp/common/singlestep.c (nonexistent) +++ v2_0/misc/bsp/common/singlestep.c (revision 1765) @@ -0,0 +1,61 @@ +//========================================================================== +// +// singlestep.c +// +// Architecture specific single-step support +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +#include + +#ifdef CYGPKG_HAL_ARM +#include "bsp/arm/singlestep.c" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "bsp/mips/singlestep.c" +#endif Index: v2_0/misc/bsp/common/shared-data.c =================================================================== --- v2_0/misc/bsp/common/shared-data.c (nonexistent) +++ v2_0/misc/bsp/common/shared-data.c (revision 1765) @@ -0,0 +1,59 @@ +//========================================================================== +// +// shared-data.c +// +// Declaration of bsp shared data pointer. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Declaration of bsp shared data pointer. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include "bsp_if.h" + +bsp_shared_t *bsp_shared_data; + + Index: v2_0/misc/bsp/common/syscall.h =================================================================== --- v2_0/misc/bsp/common/syscall.h (nonexistent) +++ v2_0/misc/bsp/common/syscall.h (revision 1765) @@ -0,0 +1,50 @@ +/* General use syscall.h file. + The more ports that use this file, the simpler sim/common/nltvals.def + remains. */ + +#ifndef LIBGLOSS_SYSCALL_H +#define LIBGLOSS_SYSCALL_H + +/* Note: This file may be included by assembler source. */ + +/* These should be as small as possible to allow a port to use a trap type + instruction, which the system call # as the trap (the d10v for instance + supports traps 0..31). An alternative would be to define one trap for doing + system calls, and put the system call number in a register that is not used + for the normal calling sequence (so that you don't have to shift down the + arguments to add the system call number). Obviously, if these system call + numbers are ever changed, all of the simulators and potentially user code + will need to be updated. */ + +/* There is no current need for the following: SYS_execv, SYS_creat, SYS_wait, + etc. etc. Don't add them. */ + +/* These are required by the ANSI C part of newlib (excluding system() of + course). */ +#define SYS_exit 1 +#define SYS_open 2 +#define SYS_close 3 +#define SYS_read 4 +#define SYS_write 5 +#define SYS_lseek 6 +#define SYS_unlink 7 +#define SYS_getpid 8 +#define SYS_kill 9 +#define SYS_fstat 10 +/*#define SYS_sbrk 11 - not currently a system call, but reserved. */ + +/* ARGV support. */ +#define SYS_argvlen 12 +#define SYS_argv 13 + +/* These are extras added for one reason or another. */ +#define SYS_chdir 14 +#define SYS_stat 15 +#define SYS_chmod 16 +#define SYS_utime 17 +#define SYS_time 18 + +#define SYS_interrupt 1000 + +#define SYS_meminfo 1001 +#endif Index: v2_0/misc/bsp/common/gdb-cpu.c =================================================================== --- v2_0/misc/bsp/common/gdb-cpu.c (nonexistent) +++ v2_0/misc/bsp/common/gdb-cpu.c (revision 1765) @@ -0,0 +1,61 @@ +//========================================================================== +// +// gdb-cpu.c +// +// Architecture specific support for GDB +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +#include + +#ifdef CYGPKG_HAL_ARM +#include "bsp/arm/gdb-cpu.c" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "bsp/mips/gdb-cpu.c" +#endif Index: v2_0/misc/bsp/common/hex-utils.c =================================================================== --- v2_0/misc/bsp/common/hex-utils.c (nonexistent) +++ v2_0/misc/bsp/common/hex-utils.c (revision 1765) @@ -0,0 +1,126 @@ +//========================================================================== +// +// hex-utils.c +// +// Utilities for dealing with hexadecimal strings. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include + +int +__hex(char ch) +{ + if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10); + if ((ch >= '0') && (ch <= '9')) return (ch-'0'); + if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10); + return (-1); +} + + +/* + * Convert the hex data in 'buf' into 'count' bytes to be placed in 'mem'. + * Returns a pointer to the character in mem AFTER the last byte written. + */ +char * +__unpack_bytes_to_mem(char *buf, char *mem, int count) +{ + int i; + char ch; + + for (i = 0; i < count; i++) { + ch = __hex(*buf++) << 4; + ch = ch + __hex(*buf++); + *mem++ = ch; + } + return(mem); +} + +/* + * While finding valid hex chars, build an unsigned long int. + * Return number of hex chars processed. + */ +int +__unpack_ulong(char **ptr, unsigned long *val) +{ + int numChars = 0; + int hexValue; + + *val = 0; + + while (**ptr) { + hexValue = __hex(**ptr); + if (hexValue >= 0) { + *val = (*val << 4) | hexValue; + numChars ++; + } else + break; + (*ptr)++; + } + return (numChars); +} + + +/* + * Unpack 'count' hex characters, forming them into a binary value. + * Return that value as an int. Adjust the source pointer accordingly. + */ +int +__unpack_nibbles(char **ptr, int count) +{ + int value = 0; + + while (--count >= 0) { + value = (value << 4) | __hex(**ptr); + (*ptr)++; + } + return value; +} + + Index: v2_0/misc/bsp/common/bsp.c =================================================================== --- v2_0/misc/bsp/common/bsp.c (nonexistent) +++ v2_0/misc/bsp/common/bsp.c (revision 1765) @@ -0,0 +1,341 @@ +//========================================================================== +// +// bsp.c +// +// General BSP support. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: General BSP support. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include +#include +#include "bsp_if.h" +#include "gdb.h" + +#ifndef DEBUG_BSP_INIT +#define DEBUG_BSP_INIT 0 +#endif + +struct bsp_comm_channel *_bsp_net_channel = NULL; + +/* + * This is the array of pointers to interrupt controller descriptors. + */ +static struct bsp_irq_controller *_bsp_ictrl_table[BSP_MAX_IRQ_CONTROLLERS]; + +/* + * This is the array of second-level exception vectors. + */ +static bsp_vec_t *_bsp_exc_table[BSP_MAX_EXCEPTIONS]; + + +/* + * Debug (default exception) handler vector. + */ +bsp_handler_t _bsp_dbg_vector; + + +static bsp_shared_t __bsp_shared = { + BSP_SHARED_DATA_VERSION, /* version */ + (const struct bsp_irq_controller **)&_bsp_ictrl_table[0], /* __ictrl_table */ + &_bsp_exc_table[0], /* __exc_table */ + &_bsp_dbg_vector, /* __dbg_vector */ + (bsp_handler_t)0, /* __kill_vector */ + (struct bsp_comm_procs *)NULL, /* __console_procs */ + (struct bsp_comm_procs *)NULL, /* __debug_procs */ + (void (*)(void *, int ))NULL, /* __flush_dcache */ + (void (*)(void *, int ))NULL, /* __flush_icache */ + (void (*)(void ))NULL, /* __reset */ + (void*)NULL, /* __cpu_data */ + (void*)NULL /* __board_data */ +}; + + +static void +default_cache_proc(void *p, int nbytes) +{ + /* do nothing */ +} + + +static void +default_reset_proc(void) +{ + /* do nothing */ +} + + +static int +find_comm_id(struct bsp_comm_procs *procs) +{ + int i; + + for (i = 0; i < _bsp_num_comms; i++) + if (&_bsp_comm_list[i].procs == procs) + return i; + + if (procs == &_bsp_net_channel->procs) + return _bsp_num_comms; + + return -1; +} + + +/* + * Set or get active debug channel. + * Returns -1 if unsucessful. + * If the passed in comm id is -1, then the id of the current channel + * is returned. + */ +static int +set_debug_comm(int id) +{ + struct bsp_comm_channel *chan; + struct bsp_comm_procs *procs; + int current_chan = find_comm_id(bsp_shared_data->__debug_procs); + + if (id < 0) + return current_chan; + + if (id > _bsp_num_comms) + return -1; + + if (id == _bsp_num_comms && _bsp_net_channel == NULL) + return -1; + + if (id == current_chan) + return 0; + + /* Remove existing channel */ + if ((procs = bsp_shared_data->__debug_procs) != NULL) + (*procs->__control)(procs->ch_data, COMMCTL_REMOVE_DBG_ISR); + + /* Install new channel */ + if (id == _bsp_num_comms) + chan = _bsp_net_channel; + else + chan = &_bsp_comm_list[id]; + bsp_shared_data->__debug_procs = &chan->procs; + (*chan->procs.__control)(chan->procs.ch_data, COMMCTL_INSTALL_DBG_ISR); + + return 0; +} + + +/* + * Set or get active console channel. + * Returns -1 if unsucessful. + * If the passed in comm id is -1, then the id of the current channel + * is returned. + */ +static int +set_console_comm(int id) +{ + int current_chan = find_comm_id(bsp_shared_data->__console_procs); + + if (id < 0) + return current_chan; + + if (id > _bsp_num_comms) + return -1; + + if (id == _bsp_num_comms && _bsp_net_channel == NULL) + return -1; + + if (id == current_chan) + return 0; + + /* + * Install new channel. If its the same as the debug channel, + * just clear the __console_procs and the bsp_console_* + * interface functions will take care of the rest. + */ + if (id == _bsp_num_comms) + bsp_shared_data->__console_procs = &_bsp_net_channel->procs; + else + bsp_shared_data->__console_procs = &_bsp_comm_list[id].procs; + + if (bsp_shared_data->__console_procs == bsp_shared_data->__debug_procs) + bsp_shared_data->__console_procs = NULL; + + return 0; +} + + +/* + * Set or get the current baud rate of a serial comm channel. + * Returns -1 on if unsuccessful. + * If the given baud is -1, then the current baudrate is returned. + */ +int +set_serial_baud(int id, int baud) +{ + struct bsp_comm_channel *chan; + + if (id < 0 || id >= _bsp_num_comms) + return -1; + + chan = &_bsp_comm_list[id]; + + if (chan->info.kind != BSP_COMM_SERIAL) + return -1; + + if (baud == -1) + return (*chan->procs.__control)(chan->procs.ch_data, + COMMCTL_GETBAUD); + + return (*chan->procs.__control)(chan->procs.ch_data, + COMMCTL_SETBAUD, baud); +} + +/* + * Final initialization before calling main. + */ +void +_bsp_init(void) +{ + struct bsp_comm_procs *com; + extern void __init_irq_controllers(void); + + bsp_shared_data = &__bsp_shared; + _bsp_dbg_vector = (bsp_handler_t)_bsp_gdb_handler; + bsp_shared_data->__dbg_data = &_bsp_gdb_data; + + bsp_shared_data->__flush_dcache = default_cache_proc; + bsp_shared_data->__flush_icache = default_cache_proc; + + bsp_shared_data->__reset = default_reset_proc; + + /* + * General BSP information access. + */ + bsp_shared_data->__sysinfo = _bsp_sysinfo; + + /* + * Setup comm port handlers. + */ + bsp_shared_data->__set_debug_comm = set_debug_comm; + bsp_shared_data->__set_console_comm = set_console_comm; + bsp_shared_data->__set_serial_baud = set_serial_baud; + + /* + * Very first thing is to initialize comm channels so + * we can have debug printfs working. None of this + * must rely on interrupts until interrupt controllers + * are initialized below. + */ + _bsp_init_board_comm(); + + /* + * Assume first comm channel is the default. + */ + bsp_shared_data->__debug_procs = &_bsp_comm_list[0].procs; + + /* + * By default, console i/o goes through the debug channel. + * We indicate this by making the console i/o procs + * pointer NULL. + */ + bsp_shared_data->__console_procs = NULL; + + /* + * Install interrupt controllers. + */ +#if DEBUG_BSP_INIT + bsp_printf("Installing interrupt controllers...\n"); +#endif + + _bsp_install_cpu_irq_controllers(); + _bsp_install_board_irq_controllers(); + +#if DEBUG_BSP_INIT + bsp_printf("Done installing interrupt controllers.\n"); + bsp_printf("Initializing interrupt controllers...\n"); +#endif + /* + * Actually run the init routines for all installed + * interrupt controllers. + */ + __init_irq_controllers(); + +#if DEBUG_BSP_INIT + bsp_printf("Done initializing interrupt controllers.\n"); + bsp_printf("CPU-specific initialization...\n"); +#endif + + /* + * Final architecture specific initialization. + */ + _bsp_cpu_init(); + +#if DEBUG_BSP_INIT + bsp_printf("Done w/ CPU-specific initialization.\n"); + bsp_printf("Board specific initialization...\n"); +#endif + /* + * Final board specific initialization. + */ + _bsp_board_init(); + +#if DEBUG_BSP_INIT + bsp_printf("Done w/ board specific initialization.\n"); +#endif + + /* + * Now we can install the debug interrupt handler on the debug channel. + */ + com = bsp_shared_data->__debug_procs; + (*com->__control)(com->ch_data, COMMCTL_INSTALL_DBG_ISR); + + + if (_bsp_net_channel != NULL) { + set_debug_comm(_bsp_num_comms); + set_console_comm(0); + } +} Index: v2_0/misc/bsp/common/sprintf.c =================================================================== --- v2_0/misc/bsp/common/sprintf.c (nonexistent) +++ v2_0/misc/bsp/common/sprintf.c (revision 1765) @@ -0,0 +1,86 @@ +//========================================================================== +// +// sprintf.c +// +// Light-weight BSP sprintf. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Light-weight BSP sprintf. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include "bsp_if.h" + +static char *str_ptr; + +static void +str_putc(char ch) +{ + *str_ptr++ = ch; +} + +int +bsp_vsprintf(char *str, const char *fmt, va_list ap) +{ + str_ptr = str; + __vprintf(str_putc, fmt, ap); + *str_ptr = '\0'; + return str_ptr - str; +} + + +void +bsp_sprintf(char *str, const char *fmt, ...) +{ + va_list ap; + + va_start (ap, fmt); + bsp_vsprintf(str, fmt, ap); + va_end (ap); +} + + Index: v2_0/misc/bsp/common/gdb-cpu.h =================================================================== --- v2_0/misc/bsp/common/gdb-cpu.h (nonexistent) +++ v2_0/misc/bsp/common/gdb-cpu.h (revision 1765) @@ -0,0 +1,65 @@ +#ifndef __BSP_COMMON_GDB_CPU_H__ +#define __BSP_COMMON_GDB_CPU_H__ +//========================================================================== +// +// gdb-cpu.h +// +// CPU specifics for GDB +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +#include + +#ifdef CYGPKG_HAL_ARM +#include "../arm/gdb-cpu.h" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "../mips/gdb-cpu.h" +#endif + +#endif // __BSP_COMMON_GDB_CPU_H__ Index: v2_0/misc/bsp/common/generic-mem.c =================================================================== --- v2_0/misc/bsp/common/generic-mem.c (nonexistent) +++ v2_0/misc/bsp/common/generic-mem.c (revision 1765) @@ -0,0 +1,194 @@ +//========================================================================== +// +// generic-mem.c +// +// Generic support for safe memory read/write. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Generic support for safe memory read/write. +// Description: Some targets may need to provide their own version. +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include +#include +#include + +typedef void (*moveproc_t)(void *s, void *d); + +static jmp_buf __errjmp; + +/* + * These are globals because we want them preserved + * across function calls. + */ +static bsp_handler_t __oldtrap; +static int __done; + + +static void +move_8(void *src, void *dest) +{ + *(char *)dest = *(char *)src; +} + + +static void +move_16(void *src, void *dest) +{ + *(short *)dest = *(short *)src; +} + + +static void +move_32(void *src, void *dest) +{ + *(int *)dest = *(int *)src; +} + + +static int +err_trap(int exc_nr, void *regs) +{ + longjmp(__errjmp, 1); +} + + +int +bsp_memory_read(void *addr, /* start addr of memory to read */ + int asid, /* address space id */ + int rsize, /* size of individual read operation */ + int nreads, /* number of read operations */ + void *buf) /* result buffer */ +{ + if (nreads <= 0) + return 0; + + __oldtrap = bsp_install_dbg_handler(err_trap); + + if (setjmp(__errjmp) == 0) { + moveproc_t move_mem; + int incr; + char *src, *dest; + + switch (rsize) { + case 8: + move_mem = move_8; + incr = 1; + break; + case 16: + move_mem = move_16; + incr = 2; + break; + case 32: + move_mem = move_32; + incr = 4; + break; + default: + (void)bsp_install_dbg_handler(__oldtrap); + return 0; + } + + src = addr; + dest = buf; + + for (__done = 0; __done < nreads; __done++) { + move_mem(src, dest); + src += incr; + dest += incr; + } + } + + (void)bsp_install_dbg_handler(__oldtrap); + return __done; +} + + +int bsp_memory_write(void *addr, /* start addr of memory to write */ + int asid, /* address space id */ + int wsize, /* size of individual write operation */ + int nwrites, /* number of write operations */ + void *buf) /* source buffer for write data */ +{ + if (nwrites <= 0) + return 0; + + __oldtrap = bsp_install_dbg_handler(err_trap); + + if (setjmp(__errjmp) == 0) { + moveproc_t move_mem; + int incr; + char *src, *dest; + + switch (wsize) { + case 8: + move_mem = move_8; + incr = 1; + break; + case 16: + move_mem = move_16; + incr = 2; + break; + case 32: + move_mem = move_32; + incr = 4; + break; + default: + (void)bsp_install_dbg_handler(__oldtrap); + return 0; + } + + src = buf; + dest = addr; + + for (__done = 0; __done < nwrites; __done++) { + move_mem(src, dest); + src += incr; + dest += incr; + } + } + + (void)bsp_install_dbg_handler(__oldtrap); + return __done; +} Index: v2_0/misc/bsp/common/vprintf.c =================================================================== --- v2_0/misc/bsp/common/vprintf.c (nonexistent) +++ v2_0/misc/bsp/common/vprintf.c (revision 1765) @@ -0,0 +1,445 @@ +//========================================================================== +// +// vprintf.c +// +// Stripped down (no floating point) for debugging printf in ROMable BSP. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +/* + * Copyright (c) 1990, 1999 The Regents of the University of California. + * All rights reserved. + * + * This code is derived from software contributed to Berkeley by + * Chris Torek. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * Stripped down (no floating point) for debugging printf in ROMable BSP. + */ +#include +#include + +#define BUF 40 + +#ifndef NULL +#define NULL ((void *)0) +#endif + +/* + * Macros for converting digits to letters and vice versa + */ +#define to_digit(c) ((c) - '0') +#define is_digit(c) ((unsigned)to_digit(c) <= 9) +#define to_char(n) ((n) + '0') + +/* + * Flags used during conversion. + */ +#define ALT 0x001 /* alternate form */ +#define HEXPREFIX 0x002 /* add 0x or 0X prefix */ +#define LADJUST 0x004 /* left adjustment */ +#define LONGDBL 0x008 /* long double; unimplemented */ +#define LONGINT 0x010 /* long integer */ +#define QUADINT 0x020 /* quad integer */ +#define SHORTINT 0x040 /* short integer */ +#define ZEROPAD 0x080 /* zero (as opposed to blank) pad */ +#define FPT 0x100 /* Floating point number */ + + +void +__vprintf(void (*putc_func)(char c), const char *fmt0, va_list ap) +{ + char *fmt; /* format string */ + int ch; /* character from fmt */ + int n, m; /* handy integers (short term usage) */ + char *cp; /* handy char pointer (short term usage) */ + int flags; /* flags as above */ + int width; /* width from format (%8d), or 0 */ + int prec; /* precision from format (%.3d), or -1 */ + char sign; /* sign prefix (' ', '+', '-', or \0) */ + unsigned long _uquad; + enum {OCT, DEC, HEX} base; /* base for [diouxX] conversion */ + int dprec; /* a copy of prec if [diouxX], 0 otherwise */ + int realsz; /* field size expanded by dprec */ + int size; /* size of converted field or string */ + char *xdigs = NULL; /* digits for [xX] conversion */ + char buf[BUF]; /* space for %c, %[diouxX], %[eEfgG] */ + char ox[2]; /* space for 0x hex-prefix */ + +#define PRINT(ptr, len) { \ + for(n=0;n<(len);n++) { \ + if((ptr)[n] == '\n') \ + (*putc_func)('\r'); \ + (*putc_func)((ptr)[n]); \ + } \ +} + +#define PAD(howmany, with) { \ + if ((n = (howmany)) > 0) { \ + while (n--) \ + (*putc_func)(with); \ + } \ +} + + /* + * To extend shorts properly, we need both signed and unsigned + * argument extraction methods. + */ +#define SARG() \ + (flags&LONGINT ? va_arg(ap, long) : \ + flags&SHORTINT ? (long)(short)va_arg(ap, int) : \ + (long)va_arg(ap, int)) + +#define UARG() \ + (flags&LONGINT ? va_arg(ap, unsigned long) : \ + flags&SHORTINT ? (unsigned long)(unsigned short)va_arg(ap, int) : \ + (unsigned long)va_arg(ap, unsigned int)) + + fmt = (char *)fmt0; + + /* + * Scan the format for conversions (`%' character). + */ + for (;;) { + cp = fmt; + while (*fmt && *fmt != '%') + fmt++; + if ((m = fmt - cp) != 0) { + PRINT(cp, m); + } + + if (*fmt) + fmt++; /* skip over '%' */ + else + goto done; + + flags = 0; + dprec = 0; + width = 0; + prec = -1; + sign = '\0'; + + rflag: + ch = *fmt++; + reswitch: + switch (ch) { + case ' ': + /* + * ``If the space and + flags both appear, the space + * flag will be ignored.'' + * -- ANSI X3J11 + */ + if (!sign) + sign = ' '; + goto rflag; + case '#': + flags |= ALT; + goto rflag; + case '*': + /* + * ``A negative field width argument is taken as a + * - flag followed by a positive field width.'' + * -- ANSI X3J11 + * They don't exclude field widths read from args. + */ + if ((width = va_arg(ap, int)) >= 0) + goto rflag; + width = -width; + /* FALLTHROUGH */ + case '-': + flags |= LADJUST; + goto rflag; + case '+': + sign = '+'; + goto rflag; + case '.': + if ((ch = *fmt++) == '*') { + n = va_arg(ap, int); + prec = n < 0 ? -1 : n; + goto rflag; + } + n = 0; + while (is_digit(ch)) { + n = 10 * n + to_digit(ch); + ch = *fmt++; + } + prec = n < 0 ? -1 : n; + goto reswitch; + case '0': + /* + * ``Note that 0 is taken as a flag, not as the + * beginning of a field width.'' + * -- ANSI X3J11 + */ + flags |= ZEROPAD; + goto rflag; + case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + n = 0; + do { + n = 10 * n + to_digit(ch); + ch = *fmt++; + } while (is_digit(ch)); + width = n; + goto reswitch; + case 'h': + flags |= SHORTINT; + goto rflag; + case 'l': + if (*fmt == 'l') { + fmt++; + flags |= QUADINT; + } else { + flags |= LONGINT; + } + goto rflag; + case 'c': + *(cp = buf) = va_arg(ap, int); + size = 1; + sign = '\0'; + break; + case 'd': + case 'i': + _uquad = SARG(); + if ((long) _uquad < 0) + { + + _uquad = -_uquad; + sign = '-'; + } + base = DEC; + goto number; + case 'o': + _uquad = UARG(); + base = OCT; + goto nosign; + case 's': + if ((cp = va_arg(ap, char *)) == NULL) + cp = "(null)"; + if (prec >= 0) { + /* + * can't use strlen; can only look for the + * NUL in the first `prec' characters, and + * strlen() will go further. + */ + char *p = memchr(cp, 0, prec); + + if (p != NULL) { + size = p - cp; + if (size > prec) + size = prec; + } else + size = prec; + } else + size = strlen(cp); + sign = '\0'; + break; + case 'u': + _uquad = UARG(); + base = DEC; + goto nosign; + case 'X': + xdigs = "0123456789ABCDEF"; + goto hex; + case 'x': + xdigs = "0123456789abcdef"; + hex: _uquad = UARG(); + base = HEX; + /* leading 0x/X only if non-zero */ + if (flags & ALT && _uquad != 0) + flags |= HEXPREFIX; + + /* unsigned conversions */ + nosign: sign = '\0'; + /* + * ``... diouXx conversions ... if a precision is + * specified, the 0 flag will be ignored.'' + * -- ANSI X3J11 + */ + number: if ((dprec = prec) >= 0) + flags &= ~ZEROPAD; + + /* + * ``The result of converting a zero value with an + * explicit precision of zero is no characters.'' + * -- ANSI X3J11 + */ + cp = buf + BUF; + if (_uquad != 0 || prec != 0) { + /* + * Unsigned mod is hard, and unsigned mod + * by a constant is easier than that by + * a variable; hence this switch. + */ + switch (base) { + case OCT: + do { + *--cp = to_char(_uquad & 7); + _uquad >>= 3; + } while (_uquad); + /* handle octal leading 0 */ + if (flags & ALT && *cp != '0') + *--cp = '0'; + break; + + case DEC: + /* many numbers are 1 digit */ + while (_uquad >= 10) { + *--cp = to_char(_uquad % 10); + _uquad /= 10; + } + *--cp = to_char(_uquad); + break; + + case HEX: + do { + *--cp = xdigs[_uquad & 15]; + _uquad >>= 4; + } while (_uquad); + break; + + default: + cp = "bug in vfprintf: bad base"; + size = strlen(cp); + goto skipsize; + } + } + size = buf + BUF - cp; + skipsize: + break; + default: /* "%?" prints ?, unless ? is NUL */ + if (ch == '\0') + goto done; + /* pretend it was %c with argument ch */ + cp = buf; + *cp = ch; + size = 1; + sign = '\0'; + break; + } + + /* + * All reasonable formats wind up here. At this point, `cp' + * points to a string which (if not flags&LADJUST) should be + * padded out to `width' places. If flags&ZEROPAD, it should + * first be prefixed by any sign or other prefix; otherwise, + * it should be blank padded before the prefix is emitted. + * After any left-hand padding and prefixing, emit zeroes + * required by a decimal [diouxX] precision, then print the + * string proper, then emit zeroes required by any leftover + * floating precision; finally, if LADJUST, pad with blanks. + * + * Compute actual size, so we know how much to pad. + * size excludes decimal prec; realsz includes it. + */ + realsz = dprec > size ? dprec : size; + if (sign) + realsz++; + else if (flags & HEXPREFIX) + realsz+= 2; + + /* right-adjusting blank padding */ + if ((flags & (LADJUST|ZEROPAD)) == 0) + PAD(width - realsz, ' '); + + /* prefix */ + if (sign) { + PRINT(&sign, 1); + } else if (flags & HEXPREFIX) { + ox[0] = '0'; + ox[1] = ch; + PRINT(ox, 2); + } + + /* right-adjusting zero padding */ + if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD) + PAD(width - realsz, '0'); + + /* leading zeroes from decimal precision */ + PAD(dprec - size, '0'); + + /* the string or number proper */ + PRINT(cp, size); + + /* left-adjusting padding (always blank) */ + if (flags & LADJUST) + PAD(width - realsz, ' '); + } + done: +} + + Index: v2_0/misc/bsp/common/sysinfo.c =================================================================== --- v2_0/misc/bsp/common/sysinfo.c (nonexistent) +++ v2_0/misc/bsp/common/sysinfo.c (revision 1765) @@ -0,0 +1,170 @@ +//========================================================================== +// +// sysinfo.c +// +// Interface for getting system information. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Interface for getting system information. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include +#include "bsp_if.h" + + +/* + * In order to construct the _bsp_memory_list, some board specific code + * may have to size RAM regions. To do this easily and reliably, the code + * needs to run from ROM before .bss and .data sections are initialized. + * This leads to the problem of where to store the results of the memory + * sizing tests. In this case, the _bsp_init_stack routine which sizes + * memory and sets up the stack will place the board-specific information + * on the stack and return with the stack pointer pointing to a pointer to + * the information. That is, addr_of_info = *(void **)sp. The architecture + * specific code will then copy that pointer to the _bsp_ram_info_ptr variable + * after initializing the .data and .bss sections. + */ +void *_bsp_ram_info_ptr; + +/* + * Name of CPU and board. Should be overridden by arch/board specific + * code. + */ +struct bsp_platform_info _bsp_platform_info = { + "Unknown", /* cpu name */ + "Unknown", /* board name */ + "" /* extra info */ +}; + + +/* + * Information about possible data cache. Should be overridden by + * by arch/board specific code. + */ +struct bsp_cachesize_info _bsp_dcache_info = { + 0, 0, 0 +}; + + +/* + * Information about possible instruction cache. Should be overridden by + * by arch/board specific code. + */ +struct bsp_cachesize_info _bsp_icache_info = { + 0, 0, 0 +}; + + +/* + * Information about possible secondary cache. Should be overridden by + * by arch/board specific code. + */ +struct bsp_cachesize_info _bsp_scache_info = { + 0, 0, 0 +}; + + + +int +_bsp_sysinfo(enum bsp_info_id id, va_list ap) +{ + int index, rval = 0; + void *p; + + switch (id) { + case BSP_INFO_PLATFORM: + p = va_arg(ap, void *); + *(struct bsp_platform_info *)p = _bsp_platform_info; + break; + + case BSP_INFO_DCACHE: + p = va_arg(ap, void *); + *(struct bsp_cachesize_info *)p = _bsp_dcache_info; + break; + + case BSP_INFO_ICACHE: + p = va_arg(ap, void *); + *(struct bsp_cachesize_info *)p = _bsp_icache_info; + break; + + case BSP_INFO_SCACHE: + p = va_arg(ap, void *); + *(struct bsp_cachesize_info *)p = _bsp_scache_info; + break; + + case BSP_INFO_MEMORY: + index = va_arg(ap, int); + p = va_arg(ap, void *); + + if (index >= 0 && index < _bsp_num_mem_regions) + *(struct bsp_mem_info *)p = _bsp_memory_list[index]; + else + rval = -1; + break; + + case BSP_INFO_COMM: + index = va_arg(ap, int); + p = va_arg(ap, void *); + + if (index >= 0 && index < _bsp_num_comms) + *(struct bsp_comm_info *)p = _bsp_comm_list[index].info; + else if (index == _bsp_num_comms && _bsp_net_channel != NULL) + *(struct bsp_comm_info *)p = _bsp_net_channel->info; + else + rval = -1; + break; + + default: + rval = -1; + } + + return rval; +} + + + Index: v2_0/misc/bsp/common/debug-io.c =================================================================== --- v2_0/misc/bsp/common/debug-io.c (nonexistent) +++ v2_0/misc/bsp/common/debug-io.c (revision 1765) @@ -0,0 +1,142 @@ +//========================================================================== +// +// debug-io.c +// +// BSP Debug Channel Interfaces. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: BSP Debug Channel Interfaces. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#include +#include "bsp_if.h" + +static unsigned char __debug_ungetc; + +extern int stub_is_active; +extern int __output_gdb_string (const char *str, int string_len); +void +bsp_debug_write(const char *p, int len) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + if (stub_is_active) { + // We are running in 'GDB' mode + __output_gdb_string(p, len); + } else { + com->__write(com->ch_data, p, len); + } +} + + +int +bsp_debug_read(char *p, int len) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + + if (len <= 0) + return 0; + + if (__debug_ungetc) { + *p = __debug_ungetc; + __debug_ungetc = 0; + return 1; + } + + return com->__read(com->ch_data, p, len); +} + + +void +bsp_debug_putc(char ch) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + + com->__putc(com->ch_data, ch); +} + +int +bsp_debug_getc(void) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + int ch; + + if (__debug_ungetc) { + ch = __debug_ungetc; + __debug_ungetc = 0; + } else + ch = com->__getc(com->ch_data); + + return ch; +} + + +void +bsp_debug_ungetc(char ch) +{ + __debug_ungetc = (unsigned char)ch; +} + + +int +bsp_debug_irq_disable(void) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + + return com->__control(com->ch_data, COMMCTL_IRQ_DISABLE); +} + + +void +bsp_debug_irq_enable(void) +{ + struct bsp_comm_procs *com = bsp_shared_data->__debug_procs; + + com->__control(com->ch_data, COMMCTL_IRQ_ENABLE); +} + + Index: v2_0/misc/bsp/mips/gdb-cpu.c =================================================================== --- v2_0/misc/bsp/mips/gdb-cpu.c (nonexistent) +++ v2_0/misc/bsp/mips/gdb-cpu.c (revision 1765) @@ -0,0 +1,53 @@ +//========================================================================== +// +// gdb-cpu.c +// +// CPU specific support for GDB stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-06-07 +// Purpose: CPU specific support for GDB stub. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. Index: v2_0/misc/bsp/mips/gdb.h =================================================================== --- v2_0/misc/bsp/mips/gdb.h (nonexistent) +++ v2_0/misc/bsp/mips/gdb.h (revision 1765) @@ -0,0 +1,58 @@ +#ifndef __BSP_MIPS_GDB_H__ +#define __BSP_MIPS_GDB_H__ +//========================================================================== +// +// gdb.h +// +// +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. + +#endif // __BSP_ARM_GDB_H__ Index: v2_0/misc/bsp/mips/gdb-cpu.h =================================================================== --- v2_0/misc/bsp/mips/gdb-cpu.h (nonexistent) +++ v2_0/misc/bsp/mips/gdb-cpu.h (revision 1765) @@ -0,0 +1,58 @@ +#ifndef __BSP_MIPS_GDB_CPU_H__ +#define __BSP_MIPS_GDB_CPU_H__ +//========================================================================== +// +// gdb-cpu.h +// +// CPU specific definitions for GDB stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: dmoseley +// Date: 2000-07-10 +// Purpose: CPU specific definitions for GDB stub. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. + +#endif // __BSP_MIPS_GDB_CPU_H__ Index: v2_0/misc/bsp/mips/insn.h =================================================================== --- v2_0/misc/bsp/mips/insn.h (nonexistent) +++ v2_0/misc/bsp/mips/insn.h (revision 1765) @@ -0,0 +1,59 @@ +#ifndef __BSP_MIPS_INSN_H__ +#define __BSP_MIPS_INSN_H__ +//========================================================================== +// +// insn.h +// +// MIPS instruction descriptions. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-07-10 +// Purpose: MIPS instruction descriptions. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. +// We are using the eCos hal for single-stepping. +// FIXME: this file can be removed + +#endif // __BSP_ARM_INSN_H__

v2_0/misc/bsp/mips/insn.h Property changes : Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: v2_0/misc/bsp/mips/singlestep.c =================================================================== --- v2_0/misc/bsp/mips/singlestep.c (nonexistent) +++ v2_0/misc/bsp/mips/singlestep.c (revision 1765) @@ -0,0 +1,55 @@ +//========================================================================== +// +// singlestep.c +// +// MIPS specific single-step support. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-07-10 +// Purpose: MIPS specific single-step support. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. +// We are using the eCos hal for single-stepping. +// FIXME: this file can be removed Index: v2_0/misc/bsp/gdb-data.h =================================================================== --- v2_0/misc/bsp/gdb-data.h (nonexistent) +++ v2_0/misc/bsp/gdb-data.h (revision 1765) @@ -0,0 +1,126 @@ +#ifndef __BSP_GDB_DATA_H__ +#define __BSP_GDB_DATA_H__ +//========================================================================== +// +// gdb-data.h +// +// Shared data specific to gdb stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Shared data specific to gdb stub. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#ifndef __ASSEMBLER__ +typedef int (*gdb_memproc_t)(void *__addr, /* start addr of memory to read/write */ + int __asid, /* address space id */ + int __size, /* size of individual read/write ops */ + int __n, /* number of read/write operations */ + void *__buf); /* result(read)/src(write) buffer */ + + +typedef void (*gdb_regproc_t)(int __regno, /* Register number */ + void *__regs, /* pointer to saved regs */ + void *__val); /* pointer to register value */ + + +typedef struct { + /* + * An application may override the standard BSP memory + * read and/or write routines with these hooks. + */ + gdb_memproc_t __mem_read_hook; + gdb_memproc_t __mem_write_hook; + + /* + * An application may override the standard BSP register + * access routines with these hooks. + */ + gdb_regproc_t __reg_get_hook; + gdb_regproc_t __reg_set_hook; + + /* + * An application may extend the gdb remote protocol by + * installing hooks to handle unknown general query and + * set packets ("q" pkts and 'Q' pkts) with these two hooks. + */ + void (*__pkt_query_hook)(unsigned char *__pkt); + void (*__pkt_set_hook)(unsigned char *__pkt); + + /* + * An application may also extend the gdb remote protocol + * by installing a hook to handle all unknown packets. + */ + void (*__pkt_hook)(unsigned char *__pkt); + + /* + * The above hooks for receiving packets will probably need + * a mechanism to respond. This vector is provided to allow + * an application to append data to the outgoing packet which + * will be sent after the above hooks are called. + * + * This vector uses a printf-like format string followed by + * some number of arguments. + */ + void (*__pkt_append)(char *fmt, ...); + + /* + * An application can read/write from/to gdb console + * through these vectors. + * + * NB: console read is not supported and will block forever. + */ + int (*__console_read)(char *__buf, int len); + int (*__console_write)(char *__buf, int len); + +} gdb_data_t; + + +extern gdb_data_t *__get_gdb_data(void); + +#endif /* __ASSEMBLER__ */ + +#endif // __BSP_GDB_DATA_H__ Index: v2_0/misc/bsp/bsp.h =================================================================== --- v2_0/misc/bsp/bsp.h (nonexistent) +++ v2_0/misc/bsp/bsp.h (revision 1765) @@ -0,0 +1,445 @@ +#ifndef __BSP_BSP_H__ +#define __BSP_BSP_H__ +//========================================================================== +// +// bsp.h +// +// Public interface to Red Hat BSP. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Public interface to Red Hat BSP. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#ifndef __ASSEMBLER__ + +/* needed for _bsp_vsprintf() */ +#include + +/* + * Exception and interrupt handler type. + */ +#ifndef _BSP_HANDLER_T_DEFINED +#define _BSP_HANDLER_T_DEFINED +typedef int (*bsp_handler_t)(int __irq_nr, void *__regs); +#endif // _BSP_HANDLER_T_DEFINED + +/* + * Vector descriptor. This is needed for chaining vectors. The interfaces use + * bsp_vec structure pointers instead of direct pointers to handlers. This + * puts the responsibility for allocating the bsp_vec structures on the + * caller, rather than the BSP code. + */ +typedef struct bsp_vec { + bsp_handler_t handler; /* pointer to actual ISR */ + struct bsp_vec *next; /* for chaining */ +} bsp_vec_t; + +/* + * Valid op values for vector install routines. + */ +#define BSP_VEC_REPLACE 0 +#define BSP_VEC_CHAIN_FIRST 1 +#define BSP_VEC_CHAIN_LAST 2 + +/* + * Valid kinds of vectors supported by vector install and remove + * routines. + */ +#define BSP_VEC_EXCEPTION 0 +#define BSP_VEC_INTERRUPT 1 + +/* + * Routine to cause a breakpoint exception. + */ +extern void bsp_breakpoint(void); + +/* + * Dummy function whose address is the address of + * the breakpoint caused by calling bsp_breakpoint(). + */ +extern void bsp_breakinsn(void); + +/* + * Enable given irq. + */ +extern void bsp_enable_irq(int __irq_nr); + +/* + * Disable given irq. Returns true if irq was enabled. + */ +extern int bsp_disable_irq(int __irq_nr); + +/* + * Remove given vector from vector chain. + */ +extern void bsp_remove_vec(int __vec_kind, + int __vec_nr, + bsp_vec_t *__vec); + +/* + * Install a vector chain. + * + * vec_kind may be BSP_VEC_EXCEPTION or BSP_VEC_INTERRUPT. + * vec_nr is the exception or interrupt number. + * op may be one of: + * BSP_VEC_REPLACE - replace existing chain. + * BSP_VEC_CHAIN_FIRST - install at head of chain. + * BSP_VEC_CHAIN_LAST - install at tail of chain. + * + */ +extern bsp_vec_t *bsp_install_vec(int __vec_kind, + int __vec_nr, + int __op, + bsp_vec_t *__vec); + +/* + * Install a debug handler. + * Returns old handler being replaced. + */ +extern bsp_handler_t bsp_install_dbg_handler(bsp_handler_t __new_handler); + +/* + * Sometimes it is desireable to call the debug handler directly. This routine + * accomplishes that. It is the responsibility of the caller to insure that + * interrupts are disabled before calling this routine. + */ +extern void bsp_invoke_dbg_handler(int __exc_nr, void *__regs); + +/* + * Install a 'kill' handler. This handler is called when debugger + * issues a kill command. + * Returns old handler being replaced. + */ +extern bsp_handler_t bsp_install_kill_handler(bsp_handler_t __new_handler); + +/* + * Architecure specific routine to prepare CPU to execute + * a single machine instruction. + */ +#ifndef USE_ECOS_HAL_SINGLESTEP +extern void bsp_singlestep_setup(void *__saved_regs); +#endif /* USE_ECOS_HAL_SINGLESTEP */ + +/* + * Architecure specific routine to cleanup after a single-step + * completes. + */ +#ifndef USE_ECOS_HAL_SINGLESTEP +extern void bsp_singlestep_cleanup(void *__saved_regs); +#endif /* USE_ECOS_HAL_SINGLESTEP */ + +/* + * Architecture specific routine to skip past the current machine instruction. + */ +#ifndef USE_ECOS_HAL_SINGLESTEP +extern void bsp_skip_instruction(void *__saved_regs); +#endif /* USE_ECOS_HAL_SINGLESTEP */ + +/* + * Return byte offset within the saved register area of the + * given register. + */ +extern int bsp_regbyte(int __regno); + +/* + * Return size in bytes of given register. + */ +extern int bsp_regsize(int __regno); + +/* + * Setup the saved registered to establish the given Program Counter. + */ +#ifndef bsp_set_pc +extern void bsp_set_pc(unsigned long __pc, void *__saved_regs); +#endif + +/* + * Get the current Program Counter from the saved registers. + */ +#ifndef bsp_get_pc +unsigned long bsp_get_pc(void *__saved_regs); +#endif + +extern int bsp_memory_read(void *__addr, /* start addr of memory to read */ + int __asid, /* address space id */ + int __rsize, /* size of individual read ops */ + int __nreads, /* number of read operations */ + void *__buf); /* result buffer */ + +extern int bsp_memory_write(void *__addr, /* start addr of memory to write */ + int __asid, /* address space id */ + int __wsize, /* size of individual write ops */ + int __nwrites, /* number of write operations */ + void *__buf); /* source buffer for write data */ + +/* + * Architecture specific routines to read and write CPU registers. + */ +extern void bsp_set_register(int __regno, void *__saved_regs, void *__val); +extern void bsp_get_register(int __regno, void *__saved_regs, void *__val); + + +/* + * Architecture specific conversion of raw exception info into + * a signal value. + */ +#ifndef bsp_get_signal +extern int bsp_get_signal(int __exc_nr, void *__saved_regs); +#endif + +/* light-weight bsp printf to console port */ +extern void bsp_printf(const char *__fmt, ...); + +/* light-weight bsp printf to debug port */ +extern void bsp_dprintf(const char *__fmt, ...); + +/* bsp vsprintf */ +extern int bsp_vsprintf(char *__str, const char *__fmt, va_list __ap); + +/* bsp vprintf to console port */ +extern void bsp_vprintf(const char *__fmt, va_list __ap); + +/* bsp vprintf to debug port */ +extern void bsp_dvprintf(const char *__fmt, va_list __ap); + +/* bsp sprintf */ +extern void bsp_sprintf(char *str, const char *fmt, ...); + +#ifdef NDEBUG +#define BSP_ASSERT(e) ((void)0) +#else /* NDEBUG */ +extern void _bsp_assert(const char *, const int, const char *); +#define BSP_ASSERT(e) ((e) ? (void)0 : _bsp_assert(__FILE__, __LINE__, #e)) +#endif /* NDEBUG */ + +/* + * Functions for low-level console and debug i/o. + */ +extern void bsp_console_write(const char *__p, int __len); +extern void bsp_console_putc(char __ch); +extern int bsp_console_read(char *__p, int __len); +extern int bsp_console_getc(void); +extern void bsp_console_ungetc(char ch); +extern void bsp_debug_write(const char *__p, int __len); +extern int bsp_debug_read(char *__p, int __len); +extern void bsp_debug_putc(char __ch); +extern int bsp_debug_getc(void); +extern void bsp_debug_ungetc(char ch); + +/* + * Disable interrupts for debug comm channel. + * Returns true if interrupts were previously enabled, + * false if interrupts were already disabled. + */ +extern int bsp_debug_irq_disable(void); +extern void bsp_debug_irq_enable(void); + +/* + * Cache control functions. May be noops for architectures not + * supporting caches. + * + * The icache flush simply invalidates _at_least_ the range of + * addresses specified. + * + * The dcache flush writes back (if write-back cache) and invalidates + * _at_least_ the range of addresses specified. + * + */ +extern void bsp_flush_dcache(void *__p, int __nbytes); +extern void bsp_flush_icache(void *__p, int __nbytes); + +/* + * Reset function. May be noops for architectures not + * supporting software reset. + */ +extern void bsp_reset(void); + +/* + * Generic data (board and CPU specific) handling + */ +extern void *bsp_cpu_data(void); +extern void *bsp_board_data(void); + +/* + * List of board characteristics which can be read queried by BSP clients. These + * information IDs are passed to: + * + * int bsp_sysinfo(enum bsp_info_id id, ...); + * + * Some pieces of information may have more than one instance. For example, the + * BSP will likely have information on multiple memory regions. In those cases, + * a particular instance may be accessed using a small integer index argument. + * + * The following comments indicate what additional arguments are needed + * to access the specific information. + */ +enum bsp_info_id { + /* + * CPU and board names. + * + * err = bsp_sysinfo(BSP_INFO_PLATFORM, + * struct bsp_platform_info *result) + * + * err => zero if successful, -1 if unsupported. + */ + BSP_INFO_PLATFORM, + + /* + * Data, instruction, and secondary caches. + * + * err = bsp_sysinfo(BSP_INFO_[DIS]CACHE, + * struct bsp_cache_info *result) + * + * err => zero if successful, -1 if unsupported. + * + */ + BSP_INFO_DCACHE, + BSP_INFO_ICACHE, + BSP_INFO_SCACHE, + + /* + * Memory region info. + * + * err = bsp_sysinfo(BSP_INFO_MEMORY, + * int index, + * struct bsp_mem_info *result) + * + * err => zero if successful, -1 if invalid index. + * + * Caller should start index at zero, then increment index for subsequent + * calls until error return indicates no more memory regions. + */ + BSP_INFO_MEMORY, + + /* + * Communication channel info. + * + * err = bsp_sysinfo(BSP_INFO_COMM, + * int index, + * struct bsp_comm_info *result) + * + * err => zero if successful, -1 if invalid index. + * + * Caller should start index at zero, then increment index for subsequent + * calls until error return indicates no more comm channels. + */ + BSP_INFO_COMM +}; + + +/* + * Platform info. + */ +struct bsp_platform_info { + const char *cpu; /* CPU name*/ + const char *board; /* board name */ + const char *extra; /* extra info */ +}; + + +/* + * Cache size info. + */ +struct bsp_cachesize_info { + int size; /* total size in bytes */ + short linesize; /* width of cacheline in bytes */ + short ways; /* number of ways per line */ +}; + + +/* + * Memory region info. + * The BSP may describe multiple memory regions. For example, + * DRAM may be comprised of several non-contiguous regions. + * ROM and FLASH regions may also be described. + * + */ +struct bsp_mem_info { + void *phys_start; /* physical start address */ + void *virt_start; /* virtual start address */ + int virt_asid; /* some architectures also use an address space id */ + long nbytes; /* length of region in bytes */ + int kind; /* kind of memory */ +#define BSP_MEM_RAM 1 +#define BSP_MEM_FLASH 2 +#define BSP_MEM_ROM 3 +}; + + +struct bsp_comm_info { + char *name; + short kind; +#define BSP_COMM_SERIAL 1 +#define BSP_COMM_ENET 2 + short protocol; +#define BSP_PROTO_NONE 0 +#define BSP_PROTO_UDP 1 +#define BSP_PROTO_TCP 2 +}; + + +extern int bsp_sysinfo(enum bsp_info_id __id, ...); + +/* + * Set or get active debug and console channels. + * Returns -1 if unsucessful. + * If the passed in __comm_id is -1, then the id of the current channel + * is returned. + */ +extern int bsp_set_debug_comm(int __comm_id); +extern int bsp_set_console_comm(int __comm_id); + +/* + * Set or get the current baud rate of a serial comm channel. + * Returns -1 on if unsuccessful. + * If the given baud is -1, then the current baudrate is returned. + */ +extern int bsp_set_serial_baud(int __comm_id, int baud); + +#endif + +#endif // __BSP_BSP_H__ Index: v2_0/misc/bsp/cpu.h =================================================================== --- v2_0/misc/bsp/cpu.h (nonexistent) +++ v2_0/misc/bsp/cpu.h (revision 1765) @@ -0,0 +1,71 @@ +#ifndef __BSP_CPU_H__ +#define __BSP_CPU_H__ +//========================================================================== +// +// cpu.h +// +// Architecture/processor specifics +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +// Pick up architecture info + +#include + +#ifdef CYGPKG_HAL_ARM +#include "arm/cpu.h" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "mips/cpu.h" +#endif + +#ifdef CYGPKG_HAL_MN10300 +#include "mn10300/cpu.h" +#endif + +#endif // __BSP_CPU_H__ Index: v2_0/misc/bsp/mn10300/gdb-cpu.c =================================================================== --- v2_0/misc/bsp/mn10300/gdb-cpu.c (nonexistent) +++ v2_0/misc/bsp/mn10300/gdb-cpu.c (revision 1765) @@ -0,0 +1,53 @@ +//========================================================================== +// +// gdb-cpu.c +// +// CPU specific support for GDB stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: CPU specific support for GDB stub. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. Index: v2_0/misc/bsp/mn10300/gdb.h =================================================================== --- v2_0/misc/bsp/mn10300/gdb.h (nonexistent) +++ v2_0/misc/bsp/mn10300/gdb.h (revision 1765) @@ -0,0 +1,58 @@ +#ifndef __BSP_MN10300_GDB_H__ +#define __BSP_MN10300_GDB_H__ +//========================================================================== +// +// gdb.h +// +// +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. + +#endif // __BSP_ARM_GDB_H__ Index: v2_0/misc/bsp/mn10300/gdb-cpu.h =================================================================== --- v2_0/misc/bsp/mn10300/gdb-cpu.h (nonexistent) +++ v2_0/misc/bsp/mn10300/gdb-cpu.h (revision 1765) @@ -0,0 +1,58 @@ +#ifndef __BSP_MN10300_GDB_CPU_H__ +#define __BSP_MN10300_GDB_CPU_H__ +//========================================================================== +// +// gdb-cpu.h +// +// CPU specific definitions for GDB stub. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: CPU specific definitions for GDB stub. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. + +#endif // __BSP_MN10300_GDB_CPU_H__ Index: v2_0/misc/bsp/mn10300/insn.h =================================================================== --- v2_0/misc/bsp/mn10300/insn.h (nonexistent) +++ v2_0/misc/bsp/mn10300/insn.h (revision 1765) @@ -0,0 +1,59 @@ +#ifndef __BSP_MN10300_INSN_H__ +#define __BSP_MN10300_INSN_H__ +//========================================================================== +// +// insn.h +// +// MN10300 instruction descriptions. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: MN10300 instruction descriptions. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. +// We are using the eCos hal for single-stepping. +// FIXME: this file can be removed + +#endif // __BSP_ARM_INSN_H__ Index: v2_0/misc/bsp/mn10300/singlestep.c =================================================================== --- v2_0/misc/bsp/mn10300/singlestep.c (nonexistent) +++ v2_0/misc/bsp/mn10300/singlestep.c (revision 1765) @@ -0,0 +1,55 @@ +//========================================================================== +// +// singlestep.c +// +// MN10300 specific single-step support. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: MN10300 specific single-step support. +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Nothing now. +// We are using the eCos hal for single-stepping. +// FIXME: this file can be removed Index: v2_0/misc/stub-tservice.h =================================================================== --- v2_0/misc/stub-tservice.h (nonexistent) +++ v2_0/misc/stub-tservice.h (revision 1765) @@ -0,0 +1,54 @@ +//========================================================================== +// +// stub-tservice.h +// +// +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Placeholder Index: v2_0/misc/ecos_dummy.c =================================================================== --- v2_0/misc/ecos_dummy.c (nonexistent) +++ v2_0/misc/ecos_dummy.c (revision 1765) @@ -0,0 +1,70 @@ +//========================================================================== +// +// ecos_dummy.c +// +// eCos BSP (for building Cygmon) +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-11 +// Description: Wrapper functions which provide BSP environment for Cygmon +//####DESCRIPTIONEND#### + +#ifdef CYGPKG_KERNEL +#include // Configuration header +#include +#endif +#include +#include + +// TEMP + +#define FAIL(n) \ +void n(void) \ +{ \ + diag_printf("Fail: %s\n", #n); \ + while (1) ; \ +} + +#ifndef CYGHWR_HAL_RESET_DEFINED + FAIL(bsp_reset) +#endif + + FAIL(_bsp_gdb_handler) + FAIL(_bsp_gdb_data) Index: v2_0/misc/ledit.h =================================================================== --- v2_0/misc/ledit.h (nonexistent) +++ v2_0/misc/ledit.h (revision 1765) @@ -0,0 +1,88 @@ +//========================================================================== +// +// ledit.h +// +// Header for the utterly simple line editor +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Header for the udderly simple line editor +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#ifndef LEDIT_H +#define LEDIT_H + +#define LF '\n' +#define CR '\r' +#define BOLCMD '\001' +#define EOLCMD '\005' +#define FORWCMD '\006' +#define BACKCMD '\002' +#define DELBACK '\010' +#define DELEOL '\013' +#define YANKCH '\031' +#define DELCURRCH '\004' +#define PREVCMD '\020' +#define ERASELINE '\025' +#define NEXTCMD '\016' + +/* Prompt for one line of input using PROMPT. The input from the user + (up to MAXINPLEN characters) will be stored in BUFFER. The number + of characters read will be returned. */ +extern int lineedit(char *prompt, char *buffer, int maxInpLen); + +/* Add CMD to the user's command history. */ +extern void addHistoryCmd (char *cmd); + +/* Configure the editor to use the specified terminal. */ +extern void set_term_name (char *name); + +/* Beep the terminal. */ +extern void beep (void); + +/* Print a history list. */ +extern void printHistoryList(void); + +#endif Index: v2_0/misc/cpu_info.h =================================================================== --- v2_0/misc/cpu_info.h (nonexistent) +++ v2_0/misc/cpu_info.h (revision 1765) @@ -0,0 +1,69 @@ +#ifndef __CYGMON_CPU_INFO_H__ +#define __CYGMON_CPU_INFO_H__ +//========================================================================== +// +// cpu_info.h +// +// Architecture specific information +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +#include +#include + +#ifdef CYGPKG_HAL_ARM +#include "arm/cpu_info.h" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "mips/cpu_info.h" +#endif + +#ifdef CYGPKG_HAL_MN10300 +#include "mn10300/cpu_info.h" +#endif +#endif // __CYGMON_CPU_INFO_H__ Index: v2_0/misc/monitor_cmd.c =================================================================== --- v2_0/misc/monitor_cmd.c (nonexistent) +++ v2_0/misc/monitor_cmd.c (revision 1765) @@ -0,0 +1,2549 @@ +//========================================================================== +// +// monitor_cmd.c +// +// Monitor commands for the CygMON ROM monitor +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: Monitor commands for the CygMON ROM monitor +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#ifdef HAVE_BSP +#include "cpu_info.h" +#include +#include +#include +#ifdef __BOARD_HEADER__ +#include __BOARD_HEADER__ +#endif +#endif +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_BSP +#include "fmt_util.h" +#include "tservice.h" +#endif + +#ifdef __ECOS__ +#include +#endif + +#if USE_CYGMON_PROTOTYPES +/* Use common prototypes */ +/* Some of the composed board.h files compose these + prototypes redundently, but if they dont, + these are the common definitions */ +#include "fmt_util.h" /* Interface to string formatting utilities */ +#include "tservice.h" /* Interface to target specific services */ +#include "generic-stub.h" /* from libstub */ +#endif /* USE_CYGMON_PROTOTYPES */ + +static int history_cmd(cmdmode_t mode) ; + +#ifndef MAXLINELEN +#define MAXLINELEN 80 +#endif + +#define MAXLINES 23 + +char inbuf[MAXLINELEN] ; +static char cmd[MAXLINELEN]; + +#if ! defined(PROVIDE_CRASH_CMD) +#define PROVIDE_CRASH_CMD 0 +#endif + +#if PROVIDE_CRASH_CMD +/* + * The crash command is used while debugging cygmon itself + */ +static int crash_cmd(cmdmode_t mode) ; /* Command to trap into cygmon */ +#endif + +struct cmdentry cmdtab[] = { + {NULL, "baud", set_serial_speed_cmd}, + {"b", "break", breakpoint_cmd}, +#if HAVE_CACHE + {NULL, "cache", cache_cmd}, +#endif + {NULL, "copy", copy_cmd}, +#if PROVIDE_CRASH_CMD + {NULL, "crash", crash_cmd}, +#endif + {NULL, "crc", checksumcmd}, + {"d", "disassemble", disassemble_cmd}, + {NULL, "dump", dump_cmd}, +#if defined(NVRAM_ETH_ADDR) + {NULL, "ethaddr", ethaddr_cmd}, +#endif + {NULL, "fill", fill_cmd}, + {NULL, "go", go_cmd}, + {NULL, "help", help_cmd}, + {"his","history", history_cmd}, +#ifdef MONITOR_CONTROL_INTERRUPTS + {NULL, "interrupt", int_cmd}, +#endif +#if defined(NVRAM_IP_ADDR) + {NULL, "ipaddr", ipaddr_cmd}, +#endif + {NULL, "load", load_cmd}, + {"m", "memory", mem_cmd}, +#ifdef OTHERNAMES_CMD + {"o", "othernames", othernames_cmd}, +#endif + {NULL, "port", set_serial_port_cmd}, + {"r", "register", reg_cmd}, + {NULL, "reset", reset_cmd}, +#ifndef HAVE_BSP + {NULL, "setargs", set_program_args_cmd}, +#endif + {"si", "step", step_cmd}, + {NULL, "swapmem", swapmem_cmd}, +#if defined(NVRAM_TCP_PORT) + {NULL, "tcpport", tcpport_cmd}, +#endif + {NULL, "terminal", set_term_cmd}, +#ifdef HAS_TIMER + {NULL, "timer", timer_cmd}, +#endif +#if !defined(__ECOS__) || defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS) + {NULL, "transfer", transfer_cmd}, +#endif + {"u", "unbreak", clear_breakpoint_cmd}, +#if HAVE_USAGE + {NULL, "usage", memusage_cmd}, +#endif + {NULL, "version", version_cmd}, + /* Really need to redo the way commands are done--there should be a + dynamic list (perhaps in addition to the static one). */ +#ifdef TARGET_COMMANDS + TARGET_COMMANDS +#endif + + {NULL, NULL, NULL} +}; + +static int +alias_compare (char *cmd) +{ + int m = 0; + int match = -1; + int num_matches = 0; + + while (cmdtab[m].cmd != NULL) + { + if (cmdtab[m].alias != NULL && !strcmp (cmd, cmdtab[m].alias)) + { + match = m; + num_matches++; + /* We're expecting that aliases will be defined + uniquely, but just in case, we let the user know + if there is a conflict */ + if (num_matches > 1) + { + xprintf ("Alias conflict. Executing last matching alias.\n"); + } + } + m++; + } + return match; +} + +static int +command_compare (char *cmd) +{ + int m = 0; + int match = -1; + int num_matches = 0; + int cmdlen = strlen(cmd) ; + while (cmdtab[m].cmd != NULL) + { + if (!(strncmp (cmd,cmdtab[m].cmd, cmdlen))) + { + /* we found a match */ + num_matches++; + if (num_matches == 2) /* we found a second match */ + { + xprintf ("Ambiguous command. Possibilities are:\n%s\n%s\n", + cmdtab[match].cmd, + cmdtab[m].cmd); + } + else if (num_matches > 2) /* we found another match */ + { + /* Show the new possibility we just found */ + xprintf ("%s\n", cmdtab[m].cmd); + } + /* Point the match at the command we just looked at. + We have to wait until now so that the first duplicate + found can output the earlier match as well */ + match = m; + } + m++; + } + return ((num_matches == 1) ? match : -1); +} + +#ifdef USE_HELP +void +usage (char *string) +{ + xprintf ("Usage: %s\n", string); +} + +void +short_help (char *string) +{ + xprintf ("%s\n", string); +} + +void +long_help (char *string) +{ + int linecnt = 0; + int do_leave = 0; + + for (; *string && !do_leave; string++) + { + xprintf ("%c", *string); + if (*string == '\n') + { + linecnt++; + if (linecnt == MAXLINES) + { + int i; + + xprintf ("-More-"); + while ((i = input_char ()) >= 0) + { + if (i == '\r' || i == '\n') + { + linecnt--; + break; + } + else if (i == ' ') + { + linecnt = 0; + break; + } + else if (i == 'q' || i == 'Q') + { + do_leave = 1; + break; + } + else + beep (); + } + } + } + } + xprintf ("\n"); +} + +void +example (char *example) +{ + xprintf ("Example: %s\n", example); +} + +#else +void +no_help (void) +{ + xprintf ("No help available.\n"); +} + +void +no_help_usage (void) +{ + xprintf ("Incorrect usage.\n"); +} +#endif + +int +help_cmd (cmdmode_t mode) +{ + int command_number = -2; + + if (mode == USAGE) + { + usage ("help [command]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("The help command"); + return 0; + } + if (mode == LONG_HELP) + { + help_cmd (USAGE); + long_help ("\ +The help command without arguments shows a list of all available commands\n\ +with a short description of each one. With a command name as an argument\n\ +it shows usage for the command and a paragraph describing the command.\n\ +Usage is shown as command name followed by names of extensions or arguments.\n\ +Arguments in [brackets] are optional, plain text arguments are required.\n\ +Note that all commands can be invoked by typing enough of the command name\n\ +to uniquely specify the command. Some commands have aliases, which are one\n\ +letter abbreviations for commands which do not have unique first letters.\n\ +Aliases for all commands are shown in the help screen, which displays\n\ +commands in the format:\n\ +command name: (alias, if any) description of command \n"); + example("\ +help foo \n\ +Shows the help screen for the command foo."); + return 0; + } + + if (argvect[1] != NULL) + { + if (argvect[2] == NULL) + { + command_number = command_compare (argvect[1]); + if (command_number < 0) + { + xprintf ("No such command as %s\n", argvect[1]); + } + } + + if (command_number < 0) + { + return help_cmd (USAGE); + } + else + { + return cmdtab[command_number].function (LONG_HELP); + } + } + else + { + int i; + + xprintf ("Available commands are:\n"); + for (i = 0; cmdtab[i].cmd != NULL; i++) + { + int x = strlen (cmdtab[i].cmd) + 2; + + xprintf ("%s: ", cmdtab[i].cmd); + if (cmdtab[i].alias != NULL) + { + xprintf("(%s)", cmdtab[i].alias); + x += 2 + strlen(cmdtab[i].alias); + } + for (; x < 20; x++) + { + xprintf (" "); + } + cmdtab[i].function (SHORT_HELP); + if ((i > 0) && (i % MAXLINES) == 0) + { + xprintf ("-More-"); + input_char (); + xprintf ("\n"); + } + } + } + return 0; +} + +#if PROVIDE_CRASH_CMD +static int crash_cmd(cmdmode_t mode) +{ + switch (mode) + { + case USAGE : usage("crash") ; break ; + case SHORT_HELP : short_help("invoke the breakpoint function"); + break ; + case LONG_HELP : + long_help("The crash command calls the breakpoint function() which is useful\n\ +only if you are using an additional debugger to debug this software and,\n\ +the general exception handler is hooked to the other debugger\n") ; + break ; + case INVOCATION : + dbg_breakpoint() ; + break ; + } + return 0 ; +} +#endif /* provide_crash_command */ + + + +static int history_cmd(cmdmode_t mode) +{ + switch (mode) + { + case USAGE : usage("history") ; break ; + case SHORT_HELP : short_help("Print help about line editing features."); + break ; + case INVOCATION : + printHistoryList(); + break; + case LONG_HELP : + long_help("Cygmon line editing allows you to repeat previously entered +commands. The line editing commands are: + CR '\\n' Execute the currently displayed command + ctl-a move to Beginning of line + ctl-e End of line + ctl-f Forward char + ctl-b Backward char + ctl-k Delete to end of line + ctl-y yank Character (undelete) + ctl-d Delete current character + ctl-p edit previous command + ctl-u Erase Line + ctl-n Edit next command") ; + break ; + } + return 0 ; +} /* history_cmd */ + +#ifdef OTHERNAMES_CMD +/* Switch to using the othernames (ie alternate register names) */ +int +othernames_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("othernames"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Switch between alternate register names."); + return 0; + } + if (mode == LONG_HELP) + { + othernames_cmd (USAGE); + long_help ("\ +The othernames command allows you to switch between alternate register +names for a given target."); + example ("\ +othernames\n\ +Switches to the alternate register name set.."); + return 0; + } + OTHERNAMES_CMD(); + + return 0; +} +#endif /* OTHERNAMES_CMD */ + + +#if defined(NVRAM_ETH_ADDR) +int +ethaddr_cmd (cmdmode_t mode) +{ + int i, n; + unsigned char addr[6]; + char *p; + + if (mode == USAGE) + { + usage ("ethaddr [xx:xx:xx:xx:xx:xx]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("get/set NVRAM backed ethernet address"); + return 0; + } + if (mode == LONG_HELP) + { + ethaddr_cmd (USAGE); + long_help ("\ +The ethaddr command is used to view and modify the non-volatile ethernet\n\ +address. The address is specified by 6 colon-seperated 2 digit hexadecimal\n\ +numbers. If no address is specified, the current address is displayed.\n"); + example ("ethaddr 00:00:8B:F1:36:01"); + return 0; + } + + if (argvect[1] != NULL) + { + if (strlen(argvect[1]) != 17 || argvect[2] != NULL) + { + return ethaddr_cmd (USAGE); + } + + for (i = 0, p = argvect[1]; i < 6; i++, p++) + { + n = __hex(*p++); + if (n < 0) + return ethaddr_cmd (USAGE); + addr[i] = (n << 4); + n = __hex(*p++); + if (n < 0) + return ethaddr_cmd (USAGE); + addr[i] |= n; + + if (*p != ':' && !(i == 5 && *p == '\0')) + return ethaddr_cmd (USAGE); + } + for (i = 0; i < 6; i++) + NVRAM_ETH_ADDR(i) = addr[i]; + } + else + { + for (i = 0; i < 5; i++) + xprintf("%02x:", NVRAM_ETH_ADDR(i)); + xprintf("%02x\n", NVRAM_ETH_ADDR(i)); + } + + return 0; +} +#endif /* NVRAM_ETH_ADDR */ + + +#if defined(NVRAM_IP_ADDR) +int +ipaddr_cmd (cmdmode_t mode) +{ + int i, j, n; + unsigned char addr[4]; + char *p; + + if (mode == USAGE) + { + usage ("ipaddr [n.n.n.n]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("get/set NVRAM backed ip address"); + return 0; + } + if (mode == LONG_HELP) + { + ipaddr_cmd (USAGE); + long_help ("\ +The ipaddr command is used to view and modify the non-volatile internet\n\ +address. The address is specified by 4 dot-seperated 1-3 digit decimal\n\ +numbers. If no address is specified, the current address is displayed.\n"); + example ("ipaddr 192.161.0.1"); + return 0; + } + + if (argvect[1] != NULL) + { + if (argvect[2] != NULL) + return ipaddr_cmd (USAGE); + + p = argvect[1]; + + for (i = 0; i < 3; i++, p++) + { + for (j = n = 0; j < 3 && isdigit(*p); j++, p++) + n = n*10 + (*p - '0'); + if (j == 0 || *p != '.' || n > 255) + return ipaddr_cmd (USAGE); + addr[i] = n; + } + for (j = n = 0; j < 3 && isdigit(*p); j++, p++) + n = n*10 + (*p - '0'); + if (j == 0 || *p != '\0' || n > 255) + return ipaddr_cmd (USAGE); + addr[i] = n; + + for (i = 0; i < 4; i++) + NVRAM_IP_ADDR(i) = addr[i]; + } + else + { + for (i = 0; i < 3; i++) + xprintf("%d.", NVRAM_IP_ADDR(i)); + xprintf("%d\n", NVRAM_IP_ADDR(i)); + } + + return 0; +} +#endif /* NVRAM_IP_ADDR */ + +#if defined(NVRAM_TCP_PORT) +int +tcpport_cmd (cmdmode_t mode) +{ + int n; + char *p; + + if (mode == USAGE) + { + usage ("ethaddr [xx:xx:xx:xx:xx:xx]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("get/set NVRAM backed tcp port number"); + return 0; + } + if (mode == LONG_HELP) + { + tcpport_cmd (USAGE); + long_help ("\ +The tcpport command is used to view and modify the non-volatile tcp port\n\ +address used for debugging. The address is specified by decimal numer in\n\ +the range of 1-65535. If no port number is specified, the current port is\n\ +displayed.\n"); + example ("tcpport 1000"); + return 0; + } + + if (argvect[1] != NULL) + { + if (argvect[2] != NULL) + return tcpport_cmd (USAGE); + + p = argvect[1]; + n = 0; + while (isdigit(*p)) + { + n = n*10 + (*p++ - '0'); + if (n > 65535) + return tcpport_cmd (USAGE); + } + if (*p != '\0') + return tcpport_cmd (USAGE); + + NVRAM_TCP_PORT(0) = (n >> 8) & 0xff; + NVRAM_TCP_PORT(1) = n & 0xff; + } + else + xprintf("%d\n", (NVRAM_TCP_PORT(0) << 8) + NVRAM_TCP_PORT(1)); + + return 0; +} +#endif /* NVRAM_TCP_PORT */ + + +#ifdef __ECOS__ +# if (CYG_BYTEORDER == CYG_LSBFIRST) +# define LITTLE_ENDIAN_TARGET +# else +# define BIG_ENDIAN_TARGET +# endif +#endif + +#ifdef LITTLE_ENDIAN_TARGET +static int swap_bytes = 1; +#else +static int swap_bytes = 0; +#endif + +int +get_memory_display_mode (void) +{ + return swap_bytes; +} + +void +set_memory_display_mode (int mode) +{ + swap_bytes = mode; +} + + +/* Just to make DEFAULT_SIZE something usable, this may go elsewhere later.*/ +#ifndef DEFAULT_SIZE +#define DEFAULT_SIZE 1 +#endif + +static int +get_cmd_size (void) +{ + int size = 0; + char *sizestr; + + sizestr = strchr (argvect[0], '.'); + + if (sizestr == NULL || sizestr[0] == '\0' || sizestr[1] == '\0') + { + size = DEFAULT_SIZE; + } + else + { + size = str2int (sizestr + 1, 10) / 8; + } + if (size != 1 && size != 2 && size != 4 && size != 8) + { + xprintf ("Invalid size.\n"); + return -1; + } + return size; +} + + +void +display_memory (char *value, int size, int littleEndian) +{ + int x; + int start = littleEndian ? size - 1 : 0 ; + int end = littleEndian ? -1 : size; + int incr = littleEndian ? -1 : 1; + + if (value) + { + for (x = start; x != end; x += incr) + xprintf ("%02x", value[x] & 0xff); + } + else + { + for (x = start; x != end; x += incr) + xprintf (".."); + } +} + + +static int +peek (void) +{ + mem_addr_t addr; + int size = get_cmd_size (); + + if (size > 0) + { + /* We already checked to see if the command was legal when we called the + function, so there's no need to worry about that here. */ + + if (argvect[1] != 0) + { + char value[8]; + + str2addr (argvect[1], &addr); + if (read_memory (&addr, size, 1, value)) + { + xprintf ("Memory read failed\n"); + } + else + { + display_memory (value, size, get_memory_display_mode ()); + xprintf ("\n"); + } + } + else + { + xprintf ("Not enough arguments\n"); + return mem_cmd (USAGE); + } + } + return 0; +} + +/* Poke a single byte in memory. */ + +static int +poke (void) +{ + int size = 0; + + size = get_cmd_size (); + if (size > 0) + { + /* We already checked to see if the command was legal when we called the + function, so there's no need to worry about that here. */ + + if ((argvect[1] != 0) && (argvect[2] != 0)) + { + char value[8]; + mem_addr_t addr; + + str2addr (argvect[1], &addr); + hex2bytes (argvect[2], value, size); + + if (get_memory_display_mode ()) + { + /* Gotta swap this puppy. */ + int x; + + for (x = 0; x < (size / 2); x++) + { + char tmp = value[x]; + value [x] = value [size - 1 - x]; + value [size - 1 - x] = tmp; + } + } + if (write_memory (&addr, size, 1, value)) + { + xprintf ("Memory write failed\n"); + } +#ifdef HAVE_BSP + bsp_flush_dcache((void *)addr.addr, size); + bsp_flush_icache((void *)addr.addr, size); +#endif + } + else + { + xprintf ("Not enough arguments\n"); + return mem_cmd (USAGE); + } + } + return 0; +} + + +/* I am cheap and easy. */ +int +mem_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("memory[.size] address [value]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("read/write memory"); + return 0; + } + if (mode == LONG_HELP) + { + mem_cmd (USAGE); + long_help ("\ +The memory command is used to view and modify single locations in memory.\n\ +It can take a size extension, which follows the command name or partial\n\ +command name without a space, and is a period followed by the number of\n\ +bits to be viewed or modified. Options are 8, 16, 32, and 64. Without\n\ +a size extension, the memory command defaults to displaying or changing 8\n\ +bits at a time.\n\ +The memory command can take one or two arguments, independent of\n\ +whether a size extension is specified. With one argument, it displays the\n\ +contents of the specified location. With two arguments, it replaces the\n\ +contents of the specified location with the specified value.\n"); + example ("\ +memory.8 45f6b2 57\n\ +Places the 8 bit value 57 at the location 45f6b2."); + return 0; + } + + if (argvect[1] == NULL || (argvect[2] != NULL && argvect[3] != NULL)) + { + return mem_cmd (USAGE); + } + if (argvect[1] != NULL && argvect[2] != NULL) + return poke (); + else + return peek (); +} + +/* Memory dump function. */ + +int +dump_cmd (cmdmode_t mode) +{ + mem_addr_t addr; + char value[8]; + + if (mode == USAGE) + { + usage ("dump[.size] location [count]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Memory dump command"); + return 0; + } + if (mode == LONG_HELP) + { + dump_cmd (USAGE); + long_help ("\ +The dump command displays a region of memory. If no count value is\n\ +supplied, the command displays 16 bytes. It can take a size\n\ +extension, which follows the command name or partial command name\n\ +without a space, and is a period followed by the number of bits to be\n\ +viewed or modified. Options are 8, 16, 32, and 64. Without a size\n\ +extension, the dump command defaults to displaying 8 bits at a time.\n\ +Addresses are aligned to a 16-byte boundary. Thus, dump 65 would show\n\ +all bytes from 60 through 6f.\n"); + example ("\ +dump 44f5\n\ +Displays 16 bytes starting with 44f0 and ending with 44ff."); + return 0; + } + + if (argvect[1] != 0 && (argvect[2] == NULL || argvect[3] == NULL)) + { + mem_addr_t start_addr; + char chardumps[32]; + int offset; + int count; + int line; + int size = get_cmd_size (); + int i; + + if (size == -1) + /* + * Invalid size specified. + */ + return 0; + + str2addr (argvect[1], &addr); + if (argvect[2] != NULL) + { + count = str2int (argvect[2], 10); + count = (count + 15) / 16; + } + else + { + count = 1; + } + ADD_ALIGN(&addr, &start_addr, 16); + for (line = 0; line < count; line ++) + { + for (offset = 0; offset < 16; offset += size) + { + ADD_OFFSET(&start_addr, &addr, offset + line * 16); + + if (offset == 0) + { + char buf[32]; + + addr2str (&addr, buf); + xprintf("%s: ", buf); + } + if (read_memory (&addr, size, 1, value)) + { + display_memory (0, size, get_memory_display_mode ()); + for (i = 0; i < size; i++) + { + value[i] = 0; + } + } else { + display_memory (value, size, get_memory_display_mode ()); + } + xprintf (" "); + for (i = 0; i < size; i++) + { + chardumps[offset + i] = value[i] & 0x7f; + if (chardumps[offset + i] < 32) + chardumps[offset + i] = '.'; + } + } + xprintf (" "); + for(i = 0; i < offset; i++) + { + xprintf ("%c", chardumps[i]); + } + xprintf ("\n"); + } + } + else + { + dump_cmd (USAGE); + } + return 0; +} + +static int scnt; +static int (*srec_input_char) (void); + +static inline int +gethexnibble(void) +{ + int ch; + + inbuf[scnt++] = ch = srec_input_char(); + if (ch >= '0' && ch <= '9') + return (ch - '0'); + if (ch >= 'a' && ch <= 'f') + return (ch - 'a' + 10); + if (ch >= 'A' && ch <= 'F') + return (ch - 'A' + 10); + + inbuf[scnt] = '\0'; + xprintf("Bad hex char: %s\n", inbuf); + return -1; +} + + +static inline int +gethexbyte(void) +{ + int nib; + unsigned char n; + + if ((nib = gethexnibble()) < 0) + return -1; + n = nib << 4; + if ((nib = gethexnibble()) < 0) + return -1; + n |= nib; + return n; +} + +static inline int +chk_cksum(unsigned int cksum, int rval) +{ + int n; + + if ((n = gethexbyte()) < 0) + return -1; + + cksum = ~cksum & 0xff; + + if (cksum != n) + { + inbuf[scnt] = '\0'; + xprintf("Bad cksum[%02x]: %s\n", cksum, inbuf); + return -1; + } + return rval; +} + +int +load_srec(srec_input_func_t inp_func) +{ + int count, dcount, data, n, addr_bytes = 0, is_term, is_comment; + unsigned int address, cksum; + unsigned char data_buf[256]; + mem_addr_t memaddr; + + srec_input_char = inp_func; + + is_comment = is_term = 0; + + while (srec_input_char() != 'S') + ; + + scnt = 0; + inbuf[scnt++] = 'S'; + + if ((n = gethexnibble()) < 0) + return -1; + + switch (n) + { + case 0: + case 5: + is_comment = 1; + break; + + case 1: + case 2: + case 3: + addr_bytes = n + 1; + break; + + case 7: + case 8: + case 9: + is_term = 1; + addr_bytes = 11 - n; + break; + + default: + inbuf[scnt] = '\0'; + xprintf("Bad record type: %s\n", inbuf); + return -1; + } + + if ((count = gethexbyte()) < 0) + return -1; + cksum = count; + + --count; /* don't count chksum */ + + if (is_comment) + { + while (count > 0) + { + if ((n = gethexbyte()) < 0) + return -1; + cksum += n; + --count; + } + return chk_cksum(cksum, 0); + } + + address = 0; + while (count > 0 && addr_bytes) + { + if ((n = gethexbyte()) < 0) + return -1; + cksum += n; + address = (address << 8) | n; + --addr_bytes; + --count; + } + + if (is_term) + { + if (count || addr_bytes) + { + inbuf[scnt] = '\0'; + xprintf("Malformed record cnt[%d] abytes[%d]: %s\n", + count, addr_bytes, inbuf); + return -1; + } + if (chk_cksum(cksum, 1) == 1) + { + set_pc (address); + xprintf("Setting start address: 0x%08x\n", address); + return 1; + } + return -1; + } + + dcount = 0; + + while (count > 0) + { + if ((data = gethexbyte()) < 0) + return -1; + cksum += data; + data_buf[dcount++] = data; + --count; + } + + if (chk_cksum(cksum, 0)) + return -1; + + MAKE_STD_ADDR (address, &memaddr); + write_memory (&memaddr, 1, dcount, data_buf); +#ifdef HAVE_BSP + bsp_flush_dcache((void *)memaddr.addr, dcount); + bsp_flush_icache((void *)memaddr.addr, dcount); +#endif + + return 0; +} + + +int +load_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("load"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Load srecords into memory"); + return 0; + } + if (mode == LONG_HELP) + { + load_cmd (USAGE); + long_help ("\ +The load command switches the monitor into a state where it takes all input +as s-records and stores them in memory. The monitor exits this mode when a +termination record is hit, or certain errors (such as an invalid s-record) +cause the load to fail."); + return 0; + } + + if (argvect[1] != NULL) + { + return load_cmd (USAGE); + } + + while (!load_srec(xgetchar)) + ; + + return 0; +} + +#ifndef REGNAME_EXAMPLE +# define REGNAME_EXAMPLE "a0" +#endif + +#if !defined(__ECOS__) || defined(CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS) +int +transfer_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("$"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Transfer to gdb stub"); + return 0; + } + if (mode == LONG_HELP) + { + transfer_cmd (USAGE); + long_help ("\ +The transfer or $ command transfers control to the gdb stub. This function\n\ +does not actually need to be called by the user, as connecting to the board\n\ +with gdb will call it automatically. The transfer command takes no\n\ +arguments. The $ command does not wait for a return, but executes\n\ +immediately. A telnet setup in line mode will require a return when $ is\n\ +executed by the user, as the host computer does not pass any characters to\n\ +the monitor until a return is pressed. Disconnecting from the board in gdb\n\ +automatically returns control to the monitor."); + return 0; + } + if (argvect[1] == NULL) + { + return transfer_to_stub (); + } + else + { + transfer_cmd (USAGE); + } + return 0; +} +#endif + +static void +display_group (int which_group) +{ + int len = 0; + int skipping_group = 0; + char buf[80]; + int start_entry = 0; + int i; + + if (which_group >= 0) + { + start_entry = which_group; + } + + for (i = start_entry; regtab[i].registername != NULL; i++) + { + int buflen; + + if (regtab[i].registernumber < 0) + { + if (which_group >= 0 && i != which_group) + { + break; + } + + if (len > 0) + { + xprintf ("\n"); + len = 0; + } + if (which_group < 0) + { + if (regtab[i].registernumber == -2) + { + skipping_group = 1; + xprintf ("[skipping %s]\n", regtab[i].registername); + } + else + { + skipping_group = 0; + xprintf ("[%s]\n", regtab[i].registername); +#if 0 + len = strlen (regtab[i].registername) + 2; + while (len < MAXLINES) + { + xputchar (' '); + len++; + } +#endif + } + } + } + else + if (!skipping_group) + { +#ifdef REG_VALID_FIELD_IN_REGSTRUCT +#define REGVALID_VAL regtab[i].registervalid +#else +#define REGVALID_VAL 1 +#endif + xsprintf(buf, "%4s: %s", + regtab[i].registername, + get_register_str (regtab[i].registernumber, 0 , REGVALID_VAL)); +#undef REGVALID_VAL + buflen = strlen (buf); + if ((buflen + len + 3) >= 80) + { + xprintf ("\n"); + len = 0; + } + else if(len > 0) + { + xprintf (" "); + len += 3; + } + + xprintf (buf); + len += buflen; + } + } + if (len > 0) + { + xprintf ("\n"); + } +} + +static int +getregister (void) +{ + int i; + + if (argvect[1] == 0) + { + display_group (-1); + } + else + { + for (i = 0; regtab[i].registername != NULL; i++) + { + if (!(strcmp (argvect[1], regtab[i].registername))) + { + break; + } + } + if (regtab[i].registername == NULL) + { + xprintf ("No such register\n"); + } + else + { + if (regtab[i].registernumber < 0) + { + display_group (i); + } + else + { +#ifdef REG_VALID_FIELD_IN_REGSTRUCT +#define REGVALID_VAL regtab[i].registervalid +#else +#define REGVALID_VAL 1 +#endif + xprintf("%s: %s\n", argvect[1], + get_register_str (regtab[i].registernumber, 1, REGVALID_VAL)); +#undef REGVALID_VAL + } + } + } + return 0; +} + +static int +setregister (void) +{ + int number = -1; + int i; + if ((argvect[1] != 0) && (argvect[2] != 0)) + { + i = 0; + while (regtab[i].registername != NULL) + { + if (!(strcmp (argvect[1], regtab[i].registername))) + { + number = regtab[i].registernumber; + break; + } + i++; + } + if (number < 0) + xprintf ("Unknown register name %s\n", argvect[1]); + else + store_register (number, argvect[2]); + } + else + { + xprintf ("Not enough arguments\n"); + } + return 0; +} + + +int +reg_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("register [register name] [value]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("View and manipulate registers"); + return 0; + } + if (mode == LONG_HELP) + { + reg_cmd (USAGE); + long_help ("\ +The register command allows the viewing and manipulation of register\n\ +contents. It can take zero, one, or two arguments. When called with zero\n\ +arguments, the register command displays the values of all registers. When\n\ +called with only the register name argument, it displays the contents of\n\ +the specified register. When called with both a register name and a value,\n\ +it places that value into the specified register.\n"); + example ("\ +register " REGNAME_EXAMPLE " 1f\n\ +Places the value 1f in the register " REGNAME_EXAMPLE); + return 0; + } + + if (argvect[1] != NULL && argvect[2] != NULL) + { + if (argvect[3] != NULL) + { + return reg_cmd (USAGE); + } + return setregister (); + } + else + return getregister (); +} + + +/* execute the program in memory */ +int +go_cmd (cmdmode_t mode) +{ +#ifdef HAS_TIMER + extern tick_type start_tickcount; +#endif + + if (mode == USAGE) + { + usage ("go [location]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Start user program execution"); + return 0; + } + if (mode == LONG_HELP) + { + go_cmd (USAGE); + long_help ("\ +The go command starts user program execution. It can take zero or one\n\ +argument. If no argument is provided, go starts execution at the current\n\ +pc. If an argument is specified, go sets the pc to that location, and then\n\ +starts execution at that location.\n"); + example (" +go 40020000\n\ +Sets the pc to 40020000, and starts program execution."); + return 0; + } + + if (argvect[1] != NULL && argvect[2] != NULL) + { + return go_cmd (USAGE); + } + if (argvect[1] != NULL) + { + set_pc (str2int (argvect[1], 16)); + } + +#ifdef HAS_TIMER + start_tickcount = __read_ticks (); +#endif + /* We want monitor_loop to exit now. */ + return 1; +} + +#ifdef HAS_TIMER +int +timer_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("timer [state]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Enable and disable timer"); + return 0; + } + if (mode == LONG_HELP) + { + timer_cmd (USAGE); + long_help ("\ +The timer command allows control of the on board timer. It takes zero\n\ +or one argument. With zero arguments, it displays the state of the timer,\n\ +with one argument, which can start with e or d, it enables or disables the\n\ +timer, respectively.\n"); + example ("\ +timer e\n\ +Enables the timer."); + return 0; + } + + if (argvect[1] != NULL) + { + if (argvect[2] != NULL) + { + return timer_cmd (USAGE); + } + else if (argvect[1][0] == 'e') + { + __settimer (0, 0); + } + else if (argvect[1][0] == 'd') + { + __disable_timer (); + } + else + { + timer_cmd (USAGE); + } + } + if (__timer_enabled ()) + { + xprintf ("Timer is currently enabled.\n"); + } + else + { + xprintf ("Timer is currently disabled.\n"); + } + return 0; +} +#endif + +int +clear_breakpoint_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("unbreak location"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Clear breakpoint"); + return 0; + } + if (mode == LONG_HELP) + { + clear_breakpoint_cmd (USAGE); + long_help ("\ +The unbreak command removes breakpoints from memory. It takes one\n\ +argument, the location to remove the breakpoint from.\n"); + example ("\ +unbreak 4ff5\n\ +Removes a previously set breakpoint at memory location 4ff5."); + return 0; + } + + if (argvect[1] == NULL || argvect[2] != NULL) + { + clear_breakpoint_cmd (USAGE); + } + else + { + mem_addr_t location; + str2addr (argvect[1], &location); + if (clear_mon_breakpoint (location)) + { + xprintf("Unable to remove breakpoint at 0x%08lx\n", location.addr); + } + } + return 0; +} + + +int +breakpoint_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("break [location]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Set or display breakpoints"); + return 0; + } + if (mode == LONG_HELP) + { + breakpoint_cmd (USAGE); + long_help ("\ +The break command displays and sets breakpoints in memory. It takes zero\n\ +or one argument. With zero arguments, it displays a list of all currently\n\ +set breakpoints. With one argument it sets a new breakpoint at the\n\ +specified location.\n"); + example ("\ +break 4ff5\n\ +Sets a breakpoint at address 4ff5."); + return 0; + } + + if (argvect[1] == NULL) + { + return show_breakpoints (); + } + else if (argvect[2] != NULL) + { + breakpoint_cmd (USAGE); + } + else + { + mem_addr_t location; + + str2addr (argvect[1], &location); + if (add_mon_breakpoint (location)) + { + xprintf("Unable to set breakpoint at 0x%08lx\n", location.addr); + } + } + return 0; +} + + +int +version_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("version"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Display version"); + return 0; + } + if (mode == LONG_HELP) + { + version_cmd (USAGE); + long_help ("\ +The version command displays the version of the monitor."); + return 0; + } + + if (argvect[1] == NULL) + { + version (); + } + else + { + version_cmd (USAGE); + } + return 0; +} + +int +set_serial_port_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("port [port number]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Set the active serial port"); + return 0; + } + if (mode == LONG_HELP) + { + set_serial_port_cmd (USAGE); + long_help ("\ +The port command allows control over the serial port being used by the\n\ +monitor. It takes zero or one argument. Called with zero arguments it\n\ +displays the port currently in use by the monitor. Called with one\n\ +argument it switches the port in use by the monitor to the one specified.\n\ +It then prints out a message on the new port to confirm the switch.\n"); + example ("\ +port 1\n\ +Switches the port in use by the monitor to port 1."); + return 0; + } + if (argvect[1] != NULL && argvect[2] != NULL) + { + set_serial_port_cmd (USAGE); + return 0; + } + if (argvect [1] != NULL) + { +#ifdef HAVE_BSP + if (bsp_set_debug_comm(str2int (argvect[1], 10)) < 0) + xprintf("Invalid port number.\n"); + else + /* Since we are using the new port, we just need to write + something to tell the user that this is the active port */ + xprintf ("Cygmon I/O now on this port.\n"); +#else + __setTty (str2int (argvect[1], 10)); + /* Since we are using the new port, we just need to write + something to tell the user that this is the active port */ + xprintf ("Cygmon I/O now on this port.\n"); +#endif + } + else + { + xprintf ("serial port currently set to %d\n", __getTty()); + return 0; + } + return 0; +} + +int +step_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("step [location]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Single step user program"); + return 0; + } + if (mode == LONG_HELP) + { + step_cmd (USAGE); + long_help ("\ +The step command causes one instruction of the user program to execute, then\n\ +returns control to the monitor. It can take zero or one argument. If no\n\ +argument is provided, step executes one instruction at the current pc. If\n\ +a location is specified, step executes one instruction at the specified\n\ +location.\n"); + example (" +step\n\ +Executes one instruction at the current pc."); + return 0; + } + + if (argvect[1] != NULL && argvect[2] != NULL) + { + step_cmd (USAGE); + return 0; + } + if (argvect[1] != NULL) + set_pc (str2int (argvect[1], 16)); + + __single_step (); + return 1; + +} + +#if HAVE_CACHE +/* This cache function needs to be in processor-specific files. */ + +int +cache_cmd (cmdmode_t mode) +{ + int x; + int cache_op = CACHE_NOOP; + int which_cache = -1; + + if (mode == USAGE) + { + usage ("cache [type] [state]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Manipulate caches"); + return 0; + } + if (mode == LONG_HELP) + { + cache_cmd (USAGE); + long_help ("\ +The cache command displays and changes the states of the caches. It takes\n\ +zero, one, or two arguments. With no arguments, it displays the state of\n\ +both the instruction cache and the data cache. With one argument, it\n\ +displays the state of the specified type of cache. With two arguments, it\n\ +changes the state of the specified cache to the specified state.\n"); + example ("\ +cache i d\n\ +Disables the instruction cache."); + return 0; + } + + if (argvect[1] != NULL && argvect[2] != NULL && argvect[3] != NULL) + { + return cache_cmd (USAGE); + } + if (argvect[1] != NULL) + { + if (argvect[1][0] == 'd') + which_cache = 0; + else if (argvect[1][0] == 'i') + which_cache = 1; + else + { + xprintf ("unknown cache type %s\n", argvect[1]); + return 0; + } + if (argvect[2] != NULL) + { + if (argvect[2][0] == 'e') + cache_op = CACHE_ENABLE; + else if (argvect[2][0] == 'd') + cache_op = CACHE_DISABLE; + else if (argvect[2][0] == 'f') + cache_op = CACHE_FLUSH; + else + { + xprintf ("Unknown cache op %s\n", argvect[2]); + return 0; + } + } + } + if (which_cache == 0 || which_cache == -1) + { + __data_cache (cache_op); + if (cache_op == CACHE_FLUSH) + { + xprintf ("Flushed dcache\n"); + } + x = __data_cache (CACHE_NOOP); + xprintf ("dcache is "); + xprintf (x ? "enabled\n" : "disabled\n"); + } + if (which_cache == 1 || which_cache == -1) + { + __instruction_cache (cache_op); + if (cache_op == CACHE_FLUSH) + { + xprintf ("Flushed icache\n"); + } + x = __instruction_cache (CACHE_NOOP); + xprintf ("icache is "); + xprintf (x ? "enabled\n" : "disabled\n"); + } + return 0; +} +#endif + +int +set_serial_speed_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("baud speed"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Set serial port baud rate"); + return 0; + } + if (mode == LONG_HELP) + { + set_serial_speed_cmd (USAGE); + long_help ("\ +The baud command sets the speed of the active serial port. It takes one\n\ +argument, which specifies the speed to which the port will be set.\n"); + example ("\ +baud 9600\n\ +Sets the speed of the active port to 9600 baud."); + return 0; + } + + if (argvect[1] == NULL || argvect[2] != NULL) + { + return set_serial_speed_cmd (USAGE); + } + else + { +#ifdef HAVE_BSP + int channel_id = bsp_set_debug_comm(-1); + int baud = str2int (argvect[1], 10); + + xprintf("Setting serial baud rate on channel %d to %d baud\n", + channel_id, baud); + + if (bsp_set_serial_baud(bsp_set_debug_comm(-1), + str2int (argvect[1], 10)) < 0) + xprintf("Invalid baud rate\n"); +#else + __set_baud_rate (str2int (argvect[1], 10)); +#endif + } + return 0; +} + + +int +set_term_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("terminal type"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Set the terminal type"); + return 0; + } + if (mode == LONG_HELP) + { + set_term_cmd (USAGE); + long_help ("\ +The terminal command sets the type of the current terminal to that specified\n\ +in the type argument. The only available terminal types are vt100 and dumb.\n\ +This is used by the line editor to determine how to update the terminal\n\ +display.\n"); + example ("\ +terminal dumb\n\ +Sets the type of the current terminal to a dumb terminal.\n"); + return 0; + } + + if (argvect[1] == NULL || argvect[2] != NULL) + set_term_cmd (USAGE); + else + set_term_name (argvect[1]); + return 0; +} + +int +reset_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("reset"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Reset the board (not on all architectures)."); + return 0; + } + if (mode == LONG_HELP) + { + reset_cmd (USAGE); + long_help ("\ +The reset command resets the board. This may not be implemented\n\ +on all architectures"); + return 0; + } + + if (argvect[1] != NULL) + { + reset_cmd (USAGE); + } + else + { + __reset (); + } + return 0; +} + +#if HAVE_USAGE +int +memusage_cmd (cmdmode_t mode) +{ + extern int sdata, _end; + + if (mode == USAGE) + { + usage ("usage"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Show monitor memory usage"); + return 0; + } + if (mode == LONG_HELP) + { + memusage_cmd (USAGE); + long_help ("\ +The usage command shows the amount of memory being used by the monitor,\n\ +broken down by category. Despite its name, it has nothing to do with the\n\ +usage of any other command.\n"); + return 0; + } + + if (argvect[1] != NULL) + { + return memusage_cmd (USAGE); + } + else + { + xprintf ("%d bytes were allocated with sbrk\n", (char *)sbrk (0) - (char *)&_end); + } + return 0; +} +#endif /* HAVE_USAGE */ + +int +disassemble_cmd (cmdmode_t mode) +{ +#ifdef DISASSEMBLER + int x; + + if (mode == USAGE) + { + usage ("disassemble [location]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Disassemble memory"); + return 0; + } + if (mode == LONG_HELP) + { + disassemble_cmd (USAGE); + long_help ("\ +The disassemble command disassembles the contents of memory. Because of the\n\ +way breakpoints are handled, all instructions are shown and breakpoints are\n\ +not visible in the disassembled code. The disassemble command takes zero\n\ +or one argument. When called with zero arguments, it starts disassembling\n\ +from the current (user program) pc. When called with a location, it starts\n\ +disassembling from the specified location. When called after a previous\n\ +call and with no arguments, it disassembles the next area of memory after\n\ +the one previously disassembled.\n"); + example ("\ +disassemble 45667000\n\ +Displays disassembled code starting at location 45667000."); + return 0; + } + if (argvect [1] != NULL && argvect[2] != NULL) + { + return disassemble_cmd (USAGE); + } + + if(argvect [1] != NULL) + str2addr (argvect [1], &last_pc); + for (x = 0; x < 10; x++) + last_pc = do_dis (&last_pc); + flush_dis (); +#else +#warning "DISASSEMBLER not implemented" + xprintf ("disassembler not available\n"); +#endif + + return 0; +} + +int +copy_cmd (cmdmode_t mode) +{ + mem_addr_t src, dst; + target_register_t size; + + if (mode == USAGE) + { + usage ("copy startaddr destaddr amount"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Copies one area of memory to another"); + return 0; + } + if (mode == LONG_HELP) + { + copy_cmd (USAGE); + long_help ("\ +The copy command is used to copy 'amount' bytes of memory\n\ +from 'startaddr' to 'destaddr'\n"); + example ("\ +copy 10000 20000 300\n\ +Copies 0x300 bytes of memory from 0x10000 to 0x20000."); + return 0; + } + if (argvect[1] == NULL || argvect[2] == NULL || argvect[3] == NULL + || argvect[4] != NULL) + { + return copy_cmd (USAGE); + } + str2addr (argvect[1], &src); + str2addr (argvect[2], &dst); + size = str2int (argvect[3], 16); + while (size > 0) + { + char buf[128]; + + int msize = (size > 128) ? 128 : size; + if (read_memory (&src, 1, msize, buf)) + { + xprintf ("Memory read failed\n"); + break; + } + if (write_memory (&dst, 1, msize, buf)) + { + xprintf ("Memory write failed\n"); + break; + } +#ifdef HAVE_BSP + bsp_flush_dcache((void *)dst.addr, msize); + bsp_flush_icache((void *)dst.addr, msize); +#endif + ADD_OFFSET (&src, &src, msize); + ADD_OFFSET (&dst, &dst, msize); + size -= msize; + } + return 0; +} + +#ifndef HAVE_BSP +int +set_program_args_cmd (cmdmode_t mode) +{ + int argc; + + if (mode == USAGE) + { + usage ("setargs [args]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Sets the program arguments passed to main()"); + return 0; + } + if (mode == LONG_HELP) + { + set_program_args_cmd (SHORT_HELP); + return 0; + } + for (argc = 1; argvect[argc] != NULL; argc++) + ; + __set_program_args (argc - 1, argvect + 1); + return 0; +} +#endif + + +int +fill_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("fill[.size] startaddress endaddress [value]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Fills memory with a specified value"); + return 0; + } + if (mode == LONG_HELP) + { + fill_cmd (USAGE); + long_help("\ +The fill command is used to fill a region of memory from 'startaddress'\n\ +to 'endaddress' with the value in 'value'. If no value is specificed,\n\ +it uses zero. It can take a size extension, which follows the command\n\ +name or partial command name without a space, and is a period followed\n\ +by the size of the writes that are used, in bits. Options are 8, 16,\n\ +32, and 64. Without a size extension, the fill command defaults to\n\ +changing 8 bits at a time.\n"); + example ("\ +fill.32 10000 20000 32\n\ +Fills the region between 0x10000 and 0x20000 with the 32 bit value 0x32."); + return 0; + } + if ((argvect[1] == NULL || argvect[2] == NULL) + || (argvect[3] != NULL && argvect[4] != NULL)) + { + fill_cmd (USAGE); + return 0; + } else { + mem_addr_t start,end; + char value[8]; + int size = get_cmd_size(); + int amt; + + if (size == -1) + /* + * Invalid size specified. + */ + return 0; + + if (argvect[3] != NULL) + { + hex2bytes (argvect[3], value, size); + } + else + { + hex2bytes ("0", value, size); + } + str2addr (argvect[1], &start); + str2addr (argvect[2], &end); + amt = MEM_ADDR_DIFF (end, start); + if (amt < 0) + { + xprintf ("Addresses in incorrect order\n"); + } + else + { + int x; + if (get_memory_display_mode ()) + { + /* Gotta swap this puppy. */ + int x; + + for (x = 0; x < (size / 2); x++) + { + char tmp = value[x]; + value [x] = value [size - 1 - x]; + value [size - 1 - x] = tmp; + } + } + + xprintf ("Writing %d units\n", amt / size + 1); + for (x = amt / size; x >= 0; x--) + { + if (write_memory (&start, size, 1, value)) + { + xprintf ("Memory write failed\n"); + break; + } + ADD_OFFSET (&start, &start, size); + } + } + } + return 0; +} + + +int +swapmem_cmd (cmdmode_t mode) +{ + int display_settings = 0; + + if (mode == USAGE) + { + usage ("swapmem [little|big]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Sets whether or not memory values are byte-swapped"); + return 0; + } + if (mode == LONG_HELP) + { + swapmem_cmd (USAGE); + + long_help("\ +The swapmem command is used to determine whether or not memory values are\n\ +displayed and written in little or big-endian byte order. By default, values\n\ +are read and written to match the byte order of the target CPU.\n\ +This command does not alter the CPU state in any way; it only changes the\n\ +way memory values are displayed and written within the monitor.\n"); + example("\ +swapmem \n\ +Displays the byte order that is currently in effect."); + return 0; + display_settings = 1; + } + else + { + if (argvect[1] != NULL && argvect[2] != NULL) + { + swapmem_cmd (USAGE); + return 0; + } + } + if (display_settings || argvect[1] == NULL) + { + if (get_memory_display_mode ()) + { + xprintf ("Memory values are read and written in little-endian byte order.\n"); + } + else + { + xprintf ("Memory values are read and written in big-endian byte order.\n"); + } + return 0; + } + if (strncmp (argvect[1], "little", strlen (argvect[1])) == 0) + { + set_memory_display_mode (1); + xprintf ("Memory values are now read and written in little-endian order.\n"); + } + else if (strncmp (argvect[1], "big", strlen (argvect[1])) == 0) + { + set_memory_display_mode (0); + xprintf ("Memory values are now read and written in big-endian order.\n"); + } + else + { + return swapmem_cmd (USAGE); + } + return 0; +} + +#ifdef MONITOR_CONTROL_INTERRUPTS +int +int_cmd (cmdmode_t mode) +{ + if (mode == USAGE) + { + usage ("interrupt [on|off]"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("Enables or disables interrupts within the monitor"); + return 0; + } + if (mode == LONG_HELP) + { + int_cmd (USAGE); + long_help("\ +The interrupt command is used to enable or disable interrupts while the\n\ +monitor is running."); + return 0; + } + if (argvect[1] != NULL && argvect[2] != NULL) + { + int_cmd (USAGE); + return 0; + } + if (argvect[1] != NULL) + { + if (strcmp (argvect[1], "on") == 0) + { + monitor_enable_interrupts (); + } + else if (strcmp (argvect[1], "off") == 0) + { + monitor_disable_interrupts (); + } + else + { + int_cmd (USAGE); + return 0; + } + } + xprintf ("Interrupts "); + if (monitor_interrupt_state ()) + { + xprintf ("enabled\n"); + } + else + { + xprintf ("disabled\n"); + } + return 0; +} +#endif + + +/* Table used by the crc32 function to calcuate the checksum. */ +static uint32 crc32_table[256]; +static int crc_initted = 0; + +static uint32 +crc32 (unsigned char *buf, int len, uint32 crc) +{ + if (! crc_initted) + { + /* Initialize the CRC table and the decoding table. */ + int i, j; + uint32 c; + + crc_initted = 1; + for (i = 0; i < 256; i++) + { + for (c = i << 24, j = 8; j > 0; --j) + c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); + crc32_table[i] = c; + } + } + + while (len--) + { + crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf) & 255]; + buf++; + } + return crc; +} + + +int +checksumcmd (cmdmode_t mode) +{ + mem_addr_t start, end; + uint32 crc = 0xffffffff; + + if (mode == USAGE) + { + usage ("crc startaddr endaddr"); + return 0; + } + if (mode == SHORT_HELP) + { + short_help ("checksum an area of memory"); + return 0; + } + if (mode == LONG_HELP) + { + checksumcmd (USAGE); + long_help ("\ +The crc command is used to calculate a standard CRC32 checksum of the\n\ +specified memory region. The checksum is printed out as a hexadecimal\n\ +value."); + return 0; + } + if (argvect[1] == NULL || argvect[2] == NULL || argvect[3] != NULL) + { + return checksumcmd (USAGE); + } + + str2addr (argvect[1], &start); + str2addr (argvect[2], &end); + while (start.addr < end.addr) + { + char c[1024]; + int len = end.addr - start.addr; + if (len > sizeof(c)) + len = sizeof(c); + + read_memory (&start, 1, len, c); + crc = crc32 (c, len, crc); + start.addr += len; + } + xprintf("0x%08lx is checksum\n", crc); + return 0; +} + +char **argvect; +static char argvect_cmd[MAXLINELEN]; + +static char ** +buildargv (char *input) +{ + static char *arglist[256]; + int numargs = 0; + + while (1) + { + while (isspace ((unsigned char)*input) && *input != 0) + input++; + if (*input == 0) + break; + arglist [numargs++] = input; + while (!isspace ((unsigned char)*input) && *input != 0) + input++; + if (*input == 0) + break; + *(input++) = 0; + } + arglist [numargs] = NULL; + return arglist; +} + + +int +monitor_loop (void) +{ + int state = 1, return_value = 0; + + while (state == 1) + { + /* Get a line of input, putting it in the input buffer */ + lineedit (PROMPT, inbuf, sizeof (inbuf)); + xprintf ("\n"); + + if (switch_to_stub_flag) + { +#ifndef HAVE_BSP + switch_to_stub_flag = 0; +#endif + return transfer_to_stub (); + } + + /* Separate off the command from any other stuff on the line */ + + strcpy (argvect_cmd, inbuf); + argvect = buildargv (argvect_cmd); + + if (argvect[0] != NULL && argvect[0][0] != '\0') + { + char *ptr; + int command_number; + + strcpy (cmd, argvect[0]); + + /* Function to split off . delimiters. */ + ptr = strchr (cmd, '.'); + + if (ptr != NULL && *ptr == '.') + *ptr = '\0'; + + /* See if it's an alias. */ + command_number = alias_compare (cmd); + + /* Compare input to command list, check for conflicts. */ + if (command_number < 0) + command_number = command_compare (cmd); + + /* If we found a command, just run the function */ + if (command_number >= 0) + { + int status; + /* Execute the function, if the function returns a non-zero + value, break out of the loop and return. */ + status = (*cmdtab[command_number].function) (INVOCATION); + if (status) + { + state = 0; + if (status < 0) + return_value = 1; + } + } + else + { + /* If none of the commands or aliases match, complain. */ + xprintf ("Not a legal command\n"); + } + + if (inbuf[0] != '\0') + addHistoryCmd (inbuf); + } + } + return return_value; +} + + Index: v2_0/misc/generic_mem.c =================================================================== --- v2_0/misc/generic_mem.c (nonexistent) +++ v2_0/misc/generic_mem.c (revision 1765) @@ -0,0 +1,99 @@ +//========================================================================== +// +// generic_mem.c +// +// Routines for reading and writing memory. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: +// Description: It may be appropriate to relay directly into the stubs +// implementation of read memory, without board specific +// considerations such as checking the allowed ranges of +// addresses. Perhaps there needs to be some consideration +// of address spaces or, masking addresses. +// +// This file implements a default version of reading and writing +// memory when none of this is an issue +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#ifdef HAVE_BSP +#include +#include "cpu_info.h" +#endif +#include "board.h" +#include "monitor.h" +#include "tservice.h" + +#ifndef HAVE_BSP +#include "generic-stub.h" +#endif + + +int +read_memory (mem_addr_t *src, int size, int amt, char *dst) +{ +#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_SAFE_MEMORY) + return (bsp_memory_read((unsigned char *)src->addr, MEM_ADDR_ASI(src), + size << 3, amt, dst) != amt); +#else + int totamt = size * amt; + return (totamt != __read_mem_safe (dst, (void*)src->addr, totamt)); +#endif +} + +int +write_memory (mem_addr_t *dst, int size, int amt, char *src) +{ +#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_SAFE_MEMORY) + return (bsp_memory_write((unsigned char *)dst->addr, MEM_ADDR_ASI(dst), + size << 3, amt, src) != amt); +#else + int totamt = size * amt; + return (totamt != __write_mem_safe (src, (void*)dst->addr, totamt)); +#endif +} + + + Index: v2_0/misc/unistd.h =================================================================== --- v2_0/misc/unistd.h (nonexistent) +++ v2_0/misc/unistd.h (revision 1765) @@ -0,0 +1,54 @@ +//========================================================================== +// +// unistd.h +// +// Standard Unix/POSIX environment +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Placeholder only Index: v2_0/misc/mn10300/mn10300-mon.c =================================================================== --- v2_0/misc/mn10300/mn10300-mon.c (nonexistent) +++ v2_0/misc/mn10300/mn10300-mon.c (revision 1765) @@ -0,0 +1,206 @@ +//========================================================================== +// +// mn10300-mon.c +// +// Support code to extend the generic monitor code to support +// MN10300 processors. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: Support code to extend the generic monitor code to support +// MN10300 processors. +// Description: Further board specific support is in other files. +// This file contains: +// register names lookup table +// +// Empty Stubs: +// Interval timer - This should really belong to the application +// operating system. +// +// Should not contain: +// low level uart getchar and putchar functions +// delay function to support uart +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include "monitor.h" + +struct regstruct regtab[] = +{ + {"d0", D0, 1}, + {"d1", D1, 1}, + {"d2", D2, 1}, + {"d3", D3, 1}, + {"a0", A0, 1}, + {"a1", A1, 1}, + {"a2", A2, 1}, + {"a3", A3, 1}, + {"sp", SP, 1}, + {"pc", PC, 1}, + {"mdr", MDR, 1}, + {"psw", PSW, 1}, + {"lir", LIR, 1}, + {"lar", LAR, 1}, +#ifdef CYGPKG_HAL_MN10300_AM33 + {"r0", R0, 1}, + {"r1", R1, 1}, + {"r2", R2, 1}, + {"r3", R3, 1}, + {"r4", R4, 1}, + {"r5", R5, 1}, + {"r6", R6, 1}, + {"r7", R7, 1}, + {"ssp", SSP, 1}, + {"msp", MSP, 1}, + {"usp", USP, 1}, + {"mcrh", MCRH, 1}, + {"mcrl", MCRL, 1}, + {"mcvf", MCVF, 1}, + {"mdrq", MDRQ, 1}, +#if CYGHWR_HAL_MN10300_AM33_REVISION == 2 + {"fpcr", FPCR, 1}, + {"fs0", FS0, 1}, + {"fs1", FS1, 1}, + {"fs2", FS2, 1}, + {"fs3", FS3, 1}, + {"fs4", FS4, 1}, + {"fs5", FS5, 1}, + {"fs6", FS6, 1}, + {"fs7", FS7, 1}, + {"fs8", FS8, 1}, + {"fs9", FS9, 1}, + {"fs10", FS10, 1}, + {"fs11", FS11, 1}, + {"fs12", FS12, 1}, + {"fs13", FS13, 1}, + {"fs14", FS14, 1}, + {"fs15", FS15, 1}, + {"fs16", FS16, 1}, + {"fs17", FS17, 1}, + {"fs18", FS18, 1}, + {"fs19", FS19, 1}, + {"fs20", FS20, 1}, + {"fs21", FS21, 1}, + {"fs22", FS22, 1}, + {"fs23", FS23, 1}, + {"fs24", FS24, 1}, + {"fs25", FS25, 1}, + {"fs26", FS26, 1}, + {"fs27", FS27, 1}, + {"fs28", FS28, 1}, + {"fs29", FS29, 1}, + {"fs30", FS30, 1}, + {"fs31", FS31, 1}, +#endif +#endif + { 0, 0, 1}, /* Terminating element must be last */ +} ; + +void +initialize_mon(void) +{ +} /* initialize_mon */ + +#if CYGHWR_HAL_MN10300_AM33_REVISION == 2 +extern int fpu_regs_read; +#endif + +#ifdef CYGPKG_HAL_MN10300_AM33 +extern int msp_read; +#endif + +void +initialize_mon_each_time(void) +{ + int i; +#if CYGHWR_HAL_MN10300_AM33_REVISION == 2 + // Make sure the regtab[] indicates the valid status of the FPU registers + for (i = 0; regtab[i].registername != NULL; i++) + { + if ((regtab[i].registernumber >= FP_START) && (regtab[i].registernumber <= FP_END)) + regtab[i].registervalid = fpu_regs_read; + } +#endif + +#ifdef CYGPKG_HAL_MN10300_AM33 + // Make sure the regtab[] indicates the valid status of the MSP + for (i = 0; regtab[i].registername != NULL; i++) + { + if (regtab[i].registernumber == MSP) + regtab[i].registervalid = msp_read; + } +#endif +} /* initialize_mon_each_time */ + + +#include +#include +int +machine_syscall(HAL_SavedRegisters *regs) +{ + int res, err; + target_register_t d0, d1, d2, d3; + + d0 = get_register(D0); + d1 = get_register(D1); + d2 = get_register(D2); + d3 = get_register(D3); + + err = _bsp_do_syscall(d0, // Function + d1, d2, d3, 0, // arguments, + &res); + if (err) + { + // This was a syscall. It has now been handled, so update the registers appropriately + put_register(D0, res); + bsp_skip_instruction(regs); + } + + return err; +} + + +// Utility function for printing breakpoints +void bp_print(target_register_t bp_val) +{ + bsp_printf("0x%08lx\n", (unsigned long)bp_val); +} Index: v2_0/misc/mn10300/cpu_info.h =================================================================== --- v2_0/misc/mn10300/cpu_info.h (nonexistent) +++ v2_0/misc/mn10300/cpu_info.h (revision 1765) @@ -0,0 +1,91 @@ +#ifndef __MN10300_CPU_INFO_H__ +#define __MN10300_CPU_INFO_H__ +//========================================================================== +// +// cpu_info.h +// +// Architecture information for MN10300 processors +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#define IS_MN10300 1 + +/* Temporary as long a multiple protypes are copied in multiple files */ +/* This variation does NOT clone the prototypes */ +#define NO_MALLOC 1 + +#ifndef USE_ECOS_HAL_BREAKPOINTS + +/* big enuf to store a trap in the BP structure */ + +#define BP_INST_T_DEFINED 1 +typedef unsigned char bp_inst_t ; + +#else /* USE_ECOS_HAL_BREAKPOINTS */ + +#define MEM_ADDR_DEFINED 1 +typedef struct mem_addr { + unsigned long addr; +} mem_addr_t ; + +#endif /* USE_ECOS_HAL_BREAKPOINTS */ + +typedef unsigned long target_register_t; + +#include +#include +#define PRINT_INSN print_insn_mn10300 + +#undef BFD_MACH +#define BFD_MACH 0 + +// Ensure that the reg_valid field in regstruct is used. +#define REG_VALID_FIELD_IN_REGSTRUCT +#define INITIALIZE_MON_EACH_TIME() initialize_mon_each_time() +extern void initialize_mon_each_time(void); + +#endif // __MN10300_CPU_INFO_H__ Index: v2_0/misc/mn10300/board.h =================================================================== --- v2_0/misc/mn10300/board.h (nonexistent) +++ v2_0/misc/mn10300/board.h (revision 1765) @@ -0,0 +1,103 @@ +#ifndef __CYGMON_MN10300_BOARD_H__ +#define __CYGMON_MN10300_BOARD_H__ +//========================================================================== +// +// board.h +// +// Cygmon board/platform configuration file +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +// Hardware/platform/configuration specifics + +// These defines are only necessary for using target_reg union in monitor.h +// It should be possible to remove that once the HAL integration is complete. +#if CYGHWR_HAL_MN10300_AM33_REVISION == 2 +#define HAVE_FLOAT_REGS 1 +#else +#define HAVE_FLOAT_REGS 0 +#endif +#define HAVE_DOUBLE_REGS 0 + +#define HAVE_CACHE 0 +#define HAVE_USAGE 0 +#define USE_CYGMON_PROTOTYPES 1 +#define NOMAIN 1 +#define CYGMON_SYSTEM_SERVICES 0 // Not used, fall back to BSP/HAL support + +#ifdef CYGDAT_CYGMON_USE_HELP +#define USE_HELP 1 +#endif + +#define USE_ECOS_HAL_EXCEPTIONS +#define USE_ECOS_HAL_BREAKPOINTS +#define USE_ECOS_HAL_SINGLESTEP +#define USE_ECOS_HAL_SAFE_MEMORY +extern int __read_mem_safe (void *dst, void *src, int count); +extern int __write_mem_safe (void *src, void *dst, int count); + + +#include "cpu_info.h" +extern void bp_print (target_register_t bp_val); +extern int __set_breakpoint (target_register_t addr); +extern int __remove_breakpoint (target_register_t addr); +extern void __install_breakpoint_list (void); +extern void __clear_breakpoint_list (void); +extern int __display_breakpoint_list (void (*print_func)(target_register_t)); + +#define bsp_skip_instruction(regs) __skipinst() +#define install_breakpoints() __install_breakpoints() +#define add_mon_breakpoint(bpt) __set_breakpoint((bpt).addr) +#define clear_mon_breakpoint(bpt) __remove_breakpoint((bpt).addr) +#define show_breakpoints() __display_breakpoint_list(bp_print) +#define clear_breakpoints() __clear_breakpoint_list() + +#define bsp_get_signal(exc_nr, regs) __computeSignal(exc_nr) +#define bsp_get_pc(regs) get_register(PC) +#define bsp_set_pc(pc, regs) put_register(PC, pc); + +#endif // __CYGMON_MN10300_BOARD_H__ Index: v2_0/misc/mn10300/cpu.h =================================================================== --- v2_0/misc/mn10300/cpu.h (nonexistent) +++ v2_0/misc/mn10300/cpu.h (revision 1765) @@ -0,0 +1,61 @@ +#ifndef __MN10300_CPU_H__ +#define __MN10300_CPU_H__ +//========================================================================== +// +// cpu.h +// +// MN10300 specific processor defines +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-08-11 +// Purpose: MN10300 specific processor defines +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include + +#define BSP_MAX_EXCEPTIONS CYGNUM_HAL_VSR_COUNT + +#define REG_PC PC + +#endif // __MN10300_CPU_H__ Index: v2_0/misc/cpu-mon.c =================================================================== --- v2_0/misc/cpu-mon.c (nonexistent) +++ v2_0/misc/cpu-mon.c (revision 1765) @@ -0,0 +1,61 @@ +//========================================================================== +// +// cpu-mon.c +// +// eCos BSP (for building Cygmon) +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-11 +// Description: Architecture support for Cygmon +//####DESCRIPTIONEND#### + +#include // Configuration header + +#ifdef CYGPKG_HAL_ARM +#include "arm/arm-mon.c" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "mips/mips-mon.c" +#endif + +#ifdef CYGPKG_HAL_MN10300 +#include "mn10300/mn10300-mon.c" +#endif Index: v2_0/misc/bplist-dynamic.c =================================================================== --- v2_0/misc/bplist-dynamic.c (nonexistent) +++ v2_0/misc/bplist-dynamic.c (revision 1765) @@ -0,0 +1,234 @@ +//========================================================================== +// +// bplist-dynamic.c +// +// Breakpoint list using dynamic memory. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Breakpoint list using dynamic memory. +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include "board.h" + +#ifndef USE_ECOS_HAL_BREAKPOINTS + +#include + +#ifndef NO_MALLOC +#ifndef NO_MALLOC_H +#include "malloc.h" +#else +void free (); +char *malloc (); +#endif +#endif + +#ifdef __ECOS__ +#include +#endif /* __ECOS__ */ + +/* + * A simple target breakpoint list using malloc. + * To use this package, you must define TRAP_SIZE to be the size + * in bytes of a trap instruction (max if there's more than one), + * and export a char array called _breakinst that contains a + * breakpoint trap. This package will copy trap instructions + * from _breakinst into the breakpoint locations. + */ + +static struct breakpoint_list { + target_register_t addr; + char old_contents [TRAP_SIZE]; + struct breakpoint_list *next; + char in_memory; +} *breakpoint_list = NULL; + +#ifdef NO_MALLOC +static struct breakpoint_list bp_list [MAX_BP_NUM]; +static struct breakpoint_list *free_bp_list = NULL; +static int curr_bp_num = 0; +#endif + +#ifndef BREAKINST_DEFINED +#define BREAKINST_DEFINED +extern unsigned char _breakinst[]; +#endif + +int +__set_breakpoint (target_register_t addr) +{ + struct breakpoint_list **addent = &breakpoint_list; + struct breakpoint_list *l = breakpoint_list; + struct breakpoint_list *newent; + + while (l != NULL && l->addr < addr) + { + addent = &l->next; + l = l->next; + } + + if (l != NULL && l->addr == addr) + return 2; + +#ifdef NO_MALLOC + if (free_bp_list != NULL) + { + newent = free_bp_list; + free_bp_list = free_bp_list->next; + } + else + { + if (curr_bp_num < MAX_BP_NUM) + { + newent = &bp_list[curr_bp_num++]; + } + else + { + return 1; + } + } +#else + newent = (struct breakpoint_list *) malloc (sizeof (struct breakpoint_list)); +#endif + newent->addr = addr; + newent->in_memory = 0; + newent->next = l; + *addent = newent; + return 0; +} + +int +__remove_breakpoint (target_register_t addr) +{ + struct breakpoint_list *l = breakpoint_list; + struct breakpoint_list *prev = NULL; + + while (l != NULL && l->addr < addr) + { + prev = l; + l = l->next; + } + + if (l == NULL) + return 1; + + if (l->in_memory) + { + __write_mem_safe (&l->old_contents[0], + (void*)l->addr, + sizeof (l->old_contents)); + } + + if (prev == NULL) + breakpoint_list = l->next; + else + prev->next = l->next; + +#ifdef NO_MALLOC + l->next = free_bp_list; + free_bp_list = l; +#else + free (l); +#endif + return 0; +} + +#include +#include +void +__cygmon_install_breakpoints (void) +{ + struct breakpoint_list *l = breakpoint_list; + + while (l != NULL) + { + if (! l->in_memory) + { + int len = sizeof (l->old_contents); + + if (__read_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len) + { +#ifdef WRITE_MEM_IS_MEMCPY + if (__write_mem_safe (_breakinst, (void*)l->addr, len) == (void*)l->addr) +#else + if (__write_mem_safe (_breakinst, (void*)l->addr, len) == len) +#endif + { + l->in_memory = 1; + } + } + } + l = l->next; + } + flush_i_cache (); +} + +void +__cygmon_clear_breakpoints (void) +{ + struct breakpoint_list *l = breakpoint_list; + + while (l != NULL) + { + if (l->in_memory) + { + int len = sizeof (l->old_contents); + +#ifdef WRITE_MEM_IS_MEMCPY + if (__write_mem_safe (_breakinst, (void*)l->addr, len) == (void*)l->addr) +#else + if (__write_mem_safe (&l->old_contents[0], (void*)l->addr, len) == len) +#endif + { + l->in_memory = 0; + } + } + l = l->next; + } + flush_i_cache (); +} + +#endif // USE_ECOS_HAL_BREAKPOINTS Index: v2_0/misc/Notes_CygMon_PID =================================================================== --- v2_0/misc/Notes_CygMon_PID (nonexistent) +++ v2_0/misc/Notes_CygMon_PID (revision 1765) @@ -0,0 +1,168 @@ +=========================================================================== +#####ECOSGPLCOPYRIGHTBEGIN#### +## ------------------------------------------- +## This file is part of eCos, the Embedded Configurable Operating System. +## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +## +## eCos is free software; you can redistribute it and/or modify it under +## the terms of the GNU General Public License as published by the Free +## Software Foundation; either version 2 or (at your option) any later version. +## +## eCos is distributed in the hope that it will be useful, but WITHOUT ANY +## WARRANTY; without even the implied warranty of MERCHANTABILITY or +## FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +## for more details. +## +## You should have received a copy of the GNU General Public License along +## with eCos; if not, write to the Free Software Foundation, Inc., +## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +## +## As a special exception, if other files instantiate templates or use macros +## or inline functions from this file, or you compile this file and link it +## with other works to produce a work based on this file, this file does not +## by itself cause the resulting work to be covered by the GNU General Public +## License. However the source code for this file must still be made available +## in accordance with section (3) of the GNU General Public License. +## +## This exception does not invalidate any other reasons why a work based on +## this file might be covered by the GNU General Public License. +## +## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +## at http://sources.redhat.com/ecos/ecos-license/ +## ------------------------------------------- +#####ECOSGPLCOPYRIGHTEND#### +=========================================================================== + +28 Jan 2000 + +How to build and install CygMon on the PID + +Make CygMon image +~~~~~~~~~~~~~~~~~ + +Configure and build using the 'cygmon' template for the PID +target. These are the necessary CLI instructions. It can also be done +from the Configtool by selecting the appropriate templates. + + % cd /tmp + % mkdir cygmon + % cd cygmon + % ecosconfig new pid cygmon + % ecosconfig tree + % make + +This will install some files in ./install/bin: + + cygmon.elf: The built CygMon image + cygmon.bin: The image converted to binary (suitable for burning to ROM) + cygmon.img: The relocated ELF image (suitable for FLASH writing, see below) + cygmon.srec: The image converted to srecords + +Make FLASH tool +~~~~~~~~~~~~~~~ + +Again, these are the necessary CLI instructions. It can also be done +from the Configtool by selecting the appropriate templates, and +enabling the option. + + % cd /tmp + % mkdir pid-flash + % cd pid-flash + % ecosconfig new pid + % + --- ecos.ecc.orig Fri Jan 28 11:21:43 2000 + +++ ecos.ecc Fri Jan 28 11:22:01 2000 + @@ -150,7 +150,7 @@ + cdl_option CYGBLD_BUILD_FLASH_TOOL { + # Flavor: bool + # No user value, uncomment the following line to provide one. + - # user_value 0 + + user_value 1 + # value_source default + # Default value: 0 + # Requires: CYG_HAL_STARTUP == "RAM" + % ecosconfig resolve + % ecosconfig tree + % make + +The flash tool is installed in ./install/bin + +Prepare board for CygMon +~~~~~~~~~~~~~~~~~~~~~~~~ + 1. Set jumper 7-8 on LK6 [using the Angle code in the 16 bit EPROM] + 2. Set jumper 5-6 on LK6 [select 8bit ROM mode] + 3. Set jumper LK18 [ROM remap - this is also required for eCos] + 4. Set S1 to 0-0-1-1 [20MHz operation] + + +Program FLASH +~~~~~~~~~~~~~ + 1. Download the CygMon relocated image onto the PID board: + % cd /tmp + % arm-elf-gdb -nw cygmon/install/bin/cygmon.img + + (gdb) target rdi s= + Angel Debug Monitor V1.04 (Advanced RISC Machines SDT 2.11a) for PID + Built with Serial(x1), Parallel, DCC + Rebuilt on Apr 7 1998 at 22:20:43 + Serial Rate: 9600 + Connected to ARM RDI target. + (gdb) load + Loading section .rom_vectors, size 0x60 lma 0x60000 + Loading section .text, size 0xeea8 lma 0x60060 + Loading section .rodata, size 0x304c lma 0x6ef08 + Loading section .data, size 0x7f8 lma 0x71f54 + Start address 0x60060 , load size 75596 + Transfer rate: 5548 bits/sec. + (gdb) quit + + This will download the stubs onto the board at 0x60000..0x80000 + + Use /dev/ttyS0, COM1 or similar for the name. + + 2. Now download the FLASH programmer tool + % arm-elf-gdb -nw pid-flash/install/bin/prog_flash.img + + (gdb) target rdi s= + Angel Debug Monitor V1.04 (Advanced RISC Machines SDT 2.11a) for PID + Built with Serial(x1), Parallel, DCC + Rebuilt on Apr 7 1998 at 22:20:43 + Serial Rate: 9600 + Connected to ARM RDI target. + (gdb) load + Loading section .rom_vectors, size 0x60 lma 0x4000 + Loading section .text, size 0x4964 lma 0x4060 + Loading section .rodata, size 0x384 lma 0x89c4 + Loading section .data, size 0x28c lma 0x8d48 + Start address 0x4060 , load size 20436 + Transfer rate: 5449 bits/sec. + (gdb) cont + + 3. The FLASH tool will output some text on the board serial port B at + 38400 baud: + + ARM eCos + FLASH here! + manuf: 8, device: 40 + Error: Wrong Manufaturer: 08 + ... Please change FLASH jumper + + 4. This text is repeated until you remove the jumper 7-8 on LK6. Then + the output should be: + + manuf: 1F, device: A4 + AT29C040A recognised + About to program FLASH using data at 60000..80000 + *** Press RESET now to abort! + + 5. You have about 10 seconds to abort the operation by pressing + reset. After this timeout, the FLASH programming happens: + + ...Programming FLASH + All done! + + 6. Quit/kill the GDB process which will hang. + + 7. Next time you reset the board, CygMon will be in control, communicating + on serial port A at 38400 baud. See documentation for further details + on how to connect with GDB. Index: v2_0/misc/monitor_cmd.h =================================================================== --- v2_0/misc/monitor_cmd.h (nonexistent) +++ v2_0/misc/monitor_cmd.h (revision 1765) @@ -0,0 +1,126 @@ +//========================================================================== +// +// monitor_cmd.h +// +// Monitor command definitions for the CygMON ROM monitor +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Monitor command definitions for the CygMON ROM monitor +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#ifndef MONITOR_CMD_H +#define MONITOR_CMD_H + +#ifndef ASM +typedef enum { + INVOCATION, USAGE, SHORT_HELP, LONG_HELP +} cmdmode_t; + +struct cmdentry +{ + char *alias; + char *cmd; + int (*function) (cmdmode_t); +}; + +extern struct cmdentry cmdtab []; + +extern int monitor_loop (void); + +extern char inbuf[]; + +extern char **argvect; + +typedef int (*srec_input_func_t)(void); + +extern int load_srec(srec_input_func_t inp_func); + +#ifdef USE_HELP +extern void usage (char *string); +extern void short_help (char *string); +extern void long_help (char *string); +extern void example (char *string); +#else +#define usage(x) no_help_usage () +#define short_help(x) no_help() +#define long_help(x) no_help() +#define example(x) +extern void no_help (void); +extern void no_help_usage (void); +#endif +extern int help_cmd (cmdmode_t mode); +extern int mem_cmd (cmdmode_t mode); + +extern int dump_cmd (cmdmode_t mode); +extern int ethaddr_cmd (cmdmode_t mode); +extern int ipaddr_cmd (cmdmode_t mode); +extern int tcpport_cmd (cmdmode_t mode); +extern int load_cmd (cmdmode_t mode); +extern int reg_cmd (cmdmode_t mode); +extern int go_cmd (cmdmode_t mode); +extern int othernames_cmd (cmdmode_t mode); +extern int step_cmd (cmdmode_t mode); +extern int transfer_cmd (cmdmode_t mode); +extern int timer_cmd (cmdmode_t mode); +extern int disassemble_cmd (cmdmode_t mode); +extern int breakpoint_cmd (cmdmode_t mode); +extern int clear_breakpoint_cmd (cmdmode_t mode); +extern int memusage_cmd (cmdmode_t mode); +extern int set_serial_port_cmd (cmdmode_t mode); +extern int set_serial_speed_cmd (cmdmode_t mode); +extern int version_cmd (cmdmode_t mode); +extern int cache_cmd (cmdmode_t mode); +extern int set_term_cmd (cmdmode_t mode); +extern int reset_cmd (cmdmode_t mode); +extern int copy_cmd (cmdmode_t mode); +extern int fill_cmd (cmdmode_t mode); +extern int set_program_args_cmd (cmdmode_t mode); +extern int swapmem_cmd (cmdmode_t mode); +extern int checksumcmd (cmdmode_t mode); +extern int int_cmd (cmdmode_t mode); +#endif + +#endif Index: v2_0/misc/breakpoints.c =================================================================== --- v2_0/misc/breakpoints.c (nonexistent) +++ v2_0/misc/breakpoints.c (revision 1765) @@ -0,0 +1,220 @@ +//========================================================================== +// +// breakpoints.c +// +// Support aribtrary set of breakpoints. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include "board.h" + +#ifndef USE_ECOS_HAL_BREAKPOINTS + +#include +#ifdef HAVE_BSP +#include +#include +#endif + +#include "monitor.h" +#include "tservice.h" +#include "stub-tservice.h" + +#include "fmt_util.h" + + +static struct bp *last_bp_ptr; +static struct bp *first_bp_ptr; + +#ifdef NO_MALLOC +static struct bp *free_bp_list; +static struct bp bp_list[MAX_NUM_BP]; +static int curr_bp_num; +#endif + +int +add_mon_breakpoint (mem_addr_t location) +{ + struct bp *ptr; + struct bp *new_bp_ptr; + + for (ptr = first_bp_ptr; ptr != NULL; ptr = ptr->next) + { + if (MEM_ADDR_EQ_P (ptr->address, location)) + return 1; + } +#ifdef NO_MALLOC + if (free_bp_list != NULL) + { + new_bp_ptr = free_bp_list; + free_bp_list = new_bp_ptr->next; + } + else + { + if (curr_bp_num < MAX_NUM_BP) + { + new_bp_ptr = &bp_list[curr_bp_num++]; + } + else + { + xprintf ("No more breakpoints\n"); + return 1; + } + } +#else + new_bp_ptr = (struct bp *)malloc (sizeof (struct bp)); +#endif + + if (first_bp_ptr == NULL) + { + first_bp_ptr = new_bp_ptr; + } + else + { + last_bp_ptr->next = new_bp_ptr; + } + last_bp_ptr = new_bp_ptr; + + last_bp_ptr->next = NULL; + last_bp_ptr->address = location; + last_bp_ptr->in_memory = 0; + return 0; +} + + +void +install_breakpoints (void) +{ + struct bp *ptr = first_bp_ptr; + while (ptr != NULL) + { + set_breakpoint (ptr); + ptr = ptr->next; + } +} + + +void +clear_breakpoints (void) +{ + struct bp *ptr = first_bp_ptr; + + while (ptr != NULL) + { + clear_breakpoint (ptr); + ptr = ptr->next; + } +} + +int +show_breakpoints (void) +{ + struct bp *ptr; + + for (ptr = first_bp_ptr; ptr != NULL; ptr = ptr->next) + { + char buf[20]; + + addr2str (&ptr->address, buf); + xprintf ("%s\n", buf); + } + + return 0; +} + + + +int +clear_mon_breakpoint (mem_addr_t location) +{ + int error = 0; + struct bp *ptr = first_bp_ptr; + struct bp *prev_ptr = NULL; + + /* Scan the list looking for the address to clear */ + while (ptr != NULL && !MEM_ADDR_EQ_P (ptr->address, location)) + { + /* keep a pointer one behind the current position */ + prev_ptr = ptr; + ptr = ptr->next; + } + if (ptr == NULL) + { + xprintf ("That address has no breakpoint on it.\n"); + error = 1; + } + else + { + /* Just in case it's still in memory. */ + clear_breakpoint (ptr); + + /* now we'll point the previous bp->next at the one after the one + we're deleting, unless there is no previous bp. */ + if (prev_ptr != NULL) + { + prev_ptr->next = ptr->next; + } + + if (first_bp_ptr == ptr) + first_bp_ptr = ptr->next; + + if (last_bp_ptr == ptr) + last_bp_ptr = prev_ptr; + + /* eliminate the offending bp struct */ +#ifdef NO_MALLOC + ptr->next = free_bp_list; + free_bp_list = ptr; +#else + free (ptr); +#endif + } + return error; +} + +#endif /* USE_ECOS_HAL_BREAKPOINTS */ Index: v2_0/misc/generic_fmt32.c =================================================================== --- v2_0/misc/generic_fmt32.c (nonexistent) +++ v2_0/misc/generic_fmt32.c (revision 1765) @@ -0,0 +1,98 @@ +//========================================================================== +// +// generic_fmt32.c +// +// Generic address conversion routines +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: Generic address conversion routines +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + + +#include +#ifdef HAVE_BSP +#include +#include +#endif +#include "monitor.h" +#include "fmt_util.h" + + +int +str2addr (char *string, mem_addr_t *res) +{ +#ifdef HAVE_ASI + if (string[0] == '[') + { + char *ptr = ++string; + while (*ptr && *ptr != ']') + ptr++; + + if (*ptr == 0) + return -1; + + *(ptr++) = 0; + res->asi = str2int (string, 16); + string = ptr; + } + else + res->asi = ASI_DEFAULT; +#endif + res->addr = str2int (string, 16); + return 0; +} + +void +addr2str (mem_addr_t *addr, char *dest) +{ +#ifdef HAVE_ASI + if (addr->asi != ASI_DEFAULT) + xsprintf(dest, "[%x]", addr->asi); + else +#endif + dest[0] = 0; + strcat (dest, int2str (addr->addr, 16, sizeof (void *) * 2)); +} Index: v2_0/misc/monitor.c =================================================================== --- v2_0/misc/monitor.c (nonexistent) +++ v2_0/misc/monitor.c (revision 1765) @@ -0,0 +1,494 @@ +//========================================================================== +// +// monitor.c +// +// Monitor shell and main routines for CygMON the Wonder Monitor +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: Monitor shell and main routines for CygMON the Wonder Monitor +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +/* Platform-independent code for cygmon */ + +#include +#include +#ifdef HAVE_BSP +#include +#include +#include +#endif +#include +#ifdef HAVE_BSP +#include "cpu_info.h" +#endif +#include +#include +#include +#include + +#if USE_CYGMON_PROTOTYPES +/* Use common prototypes */ +/* Some of the composed board.h files compose these + prototypes redundently, but if they dont, + these are the common definitions */ +#include "fmt_util.h" /* Interface to string formatting utilities */ +#include "tservice.h" /* Interface to target specific services */ +#include "generic-stub.h" /* from libstub */ +#endif /* USE_CYGMON_PROTOTYPES */ + +static int cygmon_handle_exception (int sigval); +static void monitor_take_control (void); + +#if CYGMON_SYSTEM_SERVICES +extern int process_syscall (int syscall_num); +#elif defined (USE_ECOS_HAL_EXCEPTIONS) +static int cygmon_process_syscall (int sigval); +#endif + +int stub_is_active = 0; +mem_addr_t last_pc; + +#ifdef HAVE_BSP + +#if !defined(USE_ECOS_HAL_EXCEPTIONS) +static int mon_dbg_handler(int exc_nr, void *regs); +static int mon_kill_handler(int exc_nr, void *regs); +#endif // USE_ECOS_HAL_EXCEPTIONS + +#ifndef USE_ECOS_HAL_BREAKPOINTS +#define __is_breakpoint_function() (get_pc() == (target_register_t)bsp_breakinsn) +#endif + +#ifdef __ECOS__ +/* + * This global flag is used by generic-stub.c to communicate to us that we + * are processing the breakpoint function within Cygmon itself. + */ +extern int processing_breakpoint_function; +#endif + +/* Global pointer to current set of saved registers. */ +void *mon_saved_regs; + +/* Original BSP debug vector replaced by monitor. */ +#if !defined(USE_ECOS_HAL_EXCEPTIONS) +static bsp_handler_t old_dbg_vec; +#endif // !defined(USE_ECOS_HAL_EXCEPTIONS) + +#else +static int handle_signal (int signal_val); + +__PFI user_signal_handler = NULL; +#endif + +#if defined(__ECOS__) +#include +#endif + +#if defined(__ECOS__) && !defined(PROCESS_EXCEPTION_VEC_PROTOTYPE_EXISTS) +#define PROCESS_EXCEPTION_VEC_PROTOTYPE_EXISTS +extern volatile __PFI (*__process_exception_vec)(int); +#endif + + +#ifdef MONITOR_CONTROL_INTERRUPTS +/* This is set if the user wants interrupts enabled in the monitor. */ +static int monitor_interrupts_enabled; +#endif + + +#if NOMAIN +int monitor_main (int argc, char **argv) /* Suppress default main() junk */ +#else +int main (int argc, char **argv) +#endif +{ +#ifdef HAVE_BSP + int cur_port; + struct bsp_comm_info comm_info; +#else + /* Set up exception handling traps */ + initialize_stub (); +#endif + + initialize_mon (); + +#ifdef HAVE_BSP + /* get info on debug channel */ + cur_port = bsp_set_debug_comm(-1); + bsp_sysinfo(BSP_INFO_COMM, cur_port, &comm_info); + + /* + * If we're using a network interface, don't install + * the cygmon vectors. Currently, we only support stub + * mode over a network connection. + */ + if (comm_info.kind != BSP_COMM_ENET) + { + xprintf("\n"); + version (); + + /* replace original BSP debug and kill handler with ours */ +#if !defined(USE_ECOS_HAL_EXCEPTIONS) + old_dbg_vec = bsp_install_dbg_handler(mon_dbg_handler); + (void)bsp_install_kill_handler(mon_kill_handler); +#else + /* replace original BSP debug and kill handler with ours using eCos stuff */ + __process_exception_vec = (__PFI)cygmon_handle_exception; + __process_syscall_vec = cygmon_process_syscall; + __process_exit_vec = monitor_take_control; +#endif // __ECOS__ + } + else + { + /* This forces the console to use the gdb channel. */ + bsp_set_console_comm(cur_port); + } +#else + xprintf("\n"); + version (); + + __process_exception_vec = cygmon_handle_exception; + __process_exit_vec = monitor_take_control; +#if CYGMON_SYSTEM_SERVICES + __process_syscall_vec = process_syscall; +#endif + __process_signal_vec = handle_signal; + __init_vec = install_breakpoints; + __cleanup_vec = clear_breakpoints; +#endif + +#if 0 +#ifdef __ECOS__ + __process_exception_vec = cygmon_handle_exception; +#endif +#endif + + while (1) + { + breakpoint (); + if (switch_to_stub_flag) + { + xprintf("Switching to stub\n"); + switch_to_stub_flag = 0; + } + } + + /* never reached */ + exit (0); +} + + +/* Transfer control to gdb stub */ + +int +transfer_to_stub () +{ + /* Return back to the exception handler, but the exception handler + should invoke the stub's exception handler instead of ours. */ +#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_EXCEPTIONS) + (void)bsp_install_dbg_handler(old_dbg_vec); +#else + __switch_to_stub (); +#endif + + /* The stub is now active. */ + stub_is_active = 1; + return -1; +} + +void +clear_user_state (void) +{ +#ifdef HAS_TIMER + if (__timer_enabled ()) + __settimer (0, 0); +#endif + + clear_breakpoints (); + +#ifndef HAVE_BSP + user_signal_handler = NULL; +#endif + + __clear_single_step (); +} + +static void +monitor_take_control (void) +{ + stub_is_active = 0; + switch_to_stub_flag = 0; + + // Flush the unget state. This is because the ecos stub and Cygmon track this + // stuff separately. + bsp_debug_ungetc('\0'); + +#ifdef INITIALIZE_MON_EACH_TIME + // Call the per-stop initialization routine if it is defined. + INITIALIZE_MON_EACH_TIME(); +#endif + +#if defined(HAVE_BSP) && !defined(USE_ECOS_HAL_EXCEPTIONS) + /* replace original BSP debug trap handler with ours */ + (void)bsp_install_dbg_handler(mon_dbg_handler); +#else + clear_user_state (); + __process_exception_vec = cygmon_handle_exception; +#endif +} + + +#ifdef MONITOR_CONTROL_INTERRUPTS +void +monitor_enable_interrupts (void) +{ + monitor_interrupts_enabled = 1; + enable_interrupts (); +} + +void +monitor_disable_interrupts (void) +{ + monitor_interrupts_enabled = 0; + disable_interrupts (); +} + +int +monitor_interrupt_state (void) +{ + return monitor_interrupts_enabled; +} +#endif + +#if defined(USE_ECOS_HAL_EXCEPTIONS) +externC HAL_SavedRegisters *_hal_registers; +extern int machine_syscall(HAL_SavedRegisters *regs); +static int +cygmon_process_syscall (int sigval) +{ + return machine_syscall(_hal_registers); +} +#endif + +static int +cygmon_handle_exception (int sigval) +{ + target_register_t pc; + +#ifdef MONITOR_CONTROL_INTERRUPTS + if (monitor_interrupts_enabled) + { + if (! __in_interrupt) + enable_interrupts (); + } +#endif + +#ifdef TARGET_EXCEPTION_CODE + TARGET_EXCEPTION_CODE +#endif + +#ifndef HAVE_BSP + if (sigval != SIGKILL) + if (handle_signal (sigval) == 0) + return 0; +#endif + + clear_user_state (); + + /* We may want to tweak the PC to point at the faulting instruction, + for example. (breakpoints on x86). */ +#ifdef TARGET_ADJUST_PC + TARGET_ADJUST_PC +#endif + + pc = get_pc(); + MAKE_STD_ADDR (pc, &last_pc); + +#ifdef __ECOS__ + if ((sigval == SIGTRAP) && (__is_breakpoint_function() || processing_breakpoint_function)) +#else + if ((sigval == SIGTRAP) && __is_breakpoint_function()) +#endif + { + /* + * This is the initial breakpoint inserted by the BSP + * Don't print anything for this as it is confusing + */ + } + else + { + if (sigval == SIGTRAP) + xprintf ("Hit breakpoint"); + else + xprintf ("Got signal %d", sigval); + + xprintf (" at 0x%s\n", int2str (pc, 16, sizeof (target_register_t) * 2)); + +#ifdef DISASSEMBLER + if (!__is_breakpoint_function ()) + { + do_dis (&last_pc); + flush_dis (); + } +#endif + } + + monitor_take_control (); + + return monitor_loop (); +} + +#ifndef HAVE_BSP +/* Returns 0 if the program should restart at the point at which the + signal was received, -1 otherwise. */ +static int +handle_signal (int signal) +{ + if (signal == SIGKILL) + return -1; + + if (user_signal_handler != NULL) + { + int result = user_signal_handler (signal); + switch (result) + { + /* Don't ignore potential hardware signals. */ + case 3: + if (signal == SIGSEGV || signal == SIGBUS || signal == SIGFPE + || signal == SIGTRAP || signal == SIGILL) + return -1; + + case 0: + return 0; + + default: + case 1: + case 2: + return -1; + } + } + return -1; +} +#endif + + +void +version (void) +{ +#ifdef HAVE_BSP + struct bsp_platform_info platform; + struct bsp_mem_info mem; + int i; + unsigned long u, totmem, topmem; +#endif + extern char *build_date; + + xprintf ("Cygmon, the Cygnus ROM monitor.\n"); + xprintf ("Copyright(c) 1997, 1998, 1999, 2000 Red Hat\n\n"); + xprintf ("Version: %s\nThis image was built on %s\n\n", + VERSION, build_date); + +#ifdef HAVE_BSP + bsp_sysinfo(BSP_INFO_PLATFORM, &platform); + + totmem = topmem = 0; + i = 0; + while (bsp_sysinfo(BSP_INFO_MEMORY, i++, &mem) == 0) + { + if (mem.kind == BSP_MEM_RAM) + { + totmem += mem.nbytes; + u = (unsigned long)mem.virt_start + mem.nbytes; + if (u > topmem) + topmem = u; + } + } + + xprintf("CPU: %s\n", platform.cpu); + xprintf("Board: %s\n", platform.board); + if (*(platform.extra)) + xprintf("%s\n", platform.extra); + xprintf("Total RAM: %d bytes\n", totmem); + xprintf("Top of RAM: 0x%x\n", topmem); +#endif +} + + +#ifdef HAVE_BSP +#if !defined(USE_ECOS_HAL_EXCEPTIONS) +static int +mon_kill_handler(int exc_nr, void *regs) +{ + monitor_take_control(); + return 1; +} +#endif // !defined(USE_ECOS_HAL_EXCEPTIONS) + +#if !defined(USE_ECOS_HAL_EXCEPTIONS) +static int +mon_dbg_handler(int exc_nr, void *regs) +{ + int sig; + unsigned long cur_pc; + + mon_saved_regs = regs; + sig = bsp_get_signal(exc_nr, regs); + + cygmon_handle_exception(sig); + + cur_pc = bsp_get_pc(regs); + if (cur_pc == (unsigned long)bsp_breakinsn) + bsp_skip_instruction(regs); + + if (!stub_is_active) + install_breakpoints(); + + return 1; +} +#endif // !defined(USE_ECOS_HAL_EXCEPTIONS) + +#endif Index: v2_0/misc/mips/mips-mon.c =================================================================== --- v2_0/misc/mips/mips-mon.c (nonexistent) +++ v2_0/misc/mips/mips-mon.c (revision 1765) @@ -0,0 +1,183 @@ +//========================================================================== +// +// mips-mon.c +// +// Support code to extend the generic monitor code to support +// MIPS processors. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-06-07 +// Purpose: Support code to extend the generic monitor code to support +// MIPS(R) processors. +// Description: Further board specific support is in other files. +// This file contains: +// register names lookup table +// +// Empty Stubs: +// Interval timer - This should really belong to the application +// operating system. +// +// Should not contain: +// low level uart getchar and putchar functions +// delay function to support uart +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include "monitor.h" + +struct regstruct regtab[] = +{ + { "zero", REG_ZERO }, + { "at", REG_AT }, + { "v0", REG_V0 }, + { "v1", REG_V1 }, + { "a0", REG_A0 }, + { "a1", REG_A1 }, + { "a2", REG_A2 }, + { "a3", REG_A3 }, + { "t0", REG_T0 }, + { "t1", REG_T1 }, + { "t2", REG_T2 }, + { "t3", REG_T3 }, + { "t4", REG_T4 }, + { "t5", REG_T5 }, + { "t6", REG_T6 }, + { "t7", REG_T7 }, + { "s0", REG_S0 }, + { "s1", REG_S1 }, + { "s2", REG_S2 }, + { "s3", REG_S3 }, + { "s4", REG_S4 }, + { "s5", REG_S5 }, + { "s6", REG_S6 }, + { "s7", REG_S7 }, + { "t8", REG_T8 }, + { "t9", REG_T9 }, + { "k0", REG_K0 }, + { "k1", REG_K1 }, + { "gp", REG_GP }, + { "sp", REG_SP }, + { "s8", REG_S8 }, + { "ra", REG_RA }, + + { "sr", REG_SR }, + { "lo", REG_LO }, + { "hi", REG_HI }, + { "badvr", REG_BAD }, + { "cause", REG_CAUSE }, + { "pc", REG_PC }, +#ifdef CYGHWR_HAL_MIPS_FPU + { "f0", REG_F0 }, + { "f1", REG_F1 }, + { "f2", REG_F2 }, + { "f3", REG_F3 }, + { "f4", REG_F4 }, + { "f5", REG_F5 }, + { "f6", REG_F6 }, + { "f7", REG_F7 }, + { "f8", REG_F8 }, + { "f9", REG_F9 }, + { "f10", REG_F10 }, + { "f11", REG_F11 }, + { "f12", REG_F12 }, + { "f13", REG_F13 }, + { "f14", REG_F14 }, + { "f15", REG_F15 }, + { "f16", REG_F16 }, + { "f17", REG_F17 }, + { "f18", REG_F18 }, + { "f19", REG_F19 }, + { "f20", REG_F20 }, + { "f21", REG_F21 }, + { "f22", REG_F22 }, + { "f23", REG_F23 }, + { "f24", REG_F24 }, + { "f25", REG_F25 }, + { "f26", REG_F26 }, + { "f27", REG_F27 }, + { "f28", REG_F28 }, + { "f29", REG_F29 }, + { "f30", REG_F30 }, + { "f31", REG_F31 }, + { "fcr31", REG_FCR31 }, +#endif /* CYGHWR_HAL_MIPS_FPU */ + { 0, 0 }, /* Terminating element must be last */ +} ; + +void +initialize_mon(void) +{ +} /* initialize_mon */ + + +#include +#include +int +machine_syscall(HAL_SavedRegisters *regs) +{ + int res, err; + target_register_t a0, a1, a2, a3; + + a0 = get_register(REG_A0); + a1 = get_register(REG_A1); + a2 = get_register(REG_A2); + a3 = get_register(REG_A3); + + err = _bsp_do_syscall(a0, // Function + a1, a2, a3, 0, // arguments, + &res); + if (err) + { + // This was a syscall. It has now been handled, so update the registers appropriately + put_register(REG_V0, res); + bsp_skip_instruction(regs); + } + + return err; +} + + +// Utility function for printing breakpoints +void bp_print(target_register_t bp_val) +{ + bsp_printf("0x%08lx\n", (unsigned long)bp_val); +} Index: v2_0/misc/mips/cpu_info.h =================================================================== --- v2_0/misc/mips/cpu_info.h (nonexistent) +++ v2_0/misc/mips/cpu_info.h (revision 1765) @@ -0,0 +1,90 @@ +#ifndef __MIPS_CPU_INFO_H__ +#define __MIPS_CPU_INFO_H__ +//========================================================================== +// +// cpu_info.h +// +// Architecture information for MIPS processors +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-06-07 +// Purpose: +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#define IS_MIPS 1 + +/* Temporary as long a multiple protypes are copied in multiple files */ +/* This variation does NOT clone the prototypes */ +#define NO_MALLOC 1 + +#ifndef USE_ECOS_HAL_BREAKPOINTS + +/* big enuf to store a trap in the BP structure */ + +#define BP_INST_T_DEFINED 1 +typedef unsigned int bp_inst_t ; + +#else /* USE_ECOS_HAL_BREAKPOINTS */ + +#define MEM_ADDR_DEFINED 1 +typedef struct mem_addr { + unsigned long addr; +} mem_addr_t ; + +#endif /* USE_ECOS_HAL_BREAKPOINTS */ + +typedef unsigned long target_register_t; + +#include +#include +#if CYG_BYTEORDER == CYG_MSBFIRST +#define PRINT_INSN print_insn_big_mips +#else +#define PRINT_INSN print_insn_little_mips +#endif + +#undef BFD_MACH +#define BFD_MACH 0 + +#endif // __MIPS_CPU_INFO_H__ Index: v2_0/misc/mips/board.h =================================================================== --- v2_0/misc/mips/board.h (nonexistent) +++ v2_0/misc/mips/board.h (revision 1765) @@ -0,0 +1,110 @@ +#ifndef __CYGMON_MIPS_BOARD_H__ +#define __CYGMON_MIPS_BOARD_H__ +//========================================================================== +// +// board.h +// +// Cygmon board/platform configuration file +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-07-11 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +// Hardware/platform/configuration specifics + +// These defines are only necessary for using target_reg union in monitor.h +// It should be possible to remove that once the HAL integration is complete. +#define HAVE_FLOAT_REGS 0 +#define HAVE_DOUBLE_REGS 0 + +#define HAVE_CACHE 0 +#define HAVE_USAGE 0 +#define USE_CYGMON_PROTOTYPES 1 +#define NOMAIN 1 +#define CYGMON_SYSTEM_SERVICES 0 // Not used, fall back to BSP/HAL support + +#ifdef CYGDAT_CYGMON_USE_HELP +#define USE_HELP 1 +#endif + +#define USE_ECOS_HAL_EXCEPTIONS +#define USE_ECOS_HAL_BREAKPOINTS +#define USE_ECOS_HAL_SINGLESTEP + +#include "cpu_info.h" +extern void bp_print (target_register_t bp_val); +extern int __set_breakpoint (target_register_t addr); +extern int __remove_breakpoint (target_register_t addr); +extern void __install_breakpoint_list (void); +extern void __clear_breakpoint_list (void); +extern int __display_breakpoint_list (void (*print_func)(target_register_t)); + +#define bsp_skip_instruction(regs) __skipinst() +#define install_breakpoints() __install_breakpoints() +#define add_mon_breakpoint(bpt) __set_breakpoint((bpt).addr) +#define clear_mon_breakpoint(bpt) __remove_breakpoint((bpt).addr) +#define show_breakpoints() __display_breakpoint_list(bp_print) +#define clear_breakpoints() __clear_breakpoint_list() + +#define bsp_get_signal(exc_nr, regs) __computeSignal(exc_nr) +#define bsp_get_pc(regs) get_register(PC) + +#define CYGARC_HAL_COMMON_EXPORT_CPU_MACROS +#include +#include "monitor.h" + +#ifdef __mips64 +#define bsp_set_pc(pc, regs) \ + put_register(PC, pc); \ + if (regs->_sr & SR_ERL) \ + put_register(EPC, pc); \ + else \ + put_register(EEPC, pc); +#else +#define bsp_set_pc(pc, regs) \ + put_register(PC, pc); +#endif + +#endif // __CYGMON_MIPS_BOARD_H__ Index: v2_0/misc/mips/cpu.h =================================================================== --- v2_0/misc/mips/cpu.h (nonexistent) +++ v2_0/misc/mips/cpu.h (revision 1765) @@ -0,0 +1,59 @@ +#ifndef __MIPS_CPU_H__ +#define __MIPS_CPU_H__ +//========================================================================== +// +// cpu.h +// +// MIPS specific processor defines +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): dmoseley +// Contributors: dmoseley +// Date: 2000-06-07 +// Purpose: MIPS specific processor defines +// Description: +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#include + +#define BSP_MAX_EXCEPTIONS CYGNUM_HAL_VSR_COUNT + +#endif // __MIPS_CPU_H__ Index: v2_0/misc/fmt_util.h =================================================================== --- v2_0/misc/fmt_util.h (nonexistent) +++ v2_0/misc/fmt_util.h (revision 1765) @@ -0,0 +1,65 @@ +#ifndef __FMT_UTIL_H__ +#define __FMT_UTIL_H__ +//========================================================================== +// +// fmt_util.g +// +// Interface to generic string parsing and formatting utilities. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +/* Interface to generic string parsing and formatting utilities. + + It is posible that these services need to be defined in + a platform dependent way. These will work for the majority of + processors. */ + +extern int str2addr (char *string, mem_addr_t *res); +extern void addr2str (mem_addr_t *addr, char *dest); + +#endif // __FMT_UTIL_H__ Index: v2_0/misc/tservice.h =================================================================== --- v2_0/misc/tservice.h (nonexistent) +++ v2_0/misc/tservice.h (revision 1765) @@ -0,0 +1,84 @@ +#ifndef __TSERVICE_H__ +#define __TSERVICE_H__ +//========================================================================== +// +// tservice.h +// +// These are the core functions are expected to be provided by the +// target dependent services. +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +/* These are the core functions are expected to be provided by the + target dependent services. They are used by both cygmon and by + libstub +*/ + + +extern int read_memory (mem_addr_t *src, int size, int amt, char *dst); + +extern int write_memory (mem_addr_t *dst, int size, int amt, char *src); + + +#ifndef USE_ECOS_HAL_BREAKPOINTS +extern void set_breakpoint (struct bp *bp); +extern void clear_breakpoint (struct bp *bp); +#endif // USE_ECOS_HAL_BREAKPOINTS + +#ifndef HAVE_BSP +extern void set_pc (target_register_t pc); +#endif + +extern target_register_t next_step_pc (void); + +extern void enable_interrupts (void); + +#endif // __TSERVICE_H__ + + +extern void initialize_mon(void); Index: v2_0/misc/board.h =================================================================== --- v2_0/misc/board.h (nonexistent) +++ v2_0/misc/board.h (revision 1765) @@ -0,0 +1,72 @@ +#ifndef __CYGMON_BOARD_H__ +#define __CYGMON_BOARD_H__ +//========================================================================== +// +// board.h +// +// Cygmon board/platform configuration file +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= +// Hardware/platform/configuration specifics + +#include +#include + +#ifdef CYGPKG_HAL_ARM +#include "arm/board.h" +#endif + +#ifdef CYGPKG_HAL_MIPS +#include "mips/board.h" +#endif + +#ifdef CYGPKG_HAL_MN10300 +#include "mn10300/board.h" +#endif + +#endif // __CYGMON_BOARD_H__ Index: v2_0/misc/generic-stub.h =================================================================== --- v2_0/misc/generic-stub.h (nonexistent) +++ v2_0/misc/generic-stub.h (revision 1765) @@ -0,0 +1,54 @@ +//========================================================================== +// +// generic-stub.h +// +// +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas +// Date: 1999-10-20 +// Purpose: +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +// Placeholder Index: v2_0/misc/monitor.h =================================================================== --- v2_0/misc/monitor.h (nonexistent) +++ v2_0/misc/monitor.h (revision 1765) @@ -0,0 +1,303 @@ +//========================================================================== +// +// monitor.h +// +// Main definitions for the CygMON ROM monitor +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): +// Contributors: gthomas, dmoseley +// Date: 1999-10-20 +// Purpose: Main definitions for the CygMON ROM monitor +// Description: +// +// +//####DESCRIPTIONEND#### +// +//========================================================================= + +#ifndef MONITOR_H +#define MONITOR_H + +#if !defined(__ASSEMBLER__) +#include +#endif + +#include +#ifdef HAVE_BSP +#include "cpu_info.h" +#endif +#include + +#ifdef __ECOS__ +#include +#endif + +#ifndef ASM + +#ifdef HAVE_BSP +#define xprintf bsp_dprintf +#define xsprintf bsp_sprintf +#define xvprintf bsp_dvprintf +#define xputchar bsp_debug_putc +#define xgetchar bsp_debug_getc +#define xungetchar bsp_debug_ungetc +#define __getTty() bsp_set_debug_comm(-1) +#define set_pc(x) bsp_set_pc((x), mon_saved_regs) + +#ifndef USE_ECOS_HAL_SINGLESTEP +#define __single_step() bsp_singlestep_setup(mon_saved_regs) +#define __clear_single_step() bsp_singlestep_cleanup(mon_saved_regs) +#endif /* USE_ECOS_HAL_SINGLESTEP */ + +#ifndef USE_ECOS_HAL_BREAKPOINTS +#define breakpoint() bsp_breakpoint() +#endif /* USE_ECOS_HAL_BREAKPOINTS */ + +#if defined(__ECOS__) && defined(CYGHWR_HAL_RESET_DEFINED) + extern void __reset(void); +#else // defined(__ECOS__) && defined(CYGHWR_HAL_RESET_DEFINED) +# define __reset bsp_reset +#endif // defined(__ECOS__) && defined(CYGHWR_HAL_RESET_DEFINED) + +#else +extern void xprintf(const char *fmt, ...); +extern void xsprintf(char *str, const char *fmt, ...); +extern void xvprintf(const char *fmt, va_list ap); + +#ifdef HAS_USER_IO +#define xputchar putUserChar +#define xgetchar getUserChar +#else +extern void putDebugChar(int ch); +extern int getDebugChar(void); +#define xputchar putDebugChar +#define xgetchar getDebugChar +#endif +#define xungetchar ungetDebugChar +#endif + + +#ifndef USE_ECOS_HAL_BREAKPOINTS +struct bp { + mem_addr_t address; + bp_inst_t old_inst; + char in_memory; + struct bp *next; +}; +#endif // USE_ECOS_HAL_BREAKPOINTS + +struct regstruct +{ + char *registername; + int registernumber; +#ifdef HAVE_BSP +#if defined(CYGPKG_HAL_ARM) || !defined(__ECOS__) + int registertype; +#endif // defined(CYGPKG_HAL_ARM) || !defined(__ECOS__) +#endif +#ifdef REG_VALID_FIELD_IN_REGSTRUCT + int registervalid; +#endif +}; + + + +#ifdef HAVE_BSP +#define REGTYPE_INT 1 +#define REGTYPE_FLOAT 2 +#define REGTYPE_DOUBLE 3 + +union target_reg +{ + unsigned long i; /* integer register (32/64 bit) */ +#if HAVE_FLOAT_REGS + float f; /* float register (32bit) */ +#endif +#if HAVE_DOUBLE_REGS + double d; /* double register (64bit) */ +#endif +}; + +typedef union target_reg target_regval_t; + + +/* This is a template for what should be defined in the board specific + header file composed, board.h */ +#if ! defined(MEM_ADDR_DEFINED) +#define MEM_ADDR_DEFINED 1 +typedef struct mem_addr { + unsigned long addr; +} mem_addr_t; +#endif + +#if !defined(BP_INST_T_DEFINED) +#define BP_INST_T_DEFINED 1 +typedef unsigned char bp_inst_t ; +#endif + +#if ! defined(MAKE_STD_ADDR) +#define MAKE_STD_ADDR(SRC, DST) ((DST)->addr = (SRC)) +#endif + + +#if ! defined(ADD_OFFSET) +#define ADD_OFFSET(SRC,DST,OFFSET) ((DST)->addr = (SRC)->addr + (OFFSET)) +#endif + +#if ! defined(ADD_ALIGN) +#define ADD_ALIGN(SRC,DST,ALIGN) \ + ((DST)->addr = (SRC)->addr - ((SRC)->addr % (ALIGN))) +#endif + +#if ! defined(MEM_ADDR_EQ_P) +#define MEM_ADDR_EQ_P(A, B) ((A).addr == (B).addr) +#endif + +#if ! defined(MEM_ADDR_DIFF) +#define MEM_ADDR_DIFF(A, B) ((A).addr - (B).addr) +#endif + +#if ! defined(MEM_ADDR_ASI) +#define MEM_ADDR_ASI(A) -1 +#endif + +#endif /* HAVE_BSP */ + +#if defined(NO_MALLOC) && ! defined(MAX_NUM_BP) +#define MAX_NUM_BP 64 +#endif + +extern struct regstruct regtab[]; + +extern char **argvect; + +#ifdef HAVE_BSP +#define VERSION "release 2.0" +#else +#define VERSION "release 1.2" +#endif + +#define MAXLINELEN 80 +#define PROMPT "cygmon> " +#if ! defined MAX_HIST_ENTS +#define MAX_HIST_ENTS 10 +#endif + +/* + * From monitor.c + */ +extern mem_addr_t last_pc; +extern int stub_is_active; +#ifdef HAVE_BSP +extern void *mon_saved_regs; +#else +extern int (*user_signal_handler)(int); +#endif + +extern void clear_user_state (void); +extern int transfer_to_stub (void); +extern void version (void); +#ifdef MONITOR_CONTROL_INTERRUPTS +/* Enable interrupts within the monitor. */ +extern void monitor_enable_interrupts (void); + +/* Disable interrupts within the monitor. */ +extern void monitor_disable_interrupts (void); + +/* Returns 1 if interrupts have been enabled within the monitor, 0 + otherwise. */ +extern int monitor_interrupt_state (void); +#endif /* MONITOR_CONTROL_INTERRUPTS */ + + +/* + * From utils.c + */ +extern int switch_to_stub_flag; +extern int input_char (void); +extern target_register_t str2int (char *str, int base); +#if HAVE_DOUBLE_REGS +extern double str2double (char *str, int base); +#endif +extern target_register_t str2intlen (char *str, int base, int len); +extern int hex2bytes(char *string, char *dest, int maxsize); +extern char *int2str (target_register_t number, int base, int numdigs); +#ifndef NO_MALLOC +extern char *strdup(const char *str); +#endif +extern target_register_t get_pc(void); +extern char *get_register_str (regnames_t which, int detail, int valid); +extern void store_register (regnames_t which, char *string); + +#ifndef USE_ECOS_HAL_BREAKPOINTS +/* + * From breakpoints.c + */ +extern int add_mon_breakpoint (mem_addr_t location); +extern void install_breakpoints (void); +extern void clear_breakpoints (void); +extern int show_breakpoints (void); +extern int clear_mon_breakpoint (mem_addr_t location); +#endif /* USE_ECOS_HAL_BREAKPOINTS */ + + +/* + * From do-dis.c + */ +extern mem_addr_t do_dis (mem_addr_t *addr); +extern void flush_dis (void); + + +/* + * From architecture-mon.c + */ +#ifdef HAVE_BSP +extern void initialize_mon(void); +extern target_register_t get_register(regnames_t reg); +extern void put_register (regnames_t which, target_register_t value); +#endif + + +/* Lame. */ +#ifndef ITIMER_REAL +#define ITIMER_REAL 0 +#endif + +#endif /* ASM */ +#endif Index: v2_0/misc/ecos_bsp.c =================================================================== --- v2_0/misc/ecos_bsp.c (nonexistent) +++ v2_0/misc/ecos_bsp.c (revision 1765) @@ -0,0 +1,470 @@ +//========================================================================== +// +// ecos_bsp.c +// +// eCos BSP (for building Cygmon) +// +//========================================================================== +//####ECOSGPLCOPYRIGHTBEGIN#### +// ------------------------------------------- +// This file is part of eCos, the Embedded Configurable Operating System. +// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc. +// +// eCos is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 2 or (at your option) any later version. +// +// eCos is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with eCos; if not, write to the Free Software Foundation, Inc., +// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. +// +// As a special exception, if other files instantiate templates or use macros +// or inline functions from this file, or you compile this file and link it +// with other works to produce a work based on this file, this file does not +// by itself cause the resulting work to be covered by the GNU General Public +// License. However the source code for this file must still be made available +// in accordance with section (3) of the GNU General Public License. +// +// This exception does not invalidate any other reasons why a work based on +// this file might be covered by the GNU General Public License. +// +// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc. +// at http://sources.redhat.com/ecos/ecos-license/ +// ------------------------------------------- +//####ECOSGPLCOPYRIGHTEND#### +//========================================================================== +//#####DESCRIPTIONBEGIN#### +// +// Author(s): gthomas +// Contributors: gthomas, dmoseley +// Date: 1999-10-11 +// Description: Wrapper functions which provide BSP environment for Cygmon +//####DESCRIPTIONEND#### + +#ifdef CYGPKG_KERNEL +#include // Configuration headers +#endif +#include +#include + +#include +#include +#ifdef CYGPKG_KERNEL +#include +#else +#include +#include +#endif +#include +#include "bsp/common/bsp_if.h" +#include +#include +#include CYGHWR_MEMORY_LAYOUT_H + +#include +#ifdef CYGPKG_IO +#include +#include +#endif + +#define STACK_SIZE CYGNUM_HAL_STACK_SIZE_MINIMUM +static char stack[STACK_SIZE]; +#ifdef CYGPKG_KERNEL +static cyg_thread thread_data; +static cyg_handle_t thread_handle; +#endif + +char *build_date = __DATE__; + +extern void monitor_main(int, char *); +extern int stub_is_active; + +void ecos_bsp_set_memsize(unsigned long size); + +void +cygmon_main(void) +{ + _bsp_init(); + monitor_main(0, 0); // Null argument list +} + +extern unsigned long cygmon_memsize; + +externC void +cyg_start( void ) +{ + // Fill in the BSP memory info + if (cygmon_memsize != 0) + ecos_bsp_set_memsize(cygmon_memsize); + +#ifdef CYGPKG_KERNEL + // Create a main thread, so we can run the scheduler and have time 'pass' + cyg_thread_create(10, // Priority - just a number + (cyg_thread_entry_t*)cygmon_main, // entry + 0, // entry parameter + "Cygmon", // Name + &stack[0], // Stack + STACK_SIZE, // Size + &thread_handle, // Handle + &thread_data // Thread data structure + ); + cyg_thread_resume(thread_handle); // Start it + cyg_scheduler_start(); +#else +#ifdef HAL_ARCH_FUNCALL_NEW_STACK + HAL_ARCH_FUNCALL_NEW_STACK(cygmon_main, &stack[0], STACK_SIZE); +#else + #error Need to define HAL_ARCH_FUNCALL_NEW_STACK +#endif +#endif +} // cyg_package_start() + +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS +extern void *_hal_registers; // Used by eCos GDB stubs +extern void (*__init_vec)(void); +extern void (*__cleanup_vec)(void); +extern void __install_traps(void); +#endif + +extern int machine_syscall(HAL_SavedRegisters *regs); +void +_bsp_handle_exception(cyg_addrword_t data, cyg_code_t num, cyg_addrword_t info) +{ + if (num == CYGNUM_HAL_EXCEPTION_INTERRUPT) { + if (machine_syscall((HAL_SavedRegisters*)info)) { + return; + } + // Fall through to "normal" exception handling if system call failed + } +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS + _hal_registers = (void *)info; // Used by eCos GDB stubs + __cleanup_vec(); +#endif + bsp_invoke_dbg_handler(num, (void *)info); +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS + __init_vec(); +#endif +} + +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS +extern void __handle_exception(void); +#else + +int +unhandled_exception(int num, void *args) +{ + diag_printf("Unhandled exception: %d/%x\n", num, args); + while (1) ; +} +#endif + +void +_bsp_cpu_init(void) +{ +#ifdef CYGPKG_KERNEL + int d0; + cyg_exception_set_handler(CYGNUM_HAL_EXCEPTION_ILLEGAL_INSTRUCTION, + _bsp_handle_exception, + (cyg_addrword_t)&d0, + 0, + 0); +#endif +#ifdef CYGDBG_HAL_DEBUG_GDB_INCLUDE_STUBS + bsp_install_dbg_handler((bsp_handler_t)__handle_exception); + __install_traps(); +#else + bsp_install_dbg_handler(unhandled_exception); +#endif +} + +#define FAIL() diag_printf("fail: %s\n", __FUNCTION__); while (1) ; + +#ifndef CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT + +struct BSP_IO { + char *name; + cyg_io_handle_t chan; +}; + +static void +uart_putchar(void *base, char c) +{ + char buf; + int len; + struct BSP_IO *io = (struct BSP_IO *)base; + if (io->chan) { + len = 1; + buf = c; + cyg_io_write(io->chan, &buf, &len); + } +} + +extern int __output_gdb_string (const char *str, int string_len); + +// This function is mostly used by the 'write()' system call +static void +uart_write(void *base, const char *buf, int len) +{ + struct BSP_IO *io = (struct BSP_IO *)base; + if (io->chan) { + if (stub_is_active) { + // We are running in 'GDB' mode + __output_gdb_string(buf, len); + } else { + cyg_io_write(io->chan, buf, &len); + } + } +} + +static int +uart_read(void *base, char *buf, int len) +{ + struct BSP_IO *io = (struct BSP_IO *)base; + if (io->chan) { + cyg_io_read(io->chan, buf, &len); + return len; + } + return 0; +} + +static int +uart_getchar(void *base) +{ + char buf = '\0'; + int len; + struct BSP_IO *io = (struct BSP_IO *)base; + if (io->chan) { + len = 1; + cyg_io_read(io->chan, &buf, &len); + } + return buf; +} + +static int +uart_control(void *base, int func, ...) +{ + int rc = 0; + va_list ap; + int arg; + struct BSP_IO *io = (struct BSP_IO *)base; + + va_start(ap, func); + + if (func == COMMCTL_SETBAUD) + { + cyg_serial_info_t buffer = { + CYG_SERIAL_BAUD_DEFAULT, + CYG_SERIAL_STOP_DEFAULT, + CYG_SERIAL_PARITY_DEFAULT, + CYG_SERIAL_WORD_LENGTH_DEFAULT, + CYG_SERIAL_FLAGS_DEFAULT + }; + int len = sizeof(buffer); + arg = va_arg(ap, int); + + switch (arg) + { + case 50: buffer.baud = CYG_SERIAL_BAUD_RATE(50); break; + case 75: buffer.baud = CYG_SERIAL_BAUD_RATE(75); break; + case 110: buffer.baud = CYG_SERIAL_BAUD_RATE(110); break; + case 134: buffer.baud = CYG_SERIAL_BAUD_RATE(134_5); break; + case 135: buffer.baud = CYG_SERIAL_BAUD_RATE(134_5); break; + case 150: buffer.baud = CYG_SERIAL_BAUD_RATE(150); break; + case 200: buffer.baud = CYG_SERIAL_BAUD_RATE(200); break; + case 300: buffer.baud = CYG_SERIAL_BAUD_RATE(300); break; + case 600: buffer.baud = CYG_SERIAL_BAUD_RATE(600); break; + case 1200: buffer.baud = CYG_SERIAL_BAUD_RATE(1200); break; + case 1800: buffer.baud = CYG_SERIAL_BAUD_RATE(1800); break; + case 2400: buffer.baud = CYG_SERIAL_BAUD_RATE(2400); break; + case 3600: buffer.baud = CYG_SERIAL_BAUD_RATE(3600); break; + case 4800: buffer.baud = CYG_SERIAL_BAUD_RATE(4800); break; + case 7200: buffer.baud = CYG_SERIAL_BAUD_RATE(7200); break; + case 9600: buffer.baud = CYG_SERIAL_BAUD_RATE(9600); break; + case 14400: buffer.baud = CYG_SERIAL_BAUD_RATE(14400); break; + case 19200: buffer.baud = CYG_SERIAL_BAUD_RATE(19200); break; + case 38400: buffer.baud = CYG_SERIAL_BAUD_RATE(38400); break; + case 57600: buffer.baud = CYG_SERIAL_BAUD_RATE(57600); break; + case 115200: buffer.baud = CYG_SERIAL_BAUD_RATE(115200); break; + case 230400: buffer.baud = CYG_SERIAL_BAUD_RATE(230400); break; + default: buffer.baud = -1; rc = -1; break; + } + + if ((io->chan) && (buffer.baud != -1)) { + rc = cyg_io_set_config(io->chan, CYG_IO_SET_CONFIG_SERIAL_INFO, &buffer, &len); + } + } + + va_end(ap); + return rc; +} + +/* + * Setup the bsp_comm_channel data structure + */ +struct BSP_IO bsp_comm_io[] = { + {CYGDAT_CYGMON_CONSOLE_DEV, 0}, // Console device +}; + +struct bsp_comm_channel _bsp_comm_list[] = +{ + { + { "UART 0", + BSP_COMM_SERIAL, + BSP_PROTO_NONE }, + { (void*)&bsp_comm_io[0], + uart_write, + uart_read, + uart_putchar, + uart_getchar, + uart_control } + }, +}; +int _bsp_num_comms = sizeof(_bsp_comm_list)/sizeof(_bsp_comm_list[0]); + +void +_bsp_init_board_comm(void) +{ + int i; + for (i = 0; i < _bsp_num_comms; i++) { + Cyg_ErrNo err; + struct BSP_IO *io; + io = (struct BSP_IO *)_bsp_comm_list[i].procs.ch_data; + if ((err = cyg_io_lookup(io->name, &io->chan)) != ENOERR) { + diag_printf("Can't open '%s'\n", io->name); + } + } +} + +#else // CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT + +struct bsp_comm_channel _bsp_comm_list[1]; +int _bsp_num_comms = 1; + +// Yuck! Two things need doing: + +// FIXME: Make bsp code use pointers in the bsp_comm_channel instead +// of sub-structures. + +// FIXME: Make HAL provide the bsp_comm_info structure - I missed that +// initially because it cannot be accessed via the virtual table API. +void +_bsp_init_board_comm(void) +{ + struct bsp_comm_channel* channel; + hal_virtual_comm_table_t* comm; + + channel = &_bsp_comm_list[0]; + channel->info.name = "fixme"; + channel->info.kind = BSP_COMM_SERIAL; + channel->info.protocol = BSP_PROTO_NONE; + + comm = CYGACC_CALL_IF_DEBUG_PROCS(); + channel->procs = *(struct bsp_comm_procs*)comm; +} +#endif // CYGSEM_HAL_VIRTUAL_VECTOR_SUPPORT + +/* + * Array of memory region descriptors. We just list RAM. + */ +#ifdef CYGMEM_REGION_ram +#define RAM_VIRTUAL_BASE CYGMEM_REGION_ram +#define RAM_TOTAL_SIZE CYGMEM_REGION_ram_SIZE +#else +#define RAM_VIRTUAL_BASE 0x00008000 +#define RAM_TOTAL_SIZE 0x00FF8000 +#endif + +struct bsp_mem_info _bsp_memory_list[] = +{ + { (void *)RAM_VIRTUAL_BASE, + (void *)RAM_VIRTUAL_BASE, + 0, + RAM_TOTAL_SIZE, + BSP_MEM_RAM + }, +}; + +/* + * Number of memory region descriptors. + */ +int _bsp_num_mem_regions = sizeof(_bsp_memory_list)/sizeof(_bsp_memory_list[0]); + +void +_bsp_install_cpu_irq_controllers(void) +{ +} + +void +_bsp_install_board_irq_controllers(void) +{ +} + +void +__init_irq_controllers(void) +{ +} + +void +_bsp_board_init(void) +{ + /* + * Define platform info. + */ +#ifdef HAL_PLATFORM_CPU + _bsp_platform_info.cpu = HAL_PLATFORM_CPU; +#else + _bsp_platform_info.cpu = "Unknown CPU"; +#endif +#ifdef HAL_PLATFORM_BOARD + _bsp_platform_info.board = HAL_PLATFORM_BOARD; +#else + _bsp_platform_info.board = "Unknown board"; +#endif +#ifdef HAL_PLATFORM_EXTRA + _bsp_platform_info.extra = HAL_PLATFORM_EXTRA; +#else + _bsp_platform_info.extra = ""; +#endif +} + +extern char *strchr(char *, char); +char * +index(char *string, char key) +{ + return strchr(string, key); +} + +void +flush_i_cache(void) +{ + HAL_ICACHE_SYNC(); +} + +void +ecos_bsp_console_putc(char c) +{ + if (bsp_shared_data) { + bsp_console_putc(c); + } +} + +char +ecos_bsp_console_getc(void) +{ + if (bsp_shared_data) { + return bsp_console_getc(); + } else { + return '?'; + } +} + +void +ecos_bsp_set_memsize(unsigned long size) +{ + _bsp_memory_list[0].nbytes = size; +}

Browse

Tools

Subversion Repositories or1k

Compare Revisions

Rev 1254 → Rev 1765