int segm_fault ()
{
#if TEST == 1
printf ( "\nInterrupt test >>>\n" );
arch_register_interrupt_handler ( SOFTWARE_INTERRUPT, test1 );
arch_register_interrupt_handler ( SOFTWARE_INTERRUPT, test1 );
raise_interrupt ( SOFTWARE_INTERRUPT );
printf ( "Interrupt test <<<\n\n" );
#else
unsigned int *p;
unsigned int i, j=0;
printf ( "Example program: [%s:%s]\n%s\n\n", __FILE__, __FUNCTION__,
segm_fault_PROG_HELP );
printf ( "Before segmentation fault\n" );
for ( i = 16; i < 32; i++ )
{
p = (unsigned int *) (1 << i);
printf ( "[%x]=%d\n", p, *p );
j+= *p;
}
printf ( "After expected segmentation fault, j=%d\n", j );
#endif
return 0;
}
/*!
* First kernel function (after boot loader loads it to memory)
*/
void k_startup ()
{
extern console_t K_INITIAL_STDOUT, K_STDOUT;
extern console_t *k_stdout; /* console for kernel messages */
/* set initial stdout */
k_stdout = &K_INITIAL_STDOUT;
k_stdout->init (0);
/* initialize memory subsystem (needed for boot) */
k_memory_init ();
/*! start with regular initialization */
/* interrupts */
arch_init_interrupts ();
/* detect memory faults (qemu do not detect segment violations!) */
arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault );
arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault );
/* switch to default 'stdout' for kernel */
k_stdout = &K_STDOUT;
k_stdout->init (0);
kprintf ( "%s\n", system_info );
/* enable interrupts */
enable_interrupts ();
stdio_init (); /* initialize standard output devices */
/* start desired program(s) */
hello_world ();
segm_fault ();
#if ( TURN_OFF == 0 )
kprintf ( "\nSystem halted!\n" );
#ifdef PL190
/* testing uart (arm) interrupts */
void uart0_echo_test_start ();
uart0_echo_test_start ();
suspend();
#endif
halt ();
#else
/* power off (if supported, or just stop if not) */
kprintf ( "Powering off\n\n" );
power_off ();
#endif
}
static void test_interrupts ()
{
/* processor interrupts are usualy fatal - can't recover easy! */
arch_register_interrupt_handler ( 0, processor_irq_handler );
arch_register_interrupt_handler ( 5, processor_irq_handler );
arch_register_interrupt_handler ( 10, processor_irq_handler );
arch_register_interrupt_handler ( 15, processor_irq_handler );
/* interrupts generated outside processor */
arch_register_interrupt_handler ( 32, device_irq_handler );
arch_register_interrupt_handler ( 35, device_irq_handler );
arch_register_interrupt_handler ( 37, device_irq_handler );
arch_register_interrupt_handler ( 39, device_irq_handler );
/* irq number outside allowed range */
//arch_register_interrupt_handler ( 60, device_irq_handler );
/* raise a few interrupts (comment/uncomment for testing) */
//raise_interrupt ( 0 );
//raise_interrupt ( 1 );
//raise_interrupt ( 5 );
//raise_interrupt ( 7 );
//raise_interrupt ( 10 );
//raise_interrupt ( 20 );
raise_interrupt ( 32 );
raise_interrupt ( 35 );
raise_interrupt ( 38 );
}
/*!
* First kernel function (after boot loader loads it to memory)
*/
void k_startup ()
{
extern void *k_stdout; /* console for kernel messages */
/* set initial stdout */
kdevice_set_initial_stdout ();
/* initialize memory subsystem (needed for boot) */
k_memory_init ();
/*! start with regular initialization */
/* interrupts */
arch_init_interrupts ();
/* detect memory faults (qemu do not detect segment violations!) */
arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault, NULL );
arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault, NULL );
/* timer subsystem */
k_time_init ();
/* devices */
k_devices_init ();
/* switch to default 'stdout' for kernel */
k_stdout = k_device_open ( K_STDOUT, O_WRONLY );
kprintf ( "%s\n", system_info );
/* enable interrupts */
enable_interrupts ();
stdio_init (); /* initialize standard input & output devices */
/* start desired program(s) */
hello_world ();
keyboard ();
timer ();
/* segm_fault (); */
#if ( TURN_OFF == 0 )
kprintf ( "\nSystem halted!\n" );
halt ();
#else
/* power off (if supported, or just stop if not) */
kprintf ( "Powering off\n\n" );
power_off ();
#endif
}
/*!
* First kernel function (after boot loader loads it to memory)
*/
void k_startup ()
{
extern void *k_stdout; /* console for kernel messages */
extern prog_info_t pi;
/* set initial stdout */
kdevice_set_initial_stdout ();
/* initialize memory subsystem (needed for boot) */
k_memory_init ();
/*! start with regular initialization */
/* interrupts */
arch_init_interrupts ();
/* detect memory faults (qemu do not detect segment violations!) */
arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault, NULL );
arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault, NULL );
/* timer subsystem */
k_time_init ();
/* devices */
k_devices_init ();
/* switch to default 'stdout' for kernel */
k_stdout = k_device_open ( K_STDOUT, O_WRONLY );
kprintf ( "%s\n", system_info );
pi.heap = kmalloc ( PROG_HEAP_SIZE );
pi.heap_size = PROG_HEAP_SIZE;
/* enable interrupts */
enable_interrupts ();
/* starting program routine */
prog_init ( NULL );
#if ( TURN_OFF == 0 )
kprintf ( "\nSystem halted!\n" );
halt ();
#else
/* power off (if supported, or just stop if not) */
kprintf ( "Powering off\n\n" );
power_off ();
#endif
}
/*! Initialize device (and call its initializer, if set) */
int k_device_init ( kdevice_t *kdev, int flags, void *params, void *callback )
{
int retval = 0;
ASSERT ( kdev );
if ( flags )
kdev->dev.flags = flags;
if ( params )
kdev->dev.params = params;
if ( kdev->dev.init )
retval = kdev->dev.init ( flags, params, &kdev->dev );
if ( !retval && kdev->dev.irq_handler )
{
(void) arch_register_interrupt_handler ( kdev->dev.irq_num,
kdev->dev.irq_handler,
&kdev->dev );
arch_irq_enable ( kdev->dev.irq_num );
}
if ( callback )
kdev->dev.callback = callback;
return retval;
}
/*! Init console with interrupt enable */
void uart0_echo_test_start ()
{
volatile unsigned int *uart_imsc = (unsigned int *) UART0_IMSC;
/* enable RXIM interrupt (interrupt on data receive) */
*uart_imsc = 1 << 4;
/* register UART interrupt */
arch_register_interrupt_handler ( IRQ_OFFSET + UART0IRQL, uart_echo,
NULL );
/* enable UART interrupt in VIC */
arch_irq_enable ( IRQ_OFFSET + UART0IRQL );
}
