Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4633 → Rev 4634

/branches/arm/kernel/generic/src/main/version.c
36,7 → 36,7
#include <print.h>
 
char *project = "SPARTAN kernel";
char *copyright = "Copyright (c) 2001-2008 HelenOS project";
char *copyright = "Copyright (c) 2001-2009 HelenOS project";
char *release = RELEASE;
char *name = NAME;
char *arch = ARCH;
/branches/arm/kernel/arch/arm32/include/machine.h
111,6 → 111,10
*/
extern uintptr_t machine_get_fb_address(void);
 
/*
* Machine specific frame initialization
*/
extern void machine_frame_init(void);
 
#ifdef MACHINE_GXEMUL_TESTARM
#define machine_console_init(devno) gxemul_console_init(devno)
125,6 → 129,7
gxemul_irq_exception(exc_no, istate)
#define machine_get_fb_address gxemul_get_fb_address
#define machine_fb_init gxemul_fb_init
#define machine_frame_init gxemul_frame_init
#endif
 
#ifdef MACHINE_QEMU_ICP
140,6 → 145,7
qemu_icp_irq_exception(exc_no, istate)
#define machine_get_fb_address qemu_icp_get_fb_address
#define machine_fb_init qemu_icp_fb_init
#define machine_frame_init qemu_icp_frame_init
#endif
#endif
 
/branches/arm/kernel/arch/arm32/include/drivers/gxemul.h
73,6 → 73,7
extern size_t gxemul_get_memory_size(void);
extern uintptr_t gxemul_get_fb_address(void);
extern void gxemul_fb_init(void);
extern void gxemul_frame_init(void);
 
#endif
 
/branches/arm/kernel/arch/arm32/include/drivers/qemu.h
52,7 → 52,7
* of virtual address space.
*/
typedef struct {
uintptr_t videoram;
uintptr_t uart;
uintptr_t kbd_ctrl;
uintptr_t kbd_stat;
uintptr_t kbd_data;
68,6 → 68,7
uintptr_t irqc_unmask;
uintptr_t vga;
uintptr_t cmcr;
uintptr_t sdramcr;
} qemu_icp_hw_map_t;
 
extern void qemu_icp_hw_map_init(void);
81,6 → 82,7
extern size_t qemu_icp_get_memory_size(void);
extern uintptr_t qemu_icp_get_fb_address(void);
extern void qemu_icp_fb_init(void);
extern void qemu_icp_frame_init(void);
#endif
 
/** @}
/branches/arm/kernel/arch/arm32/src/mm/frame.c
53,6 → 53,9
/* blacklist boot page table */
frame_mark_unavailable(BOOT_PAGE_TABLE_START_FRAME,
BOOT_PAGE_TABLE_SIZE_IN_FRAMES);
 
/* Machine specific frame initialization */
machine_frame_init();
}
 
/** Frees the boot page table. */
/branches/arm/kernel/arch/arm32/src/drivers/pl050.c
53,6 → 53,7
 
#define PL050_KEY_RELEASE 0xF0
#define PL050_ESC_KEY 0xE0
#define PL050_CAPS_SCAN_CODE 0x58
 
static void pl050_suspend(chardev_t *);
static void pl050_resume(chardev_t *);
116,7 → 117,7
static void pl050_irq_handler(irq_t *irq, void *arg, ...)
{
static int key_released_flag = 0;
static int caps_count = 0;
static int caps_locked = 0;
 
if (irq->notif_cfg.notify && irq->notif_cfg.answerbox)
ipc_irq_send_notif(irq);
124,32 → 125,29
uint8_t data;
uint8_t status;
if (((status = pl050_statusread()) & PL050_STAT_RXFULL)) {
while (((status = pl050_statusread()) & PL050_STAT_RXFULL)) {
data = pl050_dataread();
 
if (data == PL050_ESC_KEY)
return;
 
if (data == 0x58) {
if (caps_count == 2) {
caps_count = 0;
return;
} else if (key_released_flag && !caps_count) {
key_released_flag = 0;
return;
}
caps_count++;
}
if (data == PL050_KEY_RELEASE) {
key_released_flag = 1;
} else {
if (key_released_flag) {
key_released_flag = 0;
if (data == PL050_CAPS_SCAN_CODE) {
if (!caps_locked) {
caps_locked = 1;
} else {
caps_locked = 0;
return;
}
}
key_released(data);
} else {
if (data == PL050_CAPS_SCAN_CODE && caps_locked)
return;
key_pressed(data);
}
key_released_flag = 0;
}
}
}
/branches/arm/kernel/arch/arm32/src/drivers/gxemul.c
396,5 → 396,11
return (uintptr_t) GXEMUL_FB;
}
 
/*
* GXEMUL specific frame initialization
*/
void gxemul_frame_init(void)
{
}
/** @}
*/
/branches/arm/kernel/arch/arm32/src/drivers/qemu.c
43,6 → 43,8
#include <print.h>
#include <ddi/device.h>
#include <mm/page.h>
#include <mm/frame.h>
#include <arch/mm/frame.h>
#include <arch/machine.h>
#include <arch/debug/print.h>
#include <genarch/fb/fb.h>
49,12 → 51,11
#include <genarch/fb/visuals.h>
 
/* Addresses of devices. */
#define QEMU_ICP_VIDEORAM 0x16000000
#define QEMU_ICP_UART 0x16000000
#define QEMU_ICP_KBD 0x18000000
#define ICP_KBD_STAT 0x04
#define ICP_KBD_DATA 0x08
#define ICP_KBD_INTR_STAT 0x10
#define QEMU_ICP_HALT_OFFSET 0x10
#define QEMU_ICP_RTC 0x13000000
#define QEMU_ICP_RTC1_LOAD_OFFSET 0x100
#define QEMU_ICP_RTC1_READ_OFFSET 0x104
65,22 → 66,35
#define QEMU_ICP_IRQC 0x14000000
#define QEMU_ICP_IRQC_MASK_OFFSET 0xC
#define QEMU_ICP_IRQC_UNMASK_OFFSET 0x8
#define QEMU_ICP_MP 0x11000000
#define QEMU_ICP_MP_MEMSIZE_OFFSET 0x0090
#define QEMU_ICP_FB 0x01000000
 
#define QEMU_ICP_FB 0x00800000
#define QEMU_ICP_FB_FRAME (QEMU_ICP_FB >> 12)
#define QEMU_ICP_FB_NUM_FRAME 300
#define ICP_VGA 0xC0000000
#define ICP_CMCR 0x10000000
#define QEMU_ICP_SDRAM_MASK 0x1C
#define QEMU_ICP_SDRAMCR_OFFSET 0x20
 
/* IRQs */
#define QEMU_ICP_KBD_IRQ 3
#define QEMU_ICP_TIMER_IRQ 6
 
#define SDRAM_SIZE (sdram[((*(uint32_t *)(ICP_CMCR+QEMU_ICP_SDRAMCR_OFFSET) & QEMU_ICP_SDRAM_MASK) >> 2)])
 
static qemu_icp_hw_map_t qemu_icp_hw_map;
static irq_t qemu_icp_timer_irq;
 
static bool hw_map_init_called = false;
static bool vga_init = false;
uint32_t sdram[8] = {
16777216, /* 16mb */
33554432, /* 32mb */
67108864, /* 64mb */
134217728, /* 128mb */
268435456, /* 256mb */
0, /* Reserverd */
0, /* Reserverd */
0 /* Reserverd */
};
 
void icp_vga_init(void);
 
135,7 → 149,7
/** Initializes #qemu_icp_hw_map. */
void qemu_icp_hw_map_init(void)
{
qemu_icp_hw_map.videoram = hw_map(QEMU_ICP_VIDEORAM, PAGE_SIZE);
qemu_icp_hw_map.uart = hw_map(QEMU_ICP_UART, PAGE_SIZE);
qemu_icp_hw_map.kbd_ctrl = hw_map(QEMU_ICP_KBD, PAGE_SIZE);
qemu_icp_hw_map.kbd_stat = qemu_icp_hw_map.kbd_ctrl + ICP_KBD_STAT;
qemu_icp_hw_map.kbd_data = qemu_icp_hw_map.kbd_ctrl + ICP_KBD_DATA;
149,13 → 163,11
 
qemu_icp_hw_map.irqc = hw_map(QEMU_ICP_IRQC, PAGE_SIZE);
qemu_icp_hw_map.irqc_mask = qemu_icp_hw_map.irqc + QEMU_ICP_IRQC_MASK_OFFSET;
qemu_icp_hw_map.irqc_unmask = qemu_icp_hw_map.irqc +
QEMU_ICP_IRQC_UNMASK_OFFSET;
qemu_icp_hw_map.irqc_unmask = qemu_icp_hw_map.irqc + QEMU_ICP_IRQC_UNMASK_OFFSET;
qemu_icp_hw_map.cmcr = hw_map(ICP_CMCR, PAGE_SIZE);
qemu_icp_hw_map.sdramcr = qemu_icp_hw_map.cmcr + QEMU_ICP_SDRAMCR_OFFSET;
qemu_icp_hw_map.vga = hw_map(ICP_VGA, PAGE_SIZE);
 
//icp_vga_init();
 
hw_map_init_called = true;
}
 
251,8 → 263,12
*/
size_t qemu_icp_get_memory_size(void)
{
//return *((int *) (QEMU_ICP_MP + QEMU_ICP_MP_MEMSIZE_OFFSET));
return 0x2000000;
if (hw_map_init_called) {
return (sdram[((*(uint32_t *)qemu_icp_hw_map.sdramcr & QEMU_ICP_SDRAM_MASK) >> 2)]);
} else {
return SDRAM_SIZE;
}
}
 
/** Prints a character.
265,7 → 281,7
if (!hw_map_init_called) {
addr = (char *) QEMU_ICP_KBD;
} else {
addr = (char *) qemu_icp_hw_map.videoram;
addr = (char *) qemu_icp_hw_map.uart;
}
if (ch == '\n')
279,7 → 295,7
while (1);
}
 
/** Gxemul specific interrupt exception handler.
/** interrupt exception handler.
*
* Determines sources of the interrupt from interrupt controller and
* calls high-level handlers for them.
321,6 → 337,15
return (uintptr_t) QEMU_ICP_FB;
}
 
/*
* Integrator specific frame initialization
*/
void
qemu_icp_frame_init(void)
{
frame_mark_unavailable(QEMU_ICP_FB_FRAME, QEMU_ICP_FB_NUM_FRAME);
}
 
 
/** @}
*/
/branches/arm/uspace/app/init/version.c
60,7 → 60,7
/** Print version information. */
void version_print(void)
{
printf("HelenOS init\nRelease %s%s%s\nCopyright (c) 2006 HelenOS project\n", release, revision, timestamp);
printf("HelenOS init\nRelease %s%s%s\nCopyright (c) 2009 HelenOS project\n", release, revision, timestamp);
}
 
/** @}
/branches/arm/uspace/srv/kbd/arch/arm32/src/kbd_icp.c
54,6 → 54,7
 
#define PL050_KEY_RELEASE 0xF0
#define PL050_ESC_KEY 0xE0
#define PL050_CAPS_SCAN_CODE 0x58
 
irq_cmd_t pl050_cmds[] = {
{ CMD_MEM_READ_1, (void *) 0, 0, 1 },
91,31 → 92,27
int kbd_arch_process(keybuffer_t *keybuffer, ipc_call_t *call)
{
static int key_released_flag = 0;
static int caps_count = 0;
static int caps_locked = 0;
int scan_code = IPC_GET_ARG1(*call);
 
if (scan_code == 0x58) {
if (caps_count == 2) {
caps_count = 0;
return 1;
} else if (key_released_flag && !caps_count) {
key_released_flag = 0;
return 1;
}
caps_count++;
}
 
if (scan_code == PL050_KEY_RELEASE) {
key_released_flag = 1;
} else {
if (key_released_flag) {
key_released_flag = 0;
if (scan_code == PL050_CAPS_SCAN_CODE) {
if (caps_locked) {
caps_locked = 0;
return 1;
} else
caps_locked = 1;
}
key_released(keybuffer, scan_code);
} else {
if (scan_code == PL050_CAPS_SCAN_CODE && caps_locked)
return 1;
key_pressed(keybuffer, scan_code);
}
key_released_flag = 0;
}
 
return 1;
/branches/arm/boot/arch/arm32/loader/main.c
64,7 → 64,7
/** Prints bootloader version information. */
static void version_print(void)
{
printf("HelenOS ARM32 Bootloader\nRelease %s%s%s\nCopyright (c) 2007 HelenOS project\n",
printf("HelenOS ARM32 Bootloader\nRelease %s%s%s\nCopyright (c) 2009 HelenOS project\n",
release, revision, timestamp);
}