Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 2263 → Rev 2264

/branches/arm/kernel/arch/arm32/include/debug_print/print.h
0,0 → 1,50
/*
* Copyright (c) 2006 Martin Decky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
#ifndef KERN_arm32_DEBUG_PRINT_PRINTF_H_
#define KERN_arm32_DEBUG_PRINT_PRINTF_H_
 
#define INT8 1
#define INT16 2
#define INT32 4
#define INT64 8
 
extern void debug_puts(const char *str);
extern void debug_printf(const char *fmt, ...);
extern void debug_write(const char *str, const int len);
 
 
#ifdef CONFIG_DEBUG
# define dprintf(arg1...) debug_printf(arg1)
# define dputs(arg1) debug_puts(arg1)
#else
# define dprintf(arg1...)
# define dputs(arg1)
#endif
 
#endif
/branches/arm/kernel/arch/arm32/include/drivers/gxemul.h
69,6 → 69,7
void gxemul_timer_start(uint32_t frequency);
 
size_t gxemul_get_memory_size(void);
void gxemul_debug_putc(char ch);
 
 
/branches/arm/kernel/arch/arm32/Makefile.inc
81,8 → 81,8
arch/$(ARCH)/src/mm/page.c \
arch/$(ARCH)/src/interrupt.c \
arch/$(ARCH)/src/mm/tlb.c \
arch/$(ARCH)/src/aux_print/printf.c \
arch/$(ARCH)/src/aux_print/io.c \
arch/$(ARCH)/src/debug_print/printf.c \
arch/$(ARCH)/src/debug_print/io.c \
arch/$(ARCH)/src/console.c \
arch/$(ARCH)/src/drivers/gxemul.c \
arch/$(ARCH)/src/drivers/init.c \
/branches/arm/kernel/arch/arm32/src/aux_print/printf.c
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/gentypes.h
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/io.c
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/printf.h
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/types.h
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/stdarg.h
File deleted
/branches/arm/kernel/arch/arm32/src/aux_print/README
File deleted
/branches/arm/kernel/arch/arm32/src/exception.c
34,7 → 34,7
*/
 
#include <arch/exception.h>
#include "aux_print/printf.h"
#include <arch/debug_print/print.h>
#include <arch/memstr.h>
#include <arch/regutils.h>
#include <interrupt.h>
160,7 → 160,7
spinlock_unlock(&irq->lock);
} else {
/* Spurious interrupt.*/
aux_printf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, i);
dprintf("cpu%d: spurious interrupt (inum=%d)\n", CPU->id, i);
}
}
}
173,12 → 173,12
aux_puts("?");
}
else {
aux_printf("%c", readchar);
dprintf("%c", readchar);
}
}
else if (i == TIMER_IRQ) {
aux_printf("\n.\n");
dprintf("\n.\n");
//acknowledge
*(uint32_t*)0x15000110 = 0;
}
/branches/arm/kernel/arch/arm32/src/debug_print/printf.c
0,0 → 1,243
/*
* Copyright (c) 2006 Martin Decky
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
#include <arch/debug_print/print.h>
#include <stdarg.h>
#include <arch/types.h>
 
typedef char *char_ptr;
 
static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
 
void debug_puts(const char *str)
{
int len = 0;
while (str[len] != 0)
len++;
debug_write(str, len);
}
 
 
/** Print hexadecimal digits
*
* Print fixed count of hexadecimal digits from
* the number num. The digits are printed in
* natural left-to-right order starting with
* the width-th digit.
*
* @param num Number containing digits.
* @param width Count of digits to print.
*
*/
static void print_fixed_hex(const uint64_t num, const int width)
{
int i;
for (i = width * 8 - 4; i >= 0; i -= 4)
debug_write(digits + ((num >> i) & 0xf), 1);
}
 
 
/** Print number in given base
*
* Print significant digits of a number in given
* base.
*
* @param num Number to print.
* @param base Base to print the number in (should
* be in range 2 .. 16).
*
*/
static void print_number(const unative_t num, const unsigned int base)
{
int val = num;
char d[sizeof(unative_t) * 8 + 1]; /* this is good enough even for base == 2 */
int i = sizeof(unative_t) * 8 - 1;
do {
d[i--] = digits[val % base];
} while (val /= base);
d[sizeof(unative_t) * 8] = 0;
debug_puts(&d[i + 1]);
}
 
 
/** General formatted text print
*
* Print text formatted according the fmt parameter
* and variant arguments. Each formatting directive
* begins with \% (percentage) character and one of the
* following character:
*
* \% Prints the percentage character.
*
* s The next variant argument is treated as char*
* and printed as a NULL terminated string.
*
* c The next variant argument is treated as a single char.
*
* p The next variant argument is treated as a maximum
* bit-width integer with respect to architecture
* and printed in full hexadecimal width.
*
* P As with 'p', but '0x' is prefixed.
*
* q The next variant argument is treated as a 64b integer
* and printed in full hexadecimal width.
*
* Q As with 'q', but '0x' is prefixed.
*
* l The next variant argument is treated as a 32b integer
* and printed in full hexadecimal width.
*
* L As with 'l', but '0x' is prefixed.
*
* w The next variant argument is treated as a 16b integer
* and printed in full hexadecimal width.
*
* W As with 'w', but '0x' is prefixed.
*
* b The next variant argument is treated as a 8b integer
* and printed in full hexadecimal width.
*
* B As with 'b', but '0x' is prefixed.
*
* d The next variant argument is treated as integer
* and printed in standard decimal format (only significant
* digits).
*
* x The next variant argument is treated as integer
* and printed in standard hexadecimal format (only significant
* digits).
*
* X As with 'x', but '0x' is prefixed.
*
* All other characters from fmt except the formatting directives
* are printed in verbatim.
*
* @param fmt Formatting NULL terminated string.
*/
void debug_printf(const char *fmt, ...)
{
int i = 0;
va_list ap;
char c;
va_start(ap, fmt);
while ((c = fmt[i++])) {
switch (c) {
/* control character */
case '%':
switch (c = fmt[i++]) {
/* percentile itself */
case '%':
break;
/*
* String and character conversions.
*/
case 's':
debug_puts(va_arg(ap, char_ptr));
goto loop;
case 'c':
c = (char) va_arg(ap, int);
break;
/*
* Hexadecimal conversions with fixed width.
*/
case 'P':
debug_puts("0x");
case 'p':
print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t));
goto loop;
case 'Q':
debug_puts("0x");
case 'q':
print_fixed_hex(va_arg(ap, uint64_t), INT64);
goto loop;
case 'L':
debug_puts("0x");
case 'l':
print_fixed_hex(va_arg(ap, unative_t), INT32);
goto loop;
case 'W':
debug_puts("0x");
case 'w':
print_fixed_hex(va_arg(ap, unative_t), INT16);
goto loop;
case 'B':
debug_puts("0x");
case 'b':
print_fixed_hex(va_arg(ap, unative_t), INT8);
goto loop;
/*
* Decimal and hexadecimal conversions.
*/
case 'd':
print_number(va_arg(ap, unative_t), 10);
goto loop;
case 'X':
debug_puts("0x");
case 'x':
print_number(va_arg(ap, unative_t), 16);
goto loop;
/*
* Bad formatting.
*/
default:
goto out;
}
default:
debug_write(&c, 1);
}
loop:
;
}
out:
va_end(ap);
}
/branches/arm/kernel/arch/arm32/src/debug_print/io.c
0,0 → 1,50
/*
* Copyright (c) 2007 Michal Kebrt
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
 
 
#include <arch/debug_print/print.h>
#include <arch/drivers/gxemul.h>
 
/**
* Prints a character to console.
*
* @param ch character to be printed
*/
static void putc(char ch) {
#if MACHINE == MACHINE_GXEMUL_TESTARM
gxemul_debug_putc(ch);
#endif
}
 
void debug_write(const char *str, const int len) {
int i;
for (i = 0; i < len; ++i) {
putc(str[i]);
}
}
 
/branches/arm/kernel/arch/arm32/src/arm32.c
42,7 → 42,7
#include <genarch/fb/visuals.h>
#include <ddi/irq.h>
 
#include "aux_print/printf.h"
#include <arch/debug_print/print.h>
#include <print.h>
#include <config.h>
#include <interrupt.h>
52,7 → 52,7
 
void arch_pre_main(void)
{
aux_printf("arch_pre_main\n");
dprintf("arch_pre_main\n");
int i;
 
init.cnt = bootinfo.cnt;
68,7 → 68,7
 
void arch_pre_mm_init(void)
{
aux_printf("arch_pre_mm_init\n");
dprintf("arch_pre_mm_init\n");
 
/* It is not assumed by default */
interrupts_disable();
79,7 → 79,7
 
void arch_post_mm_init(void)
{
aux_printf("arch_post_mm_init start()\n");
dprintf("arch_post_mm_init start()\n");
drivers_init();
interrupt_init();
87,9 → 87,8
//fb_init(0x12000000, 640, 480, 1920, VISUAL_RGB_8_8_8);
interrupts_enable();
// while(1);
aux_printf("machine:\n", MACHINE );
aux_printf("arch_post_mm_init end()\n");
while(1);
dprintf("arch_post_mm_init end()\n");
}
 
void arch_post_cpu_init(void)
/branches/arm/kernel/arch/arm32/src/mm/frame.c
35,7 → 35,6
#include <mm/frame.h>
#include <arch/mm/frame.h>
#include <config.h>
#include "../aux_print/printf.h"
 
uintptr_t last_frame = 0;
 
/branches/arm/kernel/arch/arm32/src/mm/page.c
42,11 → 42,9
#include <typedefs.h>
#include <arch/types.h>
#include <interrupt.h>
#include <arch/debug_print/print.h>
 
//TODO: remove in final version
#include "../aux_print/printf.h"
 
 
// localy used types
/**
* Decribes structure of fault status register in coprocessor 15
155,11 → 153,11
//TODO: remove in final version
static void print_istate(istate_t* istate);
static void print_istate(istate_t* istate) {
aux_printf("\nIstate dump:\n");
aux_printf(" r0:%X r1:%X r2:%X r3:%X\n", istate->r0, istate->r1, istate->r2, istate->r3);
aux_printf(" r4:%X r5:%X r6:%X r7:%X\n", istate->r4, istate->r5, istate->r6, istate->r7);
aux_printf(" r8:%X r8:%X r10:%X r11:%X\n", istate->r8, istate->r9, istate->r10, istate->r11);
aux_printf(" r12:%X sp:%X lr:%X spsr:%X\n", istate->r12, istate->sp, istate->lr, istate->spsr);
dprintf("\nIstate dump:\n");
dprintf(" r0:%X r1:%X r2:%X r3:%X\n", istate->r0, istate->r1, istate->r2, istate->r3);
dprintf(" r4:%X r5:%X r6:%X r7:%X\n", istate->r4, istate->r5, istate->r6, istate->r7);
dprintf(" r8:%X r8:%X r10:%X r11:%X\n", istate->r8, istate->r9, istate->r10, istate->r11);
dprintf(" r12:%X sp:%X lr:%X spsr:%X\n", istate->r12, istate->sp, istate->lr, istate->spsr);
}
 
/**
202,16 → 200,16
// get instruction op code
instruction_t i_code = *(tmp.instr);
 
aux_printf("get_instruction_memmory_access\n");
aux_printf(" i_code:%X\n",i_code);
aux_printf(" i_code.condition:%d\n", i_code.condition);
aux_printf(" i_code.instr_type:%d\n",i_code.instr_type);
aux_printf(" i_code.opcode:%d\n",i_code.opcode);
aux_printf(" i_code.acess:%d\n", i_code.access);
aux_printf(" i_code.dummy:%d\n", i_code.dummy);
aux_printf(" i_code.bits567%d\n", i_code.bits567);
aux_printf(" i_code.bit4:%d\n", i_code.bit4);
aux_printf(" i_code.dummy1:%d\n", i_code.dummy1);
dprintf("get_instruction_memmory_access\n");
dprintf(" i_code:%X\n",i_code);
dprintf(" i_code.condition:%d\n", i_code.condition);
dprintf(" i_code.instr_type:%d\n",i_code.instr_type);
dprintf(" i_code.opcode:%d\n",i_code.opcode);
dprintf(" i_code.acess:%d\n", i_code.access);
dprintf(" i_code.dummy:%d\n", i_code.dummy);
dprintf(" i_code.bits567%d\n", i_code.bits567);
dprintf(" i_code.bit4:%d\n", i_code.bit4);
dprintf(" i_code.dummy1:%d\n", i_code.dummy1);
 
 
// undefined instructions ... (or special instructions)
277,10 → 275,10
pf_access_t access = get_memmory_access_type( istate->lr, page);
 
print_istate(istate);
aux_printf(" page fault : ip:%X, va:%X, status:%x(%x), access:%d\n", istate->lr, page, fsr.status,fsr, access);
dprintf(" page fault : ip:%X, va:%X, status:%x(%x), access:%d\n", istate->lr, page, fsr.status,fsr, access);
 
int ret = as_page_fault(page, access, istate);
aux_printf(" as_page_fault ret:%d\n", ret);
dprintf(" as_page_fault ret:%d\n", ret);
if (ret == AS_PF_FAULT) {
fault_if_from_uspace(istate, "Page fault: %#x", page);
 
301,10 → 299,10
void prefetch_abourt(int n, istate_t *istate) {
// Prefetch can be made be bkpt instruction
print_istate(istate);
aux_printf(" prefetch_abourt ... instruction on adress:%x can't be fetched\n", istate->lr);
dprintf(" prefetch_abourt ... instruction on adress:%x can't be fetched\n", istate->lr);
 
int ret = as_page_fault(istate->lr, PF_ACCESS_EXEC, istate);
aux_printf(" as_page_fault ret:%d\n", ret);
dprintf(" as_page_fault ret:%d\n", ret);
if (ret == AS_PF_FAULT) {
panic("page fault - instruction fetch at addr:%X\n", istate->lr);
}
/branches/arm/kernel/arch/arm32/src/dummy.S
85,7 → 85,7
bkpt
panic_printf:
bl aux_printf
bl debug_printf
# stop gxemul
ldr r1, =0x10000010
eor r2, r2
/branches/arm/kernel/arch/arm32/src/drivers/gxemul.c
89,6 → 89,7
gxemul_hw_map.rtc_ack = gxemul_hw_map.rtc + GXEMUL_RTC_ACK_OFFSET;
gxemul_hw_map.irqc_mask = gxemul_hw_map.irqc + GXEMUL_IRQC_MASK_OFFSET;
gxemul_hw_map.irqc_unmask = gxemul_hw_map.irqc + GXEMUL_IRQC_UNMASK_OFFSET;
 
}
 
/** Putchar that works with gxemul */
284,5 → 285,9
return *((int*)(GXEMUL_MP + GXEMUL_MP_MEMSIZE_OFFSET));
}
 
void gxemul_debug_putc(char ch) {
*((volatile char *) GXEMUL_KBD) = ch;
}
 
/** @}
*/