jens/mips
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- use build in data types

Browse Source 
git-svn-id: http://moon:8086/svn/mips@35 a8ebac50-d88d-4704-bea3-6648445a41b3
This commit is contained in:
jens
2015-05-28 19:19:01 +00:00
parent 3263f9d79c
commit a655e1c5d9
54 changed files with 1551 additions and 1583 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/barcode.c
+28 -28
View File
@@ -10,15 +10,15 @@
#include "libsys.h" #include "libsys.h"
#include "irq.h" #include "irq.h"
UINT32 buffer[16384]; uint32_t buffer[16384];
#define T_SAMPLE 5000 #define T_SAMPLE 5000
#define TIMEOUT 1000 #define TIMEOUT 1000
typedef struct _bar_t typedef struct _bar_t
{ {
UINT32 T; uint32_t T;
UINT32 black; uint32_t black;
} bar_t; } bar_t;
enum enum
@@ -30,13 +30,13 @@ enum
typedef struct _sbar_cand_t typedef struct _sbar_cand_t
{ {
UINT32 T; uint32_t T;
UINT32 is_primitive; uint32_t is_primitive;
} bar_cand_t; } bar_cand_t;
bar_t bars[1024]; bar_t bars[1024];
void bsort(float *pData, UINT32 len) void bsort(float *pData, uint32_t len)
{ {
float t; float t;
int i, j; int i, j;
@@ -57,14 +57,14 @@ void bsort(float *pData, UINT32 len)
typedef struct _smedian_t typedef struct _smedian_t
{ {
UINT32 N; uint32_t N;
UINT32 is_dirty; uint32_t is_dirty;
float *pBuf, *pSorted; float *pBuf, *pSorted;
UINT32 w; uint32_t w;
float median; float median;
} median_t; } median_t;
void Median_init(median_t *pObj, UINT32 N, float init_val) void Median_init(median_t *pObj, uint32_t N, float init_val)
{ {
int i; int i;
pObj->pBuf = (float*)malloc(N*sizeof(float)); pObj->pBuf = (float*)malloc(N*sizeof(float));
@@ -124,9 +124,9 @@ float Median_get(median_t *pObj)
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
UINT32 detect_module(UINT32 T, UINT32 T0) uint32_t detect_module(uint32_t T, uint32_t T0)
{ {
UINT32 m, best_M; uint32_t m, best_M;
float err, kc, best_err; float err, kc, best_err;
best_err = 4.f; best_err = 4.f;
@@ -149,16 +149,16 @@ UINT32 detect_module(UINT32 T, UINT32 T0)
void handler7(void) void handler7(void)
{ {
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pPS20_stat = (UINT32*)SYS_PS2_0_STAT; uint32_t volatile *pPS20_stat = (uint32_t*)SYS_PS2_0_STAT;
UINT32 volatile *pPS21_stat = (UINT32*)SYS_PS2_1_STAT; uint32_t volatile *pPS21_stat = (uint32_t*)SYS_PS2_1_STAT;
static UINT32 state, bar_count; static uint32_t state, bar_count;
static UINT32 timeout_count, timeout_reload; static uint32_t timeout_count, timeout_reload;
static UINT32 white, pin_last, skip, start; static uint32_t white, pin_last, skip, start;
static UINT32 module_cnt_w, module_cnt_b, Tmod0_w, Tmod0_b, M, T0; static uint32_t module_cnt_w, module_cnt_b, Tmod0_w, Tmod0_b, M, T0;
float ratio, error, kc; float ratio, error, kc;
UINT32 i; uint32_t i;
static median_t med_b, med_w; static median_t med_b, med_w;
static bar_cand_t bc_b, bc_w; static bar_cand_t bc_b, bc_w;
static median_t speed_b, speed_w; static median_t speed_b, speed_w;
@@ -274,7 +274,7 @@ void handler7(void)
// printf("M=%d, R=%2.2f, E=%+2.2f [%04d]", M, ratio, error, T0); // printf("M=%d, R=%2.2f, E=%+2.2f [%04d]", M, ratio, error, T0);
// if (M == 1) // if (M == 1)
Median_value_add(&med_b, (UINT32)(T0*kc)); Median_value_add(&med_b, (uint32_t)(T0*kc));
Median_value_add(&speed_b, (float)bars[i].T/(M*Tmod0_b)); Median_value_add(&speed_b, (float)bars[i].T/(M*Tmod0_b));
printf("%06d %2.6f ", bars[i].T, Median_get(&speed_b)); printf("%06d %2.6f ", bars[i].T, Median_get(&speed_b));
@@ -303,7 +303,7 @@ void handler7(void)
// printf(" M=%d, R=%2.2f, E=%+2.2f [%04d]", M, ratio, error, T0); // printf(" M=%d, R=%2.2f, E=%+2.2f [%04d]", M, ratio, error, T0);
// if (M == 1) // if (M == 1)
Median_value_add(&med_w, (UINT32)(T0*kc)); Median_value_add(&med_w, (uint32_t)(T0*kc));
Median_value_add(&speed_w, (float)bars[i].T/(M*Tmod0_w)); Median_value_add(&speed_w, (float)bars[i].T/(M*Tmod0_w));
printf("%06d %2.6f ", bars[i].T, Median_get(&speed_w)); printf("%06d %2.6f ", bars[i].T, Median_get(&speed_w));
@@ -335,13 +335,13 @@ int main(void)
{ {
int i; int i;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim0_cnt = (UINT32*)SYS_ITIM0_CNT; uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
*pTim0_cnt = 0; *pTim0_cnt = 0;
*pTim0_cmp = (UINT32)T_SAMPLE; *pTim0_cmp = (uint32_t)T_SAMPLE;
*pTim_stat = 1; *pTim_stat = 1;
*pTim_ctrl = 3; *pTim_ctrl = 3;
src/barcode.new.c
+27 -27
View File
@@ -10,15 +10,15 @@
#include "libsys.h" #include "libsys.h"
#include "irq.h" #include "irq.h"
UINT32 buffer[16384]; uint32_t buffer[16384];
#define T_SAMPLE 5000 #define T_SAMPLE 5000
#define TIMEOUT 1000 #define TIMEOUT 1000
typedef struct _bar_t typedef struct _bar_t
{ {
UINT32 T; uint32_t T;
UINT32 black; uint32_t black;
} bar_t; } bar_t;
enum enum
@@ -30,7 +30,7 @@ enum
bar_t bars[1024]; bar_t bars[1024];
void bsort(float *pData, UINT32 len) void bsort(float *pData, uint32_t len)
{ {
float t; float t;
int i, j; int i, j;
@@ -51,14 +51,14 @@ void bsort(float *pData, UINT32 len)
typedef struct _smedian_t typedef struct _smedian_t
{ {
UINT32 N; uint32_t N;
UINT32 is_dirty; uint32_t is_dirty;
float *pBuf, *pSorted; float *pBuf, *pSorted;
UINT32 w; uint32_t w;
float median; float median;
} median_t; } median_t;
void Median_init(median_t *pObj, UINT32 N, float init_val) void Median_init(median_t *pObj, uint32_t N, float init_val)
{ {
int i; int i;
pObj->pBuf = (float*)malloc(N*sizeof(float)); pObj->pBuf = (float*)malloc(N*sizeof(float));
@@ -118,9 +118,9 @@ float Median_get(median_t *pObj)
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
UINT32 detect_module(UINT32 T, UINT32 *pBC) uint32_t detect_module(uint32_t T, uint32_t *pBC)
{ {
UINT32 m, best_M; uint32_t m, best_M;
float err, kc, best_err; float err, kc, best_err;
best_err = 4.f; best_err = 4.f;
@@ -143,18 +143,18 @@ UINT32 detect_module(UINT32 T, UINT32 *pBC)
void handler7(void) void handler7(void)
{ {
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pPS20_stat = (UINT32*)SYS_PS2_0_STAT; uint32_t volatile *pPS20_stat = (uint32_t*)SYS_PS2_0_STAT;
UINT32 volatile *pPS21_stat = (UINT32*)SYS_PS2_1_STAT; uint32_t volatile *pPS21_stat = (uint32_t*)SYS_PS2_1_STAT;
static UINT32 state, bar_count; static uint32_t state, bar_count;
static UINT32 timeout_count, timeout_reload; static uint32_t timeout_count, timeout_reload;
static UINT32 white, pin_last, skip, start; static uint32_t white, pin_last, skip, start;
static UINT32 module_cnt_w, module_cnt_b, Tmod0_w, Tmod0_b, M, T0; static uint32_t module_cnt_w, module_cnt_b, Tmod0_w, Tmod0_b, M, T0;
float ratio, error, kc; float ratio, error, kc;
UINT32 i, j; uint32_t i, j;
static median_t med_b, med_w; static median_t med_b, med_w;
static UINT32 bc_b[4], bc_w[4]; static uint32_t bc_b[4], bc_w[4];
if (*pTim_stat & 1) if (*pTim_stat & 1)
{ {
@@ -254,7 +254,7 @@ void handler7(void)
Median_value_add(&med_b, kc); Median_value_add(&med_b, kc);
printf("M=%d, R=%2.2f, E=%+2.2f [%04d]", M, kc, error, bc_b[M-1]); printf("M=%d, R=%2.2f, E=%+2.2f [%04d]", M, kc, error, bc_b[M-1]);
kc = Median_get(&med_b); kc = Median_get(&med_b);
bc_b[M-1] = (UINT32)(kc*bc_b[M-1]); bc_b[M-1] = (uint32_t)(kc*bc_b[M-1]);
} }
// printf("%d", M); // printf("%d", M);
@@ -269,7 +269,7 @@ void handler7(void)
Median_value_add(&med_w, kc); Median_value_add(&med_w, kc);
printf(" M=%d, R=%2.2f, E=%+2.2f [%04d]", M, kc, error, bc_w[M-1]); printf(" M=%d, R=%2.2f, E=%+2.2f [%04d]", M, kc, error, bc_w[M-1]);
kc = Median_get(&med_w); kc = Median_get(&med_w);
bc_w[M-1] = (UINT32)(kc*bc_w[M-1]); bc_w[M-1] = (uint32_t)(kc*bc_w[M-1]);
} }
// printf("%d", M); // printf("%d", M);
@@ -299,13 +299,13 @@ int main(void)
{ {
int i; int i;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim0_cnt = (UINT32*)SYS_ITIM0_CNT; uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
*pTim0_cnt = 0; *pTim0_cnt = 0;
*pTim0_cmp = (UINT32)T_SAMPLE; *pTim0_cmp = (uint32_t)T_SAMPLE;
*pTim_stat = 1; *pTim_stat = 1;
*pTim_ctrl = 3; *pTim_ctrl = 3;
src/blittertest.c
+117 -117
View File
@@ -16,23 +16,23 @@ gpio_if_t gpio_if;
box_t box; box_t box;
gfx_t gfx; gfx_t gfx;
UINT32 color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080}; uint32_t color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080};
volatile UINT32 _g_blitter_rdy; volatile uint32_t _g_blitter_rdy;
volatile UINT32 _g_blit_count; volatile uint32_t _g_blit_count;
void ISR_blitter_FIN(void) void ISR_blitter_FIN(void)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
UINT32 volatile *pGPIO = (UINT32*)SYS_GPIO_0_DATA; uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA;
static UINT32 color; static uint32_t color;
// Ack // Ack
if(_g_blit_count) if(_g_blit_count)
@@ -59,17 +59,17 @@ void ISR_blitter_FIN(void)
void ISR_blitter_EMPTY(void) void ISR_blitter_EMPTY(void)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
UINT32 volatile *pGPIO = (UINT32*)SYS_GPIO_0_DATA; uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA;
static UINT32 color; static uint32_t color;
// Ack // Ack
if(_g_blit_count) if(_g_blit_count)
@@ -95,22 +95,22 @@ void ISR_blitter_EMPTY(void)
} }
void BlitWaitStillActive(void); void BlitWaitStillActive(void);
void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UINT32 size_x, UINT32 size_y, UINT32 color); void BlitConstColor(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x, uint32_t pos_y, uint32_t size_x, uint32_t size_y, uint32_t color);
void Blit(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst, UINT32 size_x, UINT32 size_y); void Blit(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst, uint32_t size_x, uint32_t size_y);
// ------------------------------------------------------------- // -------------------------------------------------------------
void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage, UINT32 image_nx, UINT32 image_ny, UINT32 image_scale_x, UINT32 image_scale_y) void LoadPic(uint64_t *pScreen, uint32_t screen_nx, uint32_t screen_ny, uint32_t *pImage, uint32_t image_nx, uint32_t image_ny, uint32_t image_scale_x, uint32_t image_scale_y)
{ {
UINT32 off_x, off_y; uint32_t off_x, off_y;
UINT32 i, j, black; uint32_t i, j, black;
UINT32 *pScr, *pImg; uint32_t *pScr, *pImg;
off_x = (screen_nx-(image_scale_x*image_nx))/2; off_x = (screen_nx-(image_scale_x*image_nx))/2;
off_y = (screen_ny-(image_scale_y*image_ny))/2; off_y = (screen_ny-(image_scale_y*image_ny))/2;
black = 0; black = 0;
pScr = (UINT32*)pScreen; pScr = (uint32_t*)pScreen;
for (i=0; i < screen_nx*screen_ny; i += 8) for (i=0; i < screen_nx*screen_ny; i += 8)
{ {
__gfx_block_set_8(pScr, 0); __gfx_block_set_8(pScr, 0);
@@ -120,7 +120,7 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
if (!pImage) if (!pImage)
return; return;
pScr = ((UINT32*)pScreen) + screen_nx*off_y + off_x; pScr = ((uint32_t*)pScreen) + screen_nx*off_y + off_x;
pImg = pImage; pImg = pImage;
for (i=0; i < image_ny*image_nx; i += 8) for (i=0; i < image_ny*image_nx; i += 8)
@@ -131,19 +131,19 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
} }
/* /*
UINT32 off_x, off_y; uint32_t off_x, off_y;
UINT32 i; uint32_t i;
UINT32 *pScr; uint32_t *pScr;
off_x = (screen_nx-(image_scale_x*image_nx))/2; off_x = (screen_nx-(image_scale_x*image_nx))/2;
off_y = (screen_ny-(image_scale_y*image_ny))/2; off_y = (screen_ny-(image_scale_y*image_ny))/2;
memset(pScreen, 0, screen_nx*screen_ny*sizeof(UINT32)); memset(pScreen, 0, screen_nx*screen_ny*sizeof(uint32_t));
pScr = ((UINT32*)pScreen) + screen_nx*off_y + off_x; pScr = ((uint32_t*)pScreen) + screen_nx*off_y + off_x;
for (i=0; i < image_ny; i++) for (i=0; i < image_ny; i++)
{ {
memcpy(pScr, &pImage[i*image_nx], image_nx*sizeof(UINT32)); memcpy(pScr, &pImage[i*image_nx], image_nx*sizeof(uint32_t));
pScr += screen_nx; pScr += screen_nx;
} }
*/ */
@@ -152,37 +152,37 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
int main (void) int main (void)
{ {
int result, i, j, cnt, size, num_runs; int result, i, j, cnt, size, num_runs;
UINT32 volatile *pUART_baud = (UINT32*)SYS_UART_BAUD; uint32_t volatile *pUART_baud = (uint32_t*)SYS_UART_BAUD;
UINT32 volatile *pUART_stat = (UINT32*)SYS_UART_STAT; uint32_t volatile *pUART_stat = (uint32_t*)SYS_UART_STAT;
UINT32 volatile *pGPIO = (UINT32*)SYS_GPIO_0_DATA; uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA;
UINT32 volatile *pReg_usec = (UINT32*)SYS_TIMER_USEC; uint32_t volatile *pReg_usec = (uint32_t*)SYS_TIMER_USEC;
UINT32 volatile *pReg_sec = (UINT32*)SYS_TIMER_SEC; uint32_t volatile *pReg_sec = (uint32_t*)SYS_TIMER_SEC;
UINT32 volatile *pSSRAM = (UINT32*)SYS_SSRAM_IO; uint32_t volatile *pSSRAM = (uint32_t*)SYS_SSRAM_IO;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim0_cnt = (UINT32*)SYS_ITIM0_CNT; uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
UINT32 volatile *pTim1_cnt = (UINT32*)SYS_ITIM1_CNT; uint32_t volatile *pTim1_cnt = (uint32_t*)SYS_ITIM1_CNT;
UINT32 volatile *pTim1_cmp = (UINT32*)SYS_ITIM1_CMP; uint32_t volatile *pTim1_cmp = (uint32_t*)SYS_ITIM1_CMP;
UINT32 volatile *pVGA_cgcol = (UINT32*)SYS_VGA_CGCOL; uint32_t volatile *pVGA_cgcol = (uint32_t*)SYS_VGA_CGCOL;
UINT32 volatile *pFlashPicture = (UINT32*)(SYS_FLASH_MEM + 0x00600000); uint32_t volatile *pFlashPicture = (uint32_t*)(SYS_FLASH_MEM + 0x00600000);
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
UINT32 screen_res_x, screen_res_y, screen_fps; uint32_t screen_res_x, screen_res_y, screen_fps;
UINT32 pos, posx, posy, xoff, yoff, color; uint32_t pos, posx, posy, xoff, yoff, color;
UINT64 *pBuf64_0, *pBuf64_1; uint64_t *pBuf64_0, *pBuf64_1;
time_t curr_date; time_t curr_date;
struct tm *pDate, date; struct tm *pDate, date;
UINT32 start, end; uint32_t start, end;
char sel[80]; char sel[80];
struct timeval time_sec; struct timeval time_sec;
@@ -233,7 +233,7 @@ int main (void)
*pVGA_nx = box.w; *pVGA_nx = box.w;
*pVGA_ny = box.h; *pVGA_ny = box.h;
*pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL; *pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL;
*pVGA_dst = (UINT32)*pVGA_moffs_0 + 4*(5 + 800*5);// + 4*((UINT32)rand()%800 + 800*((UINT32)rand()%600)); *pVGA_dst = (uint32_t)*pVGA_moffs_0 + 4*(5 + 800*5);// + 4*((uint32_t)rand()%800 + 800*((uint32_t)rand()%600));
color = 0; color = 0;
start = clock(); start = clock();
@@ -317,28 +317,28 @@ int main (void)
xoff = 100; xoff = 100;
yoff = 0; yoff = 0;
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h);
box_create(&box, 63-2*i, 63-2*i); box_create(&box, 63-2*i, 63-2*i);
xoff = 100; xoff = 100;
yoff = 100; yoff = 100;
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h);
xoff = 100; xoff = 100;
yoff = 200; yoff = 200;
box_create(&box, 65-2*i, 65-2*i); box_create(&box, 65-2*i, 65-2*i);
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff+i, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+100+i, yoff+i, box.w, box.h, color);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+201+i, yoff+i, box.w, box.h, color);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+300+i, yoff+i, box.w, box.h);
Blit((UINT32)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h); Blit((uint32_t)*pVGA_moffs_0, 800, xoff+i, yoff+i, xoff+401+i, yoff+i, box.w, box.h);
} }
GFX_frame(&gfx, GFX_FRAME_SYNC); GFX_frame(&gfx, GFX_FRAME_SYNC);
@@ -351,8 +351,8 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+65, 64, 64); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+65, 64, 64);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+65+65, 64, 64); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+65+65, 64, 64);
xoff = 81; xoff = 81;
yoff = 300; yoff = 300;
@@ -362,8 +362,8 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+65, 64, 64); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+65, 64, 64);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+65+65, 64, 64); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+65+65, 64, 64);
xoff = 160; xoff = 160;
yoff = 300; yoff = 300;
@@ -373,8 +373,8 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+64, 63, 63); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+64, 63, 63);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+64+64, 63, 63); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+64+64, 63, 63);
xoff = 241; xoff = 241;
yoff = 300; yoff = 300;
@@ -384,8 +384,8 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+64, 63, 63); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+64, 63, 63);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+64+64, 63, 63); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+64+64, 63, 63);
xoff = 320; xoff = 320;
yoff = 300; yoff = 300;
@@ -395,8 +395,8 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+66, 65, 65); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+66, 65, 65);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+66+66, 65, 65); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+66+66, 65, 65);
xoff = 401; xoff = 401;
yoff = 300; yoff = 300;
@@ -406,21 +406,21 @@ int main (void)
color = color_cycle[i%12]; color = color_cycle[i%12];
GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color); GFX_box_draw_direct(&gfx, &box, xoff+i, yoff, color);
} }
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+66, 65, 65); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff, yoff+66, 65, 65);
Blit((UINT32)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+66+66, 65, 65); Blit((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, xoff+1, yoff+66+66, 65, 65);
xoff = 10; xoff = 10;
yoff = 500; yoff = 500;
box_create(&box, 64, 1); box_create(&box, 64, 1);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff, yoff, box.w, box.h, 0xFFFFFFFF); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, box.w, box.h, 0xFFFFFFFF);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+1, yoff+2, box.w, box.h, 0xFFFFFFFF); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+1, yoff+2, box.w, box.h, 0xFFFFFFFF);
xoff = 80; xoff = 80;
yoff = 500; yoff = 500;
box_create(&box, 1, 64); box_create(&box, 1, 64);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff, yoff, box.w, box.h, 0xFFFFFFFF); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff, yoff, box.w, box.h, 0xFFFFFFFF);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+10, yoff, box.w, box.h, 0xFFFFFFFF); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+10, yoff, box.w, box.h, 0xFFFFFFFF);
BlitConstColor((UINT32)*pVGA_moffs_0, 800, xoff+21, yoff, box.w, box.h, 0xFFFFFFFF); BlitConstColor((uint32_t)*pVGA_moffs_0, 800, xoff+21, yoff, box.w, box.h, 0xFFFFFFFF);
size++; size++;
if (size > 256) if (size > 256)
@@ -429,18 +429,18 @@ int main (void)
} }
} }
void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UINT32 size_x, UINT32 size_y, UINT32 color) void BlitConstColor(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x, uint32_t pos_y, uint32_t size_x, uint32_t size_y, uint32_t color)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
// fprintf(stdout, "BlitConstColor to (%d,%d), size (%d,%d) ...", pos_x, pos_y, size_x, size_y); // fprintf(stdout, "BlitConstColor to (%d,%d), size (%d,%d) ...", pos_x, pos_y, size_x, size_y);
@@ -457,18 +457,18 @@ void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UI
// fprintf(stdout, "done\n"); // fprintf(stdout, "done\n");
} }
void Blit(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst, UINT32 size_x, UINT32 size_y) void Blit(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst, uint32_t size_x, uint32_t size_y)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
// fprintf(stdout, "Blit from (%d,%d) to (%d,%d), size (%d,%d) ...", pos_x_src, pos_y_src, pos_x_dst, pos_y_dst, size_x, size_y); // fprintf(stdout, "Blit from (%d,%d) to (%d,%d), size (%d,%d) ...", pos_x_src, pos_y_src, pos_x_dst, pos_y_dst, size_x, size_y);
@@ -490,7 +490,7 @@ void Blit(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x_src, UINT32 pos_y_src, UINT
void BlitWaitStillActive(void) void BlitWaitStillActive(void)
{ {
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
while (*pVGA_ctrl & SYS_VGA_BIT_BLIT_ACTIVE); while (*pVGA_ctrl & SYS_VGA_BIT_BLIT_ACTIVE);
} }
src/blittertest_tb.c
+59 -59
View File
@@ -16,47 +16,47 @@ gpio_if_t gpio_if;
box_t box; box_t box;
gfx_t gfx; gfx_t gfx;
UINT32 color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080}; uint32_t color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080};
void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UINT32 size_x, UINT32 size_y, UINT32 color); void BlitConstColor(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x, uint32_t pos_y, uint32_t size_x, uint32_t size_y, uint32_t color);
void Blit(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst, UINT32 size_x, UINT32 size_y); void Blit(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst, uint32_t size_x, uint32_t size_y);
int main (void) int main (void)
{ {
int result, i, j, cnt, size; int result, i, j, cnt, size;
UINT32 volatile *pUART_baud = (UINT32*)SYS_UART_BAUD; uint32_t volatile *pUART_baud = (uint32_t*)SYS_UART_BAUD;
UINT32 volatile *pUART_stat = (UINT32*)SYS_UART_STAT; uint32_t volatile *pUART_stat = (uint32_t*)SYS_UART_STAT;
UINT32 volatile *pGPIO = (UINT32*)SYS_GPIO_0_DATA; uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA;
UINT32 volatile *pReg_usec = (UINT32*)SYS_TIMER_USEC; uint32_t volatile *pReg_usec = (uint32_t*)SYS_TIMER_USEC;
UINT32 volatile *pReg_sec = (UINT32*)SYS_TIMER_SEC; uint32_t volatile *pReg_sec = (uint32_t*)SYS_TIMER_SEC;
UINT32 volatile *pSSRAM = (UINT32*)SYS_SSRAM_IO; uint32_t volatile *pSSRAM = (uint32_t*)SYS_SSRAM_IO;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim0_cnt = (UINT32*)SYS_ITIM0_CNT; uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
UINT32 volatile *pTim1_cnt = (UINT32*)SYS_ITIM1_CNT; uint32_t volatile *pTim1_cnt = (uint32_t*)SYS_ITIM1_CNT;
UINT32 volatile *pTim1_cmp = (UINT32*)SYS_ITIM1_CMP; uint32_t volatile *pTim1_cmp = (uint32_t*)SYS_ITIM1_CMP;
UINT32 volatile *pVGA_cgcol = (UINT32*)SYS_VGA_CGCOL; uint32_t volatile *pVGA_cgcol = (uint32_t*)SYS_VGA_CGCOL;
UINT32 volatile *pFlashPicture = (UINT32*)(SYS_FLASH_MEM + 0x00600000); uint32_t volatile *pFlashPicture = (uint32_t*)(SYS_FLASH_MEM + 0x00600000);
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_moffs_1 = (UINT32*)SYS_VGA_FB_BACK; uint32_t volatile *pVGA_moffs_1 = (uint32_t*)SYS_VGA_FB_BACK;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_DST_LAST; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_DST_LAST;
UINT32 screen_res_x, screen_res_y, screen_fps; uint32_t screen_res_x, screen_res_y, screen_fps;
UINT32 pos, posx, posy, xoff, yoff, color; uint32_t pos, posx, posy, xoff, yoff, color;
UINT64 *pBuf64_0, *pBuf64_1; uint64_t *pBuf64_0, *pBuf64_1;
time_t curr_date; time_t curr_date;
struct tm *pDate, date; struct tm *pDate, date;
UINT32 start, end; uint32_t start, end;
char sel[80]; char sel[80];
struct timeval time_sec; struct timeval time_sec;
@@ -66,9 +66,9 @@ int main (void)
*pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_FIN_INTEN; *pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_FIN_INTEN;
*pVGA_cgcol = 0x00FFFFFF; *pVGA_cgcol = 0x00FFFFFF;
pBuf64_0 = (UINT64*)malloc(800*600*4); pBuf64_0 = (uint64_t*)malloc(800*600*4);
*pVGA_moffs_0 = (UINT32)pBuf64_0; *pVGA_moffs_0 = (uint32_t)pBuf64_0;
*pVGA_moffs_1 = (UINT32)pBuf64_0; *pVGA_moffs_1 = (uint32_t)pBuf64_0;
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
// GFX_init(&gfx); // GFX_init(&gfx);
@@ -77,12 +77,12 @@ int main (void)
box_create(&box, 128, 128); box_create(&box, 128, 128);
*pVGA_dimx_src0 = (UINT32)4*800; *pVGA_dimx_src0 = (uint32_t)4*800;
*pVGA_dimx_dst = (UINT32)4*800; *pVGA_dimx_dst = (uint32_t)4*800;
*pVGA_nx = (UINT32)box.w; *pVGA_nx = (uint32_t)box.w;
*pVGA_ny = (UINT32)box.h; *pVGA_ny = (uint32_t)box.h;
*pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL; *pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL;
*pVGA_dst = (UINT32)*pVGA_moffs_0 + 4*(5 + 800*5);// + 4*((UINT32)rand()%800 + 800*((UINT32)rand()%600)); *pVGA_dst = (uint32_t)*pVGA_moffs_0 + 4*(5 + 800*5);// + 4*((uint32_t)rand()%800 + 800*((uint32_t)rand()%600));
*pGPIO = 1; *pGPIO = 1;
color = 0; color = 0;
@@ -118,18 +118,18 @@ int main (void)
} }
} }
void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UINT32 size_x, UINT32 size_y, UINT32 color) void BlitConstColor(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x, uint32_t pos_y, uint32_t size_x, uint32_t size_y, uint32_t color)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_DST_LAST; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_DST_LAST;
// fprintf(stdout, "BlitConstColor to (%d,%d), size (%d,%d) ...", pos_x, pos_y, size_x, size_y); // fprintf(stdout, "BlitConstColor to (%d,%d), size (%d,%d) ...", pos_x, pos_y, size_x, size_y);
@@ -146,18 +146,18 @@ void BlitConstColor(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x, UINT32 pos_y, UI
// fprintf(stdout, "done\n"); // fprintf(stdout, "done\n");
} }
void Blit(UINT32 fb_addr, UINT32 dim_x, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst, UINT32 size_x, UINT32 size_y) void Blit(uint32_t fb_addr, uint32_t dim_x, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst, uint32_t size_x, uint32_t size_y)
{ {
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_DST_LAST; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_DST_LAST;
// fprintf(stdout, "Blit from (%d,%d) to (%d,%d), size (%d,%d) ...", pos_x_src, pos_y_src, pos_x_dst, pos_y_dst, size_x, size_y); // fprintf(stdout, "Blit from (%d,%d) to (%d,%d), size (%d,%d) ...", pos_x_src, pos_y_src, pos_x_dst, pos_y_dst, size_x, size_y);
src/bootloader/test.c
+3 -1
View File
@@ -1,5 +1,7 @@
#include "libsys_boot.h" #include "libsys_boot.h"
extern uint32_t stack_ptr;
void handler3(void) void handler3(void)
{ {
volatile uint32_t *pUART0_stat = (uint32_t*)SYS_UART_STAT; volatile uint32_t *pUART0_stat = (uint32_t*)SYS_UART_STAT;
@@ -37,7 +39,7 @@ void main()
*pGPIO = led; *pGPIO = led;
if(led == 0) if(led == 0)
{ {
memdump((uint8_t*)pRAM, 0, 16, 256); memdump((uint8_t*)(0x7FFFEFF0-4096-256), 0, 16, 256);
} }
led = (led+1) % 64; led = (led+1) % 64;
src/emac.c
+22 -22
View File
@@ -10,8 +10,8 @@
void EMAC_TX_commit(void) void EMAC_TX_commit(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_TX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_TX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_TX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_TX_SIZE;
*pEmac_ctrl |= EMAC_TX_CTRL_PKT_COMMIT; *pEmac_ctrl |= EMAC_TX_CTRL_PKT_COMMIT;
@@ -20,8 +20,8 @@ void EMAC_TX_commit(void)
void EMAC_TX_alloc(uint32_t size) void EMAC_TX_alloc(uint32_t size)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_TX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_TX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_TX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_TX_SIZE;
while(*pEmac_ctrl & EMAC_TX_STAT_PKT_ALLOC_BSY); while(*pEmac_ctrl & EMAC_TX_STAT_PKT_ALLOC_BSY);
@@ -35,8 +35,8 @@ void EMAC_TX_alloc(uint32_t size)
uint32_t EMAC_TX_is_avail(void) uint32_t EMAC_TX_is_avail(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_TX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_TX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_TX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_TX_SIZE;
while(*pEmac_ctrl & EMAC_TX_STAT_PKT_ALLOC_BSY); while(*pEmac_ctrl & EMAC_TX_STAT_PKT_ALLOC_BSY);
@@ -47,8 +47,8 @@ uint32_t EMAC_TX_is_avail(void)
uint32_t EMAC_TX_is_idle(void) uint32_t EMAC_TX_is_idle(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_TX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_TX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_TX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_TX_SIZE;
return (*pEmac_ctrl & EMAC_TX_STAT_PKT_DONE) == EMAC_TX_STAT_PKT_DONE; return (*pEmac_ctrl & EMAC_TX_STAT_PKT_DONE) == EMAC_TX_STAT_PKT_DONE;
@@ -57,8 +57,8 @@ uint32_t EMAC_TX_is_idle(void)
void EMAC_TX_reset(void) void EMAC_TX_reset(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_TX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_TX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_TX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_TX_SIZE;
*pEmac_ctrl = EMAC_TX_CTRL_RESET | EMAC_TX_CTRL_FCS_APPEND; *pEmac_ctrl = EMAC_TX_CTRL_RESET | EMAC_TX_CTRL_FCS_APPEND;
@@ -69,8 +69,8 @@ void EMAC_TX_reset(void)
uint32_t EMAC_RX_is_avail(void) uint32_t EMAC_RX_is_avail(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
return (*pEmac_ctrl & EMAC_RX_STAT_PKT_AVAIL) == EMAC_RX_STAT_PKT_AVAIL; return (*pEmac_ctrl & EMAC_RX_STAT_PKT_AVAIL) == EMAC_RX_STAT_PKT_AVAIL;
@@ -79,8 +79,8 @@ uint32_t EMAC_RX_is_avail(void)
void EMAC_RX_request(void) void EMAC_RX_request(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
*pEmac_ctrl = (*pEmac_ctrl & ~EMAC_RX_CTRL_PKT_FREE) | EMAC_RX_CTRL_PKT_REQ; *pEmac_ctrl = (*pEmac_ctrl & ~EMAC_RX_CTRL_PKT_FREE) | EMAC_RX_CTRL_PKT_REQ;
@@ -89,8 +89,8 @@ void EMAC_RX_request(void)
uint32_t EMAC_RX_is_valid(void) uint32_t EMAC_RX_is_valid(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
return (*pEmac_ctrl & EMAC_RX_STAT_PKT_VALID) == EMAC_RX_STAT_PKT_VALID; return (*pEmac_ctrl & EMAC_RX_STAT_PKT_VALID) == EMAC_RX_STAT_PKT_VALID;
@@ -99,8 +99,8 @@ uint32_t EMAC_RX_is_valid(void)
void EMAC_RX_free(void) void EMAC_RX_free(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
*pEmac_ctrl = (*pEmac_ctrl & ~EMAC_RX_CTRL_PKT_REQ) | EMAC_RX_CTRL_PKT_FREE; *pEmac_ctrl = (*pEmac_ctrl & ~EMAC_RX_CTRL_PKT_REQ) | EMAC_RX_CTRL_PKT_FREE;
@@ -109,8 +109,8 @@ void EMAC_RX_free(void)
void EMAC_RX_reset(void) void EMAC_RX_reset(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
*pEmac_ctrl = EMAC_RX_CTRL_RESET | EMAC_RX_CTRL_FCS_CHECK; *pEmac_ctrl = EMAC_RX_CTRL_RESET | EMAC_RX_CTRL_FCS_CHECK;
@@ -121,8 +121,8 @@ void EMAC_RX_reset(void)
uint32_t EMAC_RX_get_size(void) uint32_t EMAC_RX_get_size(void)
{ {
volatile UINT32 *pEmac_ctrl = (UINT32*)SYS_EMAC_RX_CTRL; volatile uint32_t *pEmac_ctrl = (uint32_t*)SYS_EMAC_RX_CTRL;
volatile UINT32 *pEmac_size = (UINT32*)SYS_EMAC_RX_SIZE; volatile uint32_t *pEmac_size = (uint32_t*)SYS_EMAC_RX_SIZE;
return *pEmac_size; return *pEmac_size;
src/fft.c
+32 -32
View File
@@ -3,7 +3,7 @@
/* Fast-Fourier-Transformation /* Fast-Fourier-Transformation
/* Author: Jens Ahrensfeld /* Author: Jens Ahrensfeld
/* Datum : 24.06.1999 /* Datum : 24.06.1999
/* letzte Änderung: 09.06.2000 /* letzte �nderung: 09.06.2000
/***************************************************************************/ /***************************************************************************/
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@@ -18,7 +18,7 @@
/* Konstruktor FFT-Objekt */ /* Konstruktor FFT-Objekt */
/* */ /* */
/***************************************************************************/ /***************************************************************************/
void FFTinit(fft_t *pFFT, UINT32 N) void FFTinit(fft_t *pFFT, uint32_t N)
{ {
pFFT->m_numPoints = 0; pFFT->m_numPoints = 0;
pFFT->m_numStages = 0; pFFT->m_numStages = 0;
@@ -32,8 +32,8 @@ void FFTinit(fft_t *pFFT, UINT32 N)
exit(1); exit(1);
} }
pFFT->m_numStages = (UINT32) (1e-06 + log((fft_float_t)N)/log(2.0)); pFFT->m_numStages = (uint32_t) (1e-06 + log((fft_float_t)N)/log(2.0));
pFFT->m_numPoints = (UINT32 )N; pFFT->m_numPoints = (uint32_t )N;
pFFT->pTwfRe = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2); pFFT->pTwfRe = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2);
pFFT->pTwfIm = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2); pFFT->pTwfIm = (fft_float_t*)malloc(pFFT->m_numPoints * sizeof(fft_float_t) /2);
@@ -76,11 +76,11 @@ void FFTfree(fft_t *pFFT)
/***************************************************************************/ /***************************************************************************/
void fft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im) void fft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{ {
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j; register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c; fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg #ifdef FFTMsg
UINT32 numMul, numAdd; uint32_t numMul, numAdd;
printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints); printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints);
#endif #endif
@@ -162,7 +162,7 @@ printf ("Total number of complex multiplications = %u\n",numMul);
/***************************************************************************/ /***************************************************************************/
void ifft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im) void ifft_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{ {
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j; register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c; fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg #ifdef FFTMsg
@@ -235,11 +235,11 @@ printf ("\n%d-Point IFFT is completed.\n",pFFT->m_numPoints);
/***************************************************************************/ /***************************************************************************/
void ffts_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im) void ffts_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im)
{ {
register UINT32 stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j; register uint32_t stageCnt, k, kk, twf, numNodesPerStage, nodeCnt, opsPerNode, opCnt, i, i2, j;
fft_float_t tempr, tempi, s, c; fft_float_t tempr, tempi, s, c;
#ifdef FFTMsg #ifdef FFTMsg
UINT32 numMul, numAdd; uint32_t numMul, numAdd;
printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints); printf ("\nStart %d-Point FFT.\n\n",pFFT->m_numPoints);
#endif #endif
@@ -319,9 +319,9 @@ printf ("Total number of complex multiplications = %u\n",numMul);
/* TWIDDLE-FAKTOR-TABLE */ /* TWIDDLE-FAKTOR-TABLE */
/* Erstellt Twiddle-Faktor-Tabelle von WN^0 bis WN^N/2 */ /* Erstellt Twiddle-Faktor-Tabelle von WN^0 bis WN^N/2 */
/***************************************************************************/ /***************************************************************************/
void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, UINT32 numPoints) void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, uint32_t numPoints)
{ {
UINT32 i, size; uint32_t i, size;
fft_float_t arg1; fft_float_t arg1;
size = numPoints/2; size = numPoints/2;
@@ -344,9 +344,9 @@ fft_float_t arg1;
/* MODULUS */ /* MODULUS */
/* Berechnet den Betrag einer komplexen Zahl */ /* Berechnet den Betrag einer komplexen Zahl */
/***************************************************************************/ /***************************************************************************/
void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N) void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N)
{ {
UINT32 i; uint32_t i;
fft_float_t temp; fft_float_t temp;
for (i = 0; i < N; i++) { for (i = 0; i < N; i++) {
@@ -359,9 +359,9 @@ fft_float_t temp;
/* Hanning */ /* Hanning */
/* Legt das Hanningfenster auf die Abtastwerte im Zeitbereich der Groesse N */ /* Legt das Hanningfenster auf die Abtastwerte im Zeitbereich der Groesse N */
/***************************************************************************/ /***************************************************************************/
void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N, UINT32 maximum) void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N, uint32_t maximum)
{ {
UINT32 n; uint32_t n;
fft_float_t arg; fft_float_t arg;
for (n=0; n < N; n++) for (n=0; n < N; n++)
@@ -374,9 +374,9 @@ void Hanning(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N, UINT32 ma
/***************************************************************************/ /***************************************************************************/
/* HANNING_K */ /* HANNING_K */
/* Gibt einen Faktor k in Abhängigkeit von n bezogen auf N zurück. */ /* Gibt einen Faktor k in Abh�ngigkeit von n bezogen auf N zur�ck. */
/***************************************************************************/ /***************************************************************************/
fft_float_t hanning_k(UINT32 n, UINT32 N) fft_float_t hanning_k(uint32_t n, uint32_t N)
{ {
fft_float_t arg; fft_float_t arg;
arg = (fft_float_t)(2 * PI / (fft_float_t)N); arg = (fft_float_t)(2 * PI / (fft_float_t)N);
@@ -386,9 +386,9 @@ return ((1-(fft_float_t)cos(arg*(fft_float_t)n))/2);
/***************************************************************************/ /***************************************************************************/
/* GAUSS_K */ /* GAUSS_K */
/* Gibt einen Faktor k in Abhängigkeit von n bezogen auf N zurück. */ /* Gibt einen Faktor k in Abh�ngigkeit von n bezogen auf N zur�ck. */
/***************************************************************************/ /***************************************************************************/
fft_float_t gauss_k(UINT32 n, UINT32 m, UINT32 s) fft_float_t gauss_k(uint32_t n, uint32_t m, uint32_t s)
{ {
fft_float_t arg; fft_float_t arg;
arg = (fft_float_t)((n-m)*(n-m)/(2*s*s)); arg = (fft_float_t)((n-m)*(n-m)/(2*s*s));
@@ -400,9 +400,9 @@ return (fft_float_t)(exp(-arg));
/* Normalize) */ /* Normalize) */
/* */ /* */
/***************************************************************************/ /***************************************************************************/
void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFactor, UINT32 N) void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFactor, uint32_t N)
{ {
UINT32 k; uint32_t k;
// Scaling Data // Scaling Data
for (k=0; k < N; k++) for (k=0; k < N; k++)
@@ -416,17 +416,17 @@ void Scale(fft_float_t *pRealData, fft_float_t *pImagData, fft_float_t scaleFact
/* BiPower() /* BiPower()
/* checks if N is power of 2 /* checks if N is power of 2
/***************************************************************************/ /***************************************************************************/
UINT32 IsPowerOfTwo(UINT32 N) uint32_t IsPowerOfTwo(uint32_t N)
{ {
UINT32 i, iterations; uint32_t i, iterations;
iterations = sizeof(UINT32)*8; iterations = sizeof(uint32_t)*8;
if (N == 0) if (N == 0)
return FFT_ERROR; return FFT_ERROR;
for (i=0; i <iterations; i++) for (i=0; i <iterations; i++)
{ {
if (N == (UINT32)(2 << i)) if (N == (uint32_t)(2 << i))
return 0; return 0;
} }
@@ -437,7 +437,7 @@ UINT32 IsPowerOfTwo(UINT32 N)
/* FFT2Dinit() /* FFT2Dinit()
/* /*
/***************************************************************************/ /***************************************************************************/
void FFT2Dinit(fft2_t *pFFT, UINT32 Nx, UINT32 Ny) void FFT2Dinit(fft2_t *pFFT, uint32_t Nx, uint32_t Ny)
{ {
pFFT->pXfft = NULL; pFFT->pXfft = NULL;
pFFT->pYfft = NULL; pFFT->pYfft = NULL;
@@ -486,7 +486,7 @@ void FFT2Dfree(fft2_t *pFFT)
void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag) void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
{ {
fft_float_t *pTempr, *pTempi; fft_float_t *pTempr, *pTempi;
UINT32 i, row; uint32_t i, row;
pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t)); pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t));
@@ -524,7 +524,7 @@ void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag) void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
{ {
fft_float_t *pTempr, *pTempi; fft_float_t *pTempr, *pTempi;
UINT32 i, row; uint32_t i, row;
pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t)); pTempr = (fft_float_t*)malloc(pFFT->m_Ny*sizeof(fft_float_t));
@@ -559,11 +559,11 @@ void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag)
/* DFT() /* DFT()
/* DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */ /* DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */
/***************************************************************************/ /***************************************************************************/
void DFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N) void DFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N)
{ {
fft_float_t *a, *b; fft_float_t *a, *b;
fft_float_t phi, c, s; fft_float_t phi, c, s;
UINT32 i, j; uint32_t i, j;
a = (fft_float_t*)malloc(N * sizeof(fft_float_t)); a = (fft_float_t*)malloc(N * sizeof(fft_float_t));
b = (fft_float_t*)malloc(N * sizeof(fft_float_t)); b = (fft_float_t*)malloc(N * sizeof(fft_float_t));
@@ -595,11 +595,11 @@ void DFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N)
/* IDFT() /* IDFT()
/* INVERSE DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */ /* INVERSE DISKRETE FOURIER-TRANSFORMATION S(f) -> s(t) */
/***************************************************************************/ /***************************************************************************/
void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N) void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N)
{ {
fft_float_t *a, *b; fft_float_t *a, *b;
fft_float_t phi, c, s; fft_float_t phi, c, s;
UINT32 i, j; uint32_t i, j;
a = (fft_float_t*)malloc(N * sizeof(fft_float_t)); a = (fft_float_t*)malloc(N * sizeof(fft_float_t));
b = (fft_float_t*)malloc(N * sizeof(fft_float_t)); b = (fft_float_t*)malloc(N * sizeof(fft_float_t));
src/fft.h
+20 -16
View File
@@ -3,54 +3,58 @@
/* Fast-Fourier-Transformation /* Fast-Fourier-Transformation
/* Author: Jens Ahrensfeld */ /* Author: Jens Ahrensfeld */
/* Datum : 24.06.1999 */ /* Datum : 24.06.1999 */
/* letzte Änderung: 09.06.2000 */ /* letzte �nderung: 09.06.2000 */
/***************************************************************************/ /***************************************************************************/
/* Tabellen und Funktionen für die FFT */ /* Tabellen und Funktionen f�r die FFT */
/***************************************************************************/ /***************************************************************************/
#ifndef FFT_H #ifndef FFT_H
#define FFT_H #define FFT_H
#define PI 3.1415926535897932384626433832795 #define PI 3.1415926535897932384626433832795
#define fft_float_t FLOAT32 #ifndef float32_t
#define float32_t float
#endif
#define fft_float_t float32_t
#define FFT_ERROR 0x80000000 #define FFT_ERROR 0x80000000
typedef struct _sfft_t typedef struct _sfft_t
{ {
UINT32 m_numPoints, m_numStages; uint32_t m_numPoints, m_numStages;
fft_float_t *pTwfRe, *pTwfIm; fft_float_t *pTwfRe, *pTwfIm;
} fft_t; } fft_t;
typedef struct _sfft2_t typedef struct _sfft2_t
{ {
fft_t *pXfft, *pYfft; fft_t *pXfft, *pYfft;
UINT32 m_Nx, m_Ny; uint32_t m_Nx, m_Ny;
} fft2_t; } fft2_t;
/* DFT functions */ /* DFT functions */
extern void DFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N); extern void DFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N);
extern void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, UINT32 N); extern void IDFT(fft_float_t *pDataR, fft_float_t *pDataI, uint32_t N);
/* FFT functions */ /* FFT functions */
extern void FFTinit(fft_t *pFFT, UINT32 N); extern void FFTinit(fft_t *pFFT, uint32_t N);
extern void FFTfree(fft_t *pFFT); extern void FFTfree(fft_t *pFFT);
extern void fft_inplace(fft_t *pFFT, fft_float_t*, fft_float_t*); extern void fft_inplace(fft_t *pFFT, fft_float_t*, fft_float_t*);
extern void ifft_inplace(fft_t *pFFT, fft_float_t*, fft_float_t*); extern void ifft_inplace(fft_t *pFFT, fft_float_t*, fft_float_t*);
extern void ffts_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im); extern void ffts_inplace(fft_t *pFFT, fft_float_t *in_re, fft_float_t *in_im);
extern void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, UINT32 numPoints); extern void FFTCalcTwiddleTable (fft_float_t *pRealData, fft_float_t *pImagData, uint32_t numPoints);
/* 2D FFT functions */ /* 2D FFT functions */
extern void FFT2Dinit(fft2_t *pFFT, UINT32 Nx, UINT32 Ny); extern void FFT2Dinit(fft2_t *pFFT, uint32_t Nx, uint32_t Ny);
extern void FFT2Dfree(fft2_t *pFFT); extern void FFT2Dfree(fft2_t *pFFT);
extern void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag); extern void fft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag);
extern void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag); extern void ifft2d_inplace(fft2_t *pFFT, fft_float_t **ppReal, fft_float_t **ppImag);
/* Helper functions */ /* Helper functions */
extern void Scale(fft_float_t *pRealData, fft_float_t *pImagData , fft_float_t scaleFactor, UINT32 N); extern void Scale(fft_float_t *pRealData, fft_float_t *pImagData , fft_float_t scaleFactor, uint32_t N);
extern void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N); extern void Modulus(fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N);
extern void Hanning (fft_float_t *pRealData, fft_float_t *pImagData, UINT32 N, UINT32 maximum); extern void Hanning (fft_float_t *pRealData, fft_float_t *pImagData, uint32_t N, uint32_t maximum);
extern fft_float_t hanning_k (UINT32, UINT32); extern fft_float_t hanning_k (uint32_t, uint32_t);
extern fft_float_t gauss_k(UINT32, UINT32, UINT32); extern fft_float_t gauss_k(uint32_t, uint32_t, uint32_t);
extern UINT32 IsPowerOfTwo(UINT32 N); extern uint32_t IsPowerOfTwo(uint32_t N);
#endif /* FFT_H */ #endif /* FFT_H */
src/fifo.h
+10 -10
View File
@@ -12,21 +12,21 @@
// --------------------------------------------------------- // ---------------------------------------------------------
typedef struct _sfifo_t typedef struct _sfifo_t
{ {
UINT32 size; uint32_t size;
UINT8 *pBuf; uint8_t *pBuf;
UINT8 * volatile pPtr_wr, * volatile pPtr_rd; uint8_t * volatile pPtr_wr, * volatile pPtr_rd;
} fifo_t; } fifo_t;
// --------------------------------------------------------- // ---------------------------------------------------------
// Functions // Functions
// --------------------------------------------------------- // ---------------------------------------------------------
UINT32 fifo_alloc(fifo_t *pObj, UINT32 size); uint32_t fifo_alloc(fifo_t *pObj, uint32_t size);
UINT32 fifo_free(fifo_t *pObj); uint32_t fifo_free(fifo_t *pObj);
UINT32 fifo_flush(fifo_t *pObj); uint32_t fifo_flush(fifo_t *pObj);
UINT32 fifo_is_full(fifo_t *pObj); uint32_t fifo_is_full(fifo_t *pObj);
UINT32 fifo_is_empty(fifo_t *pObj); uint32_t fifo_is_empty(fifo_t *pObj);
UINT32 fifo_read(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block); uint32_t fifo_read(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block);
UINT32 fifo_write(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block); uint32_t fifo_write(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block);
#endif // FIFO_H #endif // FIFO_H
src/gunzip.c
+3 -3
View File
@@ -19,8 +19,8 @@ volatile int file_len;
void handler3(void) void handler3(void)
{ {
volatile UINT32 *pUART_stat = (UINT32*)SYS_UART0_STAT; volatile uint32_t *pUART_stat = (uint32_t*)SYS_UART0_STAT;
volatile UINT32 *pUART_data = (UINT32*)SYS_UART0_DATA; volatile uint32_t *pUART_data = (uint32_t*)SYS_UART0_DATA;
while(0x200 & *pUART_stat) while(0x200 & *pUART_stat)
{ {
@@ -45,7 +45,7 @@ int READBYTE(z_stream *zs) {
#define MAX_BUFOUT 16*1024*1024 #define MAX_BUFOUT 16*1024*1024
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
volatile UINT32 *pUART_stat = (UINT32*)SYS_UART0_STAT; volatile uint32_t *pUART_stat = (uint32_t*)SYS_UART0_STAT;
unsigned char outData[MAX_BUFOUT]; unsigned char outData[MAX_BUFOUT];
FILE *infp; FILE *infp;
int i, gpflags, tmp[4]; int i, gpflags, tmp[4];
src/hpi.c
+83 -83
View File
@@ -6,9 +6,9 @@
#include "gpio.h" #include "gpio.h"
#include "hpi.h" #include "hpi.h"
static volatile UINT32 _g_int_active; static volatile uint32_t _g_int_active;
static volatile UINT32 _g_mbx_return; static volatile uint32_t _g_mbx_return;
static volatile UINT32 _g_mbx_in_flag; static volatile uint32_t _g_mbx_in_flag;
extern gpio_if_t _g_gpio; extern gpio_if_t _g_gpio;
@@ -48,9 +48,9 @@ static usb_t _g_usb[USB_MAX_NUM_PORTS];
// --------------------------------------------------------- // ---------------------------------------------------------
void cy67k3_isr(void) void cy67k3_isr(void)
{ {
INT32 i; int32_t i;
UINT16 sie_msg, hpi_status; uint16_t sie_msg, hpi_status;
UINT32 port, siemsg_handled, int_handled; uint32_t port, siemsg_handled, int_handled;
_g_int_active = 1; _g_int_active = 1;
hpi_status = cy67k3_read_HPI_STATUS(); hpi_status = cy67k3_read_HPI_STATUS();
@@ -318,69 +318,69 @@ void cy67k3_reset(void)
} }
UINT16 cy67k3_read_HPI_DATA(void) uint16_t cy67k3_read_HPI_DATA(void)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_DATA; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_DATA;
return (UINT16)*pHpi; return (uint16_t)*pHpi;
} }
UINT16 cy67k3_read_HPI_MAILBOX(void) uint16_t cy67k3_read_HPI_MAILBOX(void)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_MBX; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_MBX;
return (UINT16)*pHpi; return (uint16_t)*pHpi;
} }
UINT16 cy67k3_read_HPI_ADDRESS(void) uint16_t cy67k3_read_HPI_ADDRESS(void)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_ADDR; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_ADDR;
return (UINT16)*pHpi; return (uint16_t)*pHpi;
} }
UINT16 cy67k3_read_HPI_STATUS(void) uint16_t cy67k3_read_HPI_STATUS(void)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_STATUS; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_STATUS;
return (UINT16)*pHpi; return (uint16_t)*pHpi;
} }
void cy67k3_write_HPI_DATA(UINT16 data) void cy67k3_write_HPI_DATA(uint16_t data)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_DATA; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_DATA;
*pHpi = (UINT32)data; *pHpi = (uint32_t)data;
} }
void cy67k3_write_HPI_MAILBOX(UINT16 data) void cy67k3_write_HPI_MAILBOX(uint16_t data)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_MBX; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_MBX;
*pHpi = (UINT32)data; *pHpi = (uint32_t)data;
} }
void cy67k3_write_HPI_ADDRESS(UINT16 data) void cy67k3_write_HPI_ADDRESS(uint16_t data)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_ADDR; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_ADDR;
*pHpi = (UINT32)data; *pHpi = (uint32_t)data;
} }
void cy67k3_write_HPI_STATUS(UINT16 data) void cy67k3_write_HPI_STATUS(uint16_t data)
{ {
volatile UINT32 *pHpi = (UINT32*)SYS_USB_STATUS; volatile uint32_t *pHpi = (uint32_t*)SYS_USB_STATUS;
*pHpi = (UINT32)data; *pHpi = (uint32_t)data;
} }
// --------------------------------------------------------- // ---------------------------------------------------------
// HPI API // HPI API
// --------------------------------------------------------- // ---------------------------------------------------------
UINT32 hpi_init(void) uint32_t hpi_init(void)
{ {
int i; int i;
UINT16 reg; uint16_t reg;
// ToDo: Enable HPI interrupt // ToDo: Enable HPI interrupt
_g_int_active = 0; _g_int_active = 0;
@@ -424,16 +424,16 @@ UINT32 hpi_init(void)
return HPI_NOERROR; return HPI_NOERROR;
} }
void hpi_mbx_write(UINT16 msgcode) void hpi_mbx_write(uint16_t msgcode)
{ {
_g_mbx_in_flag = 0; _g_mbx_in_flag = 0;
cy67k3_write_HPI_MAILBOX(msgcode); cy67k3_write_HPI_MAILBOX(msgcode);
} }
UINT32 hpi_mbx_read(void) uint32_t hpi_mbx_read(void)
{ {
UINT32 err; uint32_t err;
UINT16 cy_return; uint16_t cy_return;
if (_g_int_active) if (_g_int_active)
{ {
@@ -464,7 +464,7 @@ UINT32 hpi_mbx_read(void)
return err; return err;
} }
UINT32 hpi_check_addr(UINT16 addr) uint32_t hpi_check_addr(uint16_t addr)
{ {
if ((addr >= 0x0000) && (addr < 0x4000)) if ((addr >= 0x0000) && (addr < 0x4000))
return 0; return 0;
@@ -479,9 +479,9 @@ UINT32 hpi_check_addr(UINT16 addr)
return HPI_ERR_INVPARAM; return HPI_ERR_INVPARAM;
} }
UINT32 hpi_read_reg(UINT16 addr) uint32_t hpi_read_reg(uint16_t addr)
{ {
UINT32 result; uint32_t result;
result = hpi_check_addr(addr); result = hpi_check_addr(addr);
if (IS_ERROR(result)) if (IS_ERROR(result))
@@ -491,9 +491,9 @@ UINT32 hpi_read_reg(UINT16 addr)
return cy67k3_read_HPI_DATA(); return cy67k3_read_HPI_DATA();
} }
UINT32 hpi_write_reg(UINT16 addr, UINT16 data) uint32_t hpi_write_reg(uint16_t addr, uint16_t data)
{ {
UINT32 result; uint32_t result;
result = hpi_check_addr(addr); result = hpi_check_addr(addr);
if (IS_ERROR(result)) if (IS_ERROR(result))
@@ -503,7 +503,7 @@ UINT32 hpi_write_reg(UINT16 addr, UINT16 data)
cy67k3_write_HPI_DATA(data); cy67k3_write_HPI_DATA(data);
} }
UINT32 hpi_write_ram(UINT16 addr, UINT16 *pData, UINT32 len) uint32_t hpi_write_ram(uint16_t addr, uint16_t *pData, uint32_t len)
{ {
int i, num_words; int i, num_words;
@@ -525,7 +525,7 @@ UINT32 hpi_write_ram(UINT16 addr, UINT16 *pData, UINT32 len)
return len; return len;
} }
UINT32 hpi_read_ram(UINT16 addr, UINT16 *pData, UINT32 len) uint32_t hpi_read_ram(uint16_t addr, uint16_t *pData, uint32_t len)
{ {
int i, num_words; int i, num_words;
@@ -547,14 +547,14 @@ UINT32 hpi_read_ram(UINT16 addr, UINT16 *pData, UINT32 len)
return len; return len;
} }
UINT32 hpi_comm_reset(void) uint32_t hpi_comm_reset(void)
{ {
hpi_mbx_write(COMM_RESET); hpi_mbx_write(COMM_RESET);
return hpi_mbx_read(); return hpi_mbx_read();
} }
UINT32 hpi_comm_jump2code(UINT16 addr) uint32_t hpi_comm_jump2code(uint16_t addr)
{ {
cy67k3_write_HPI_ADDRESS(addr); cy67k3_write_HPI_ADDRESS(addr);
hpi_mbx_write(COMM_JUMP2CODE); hpi_mbx_write(COMM_JUMP2CODE);
@@ -562,7 +562,7 @@ UINT32 hpi_comm_jump2code(UINT16 addr)
return hpi_mbx_read(); return hpi_mbx_read();
} }
UINT32 hpi_comm_callcode(UINT16 addr) uint32_t hpi_comm_callcode(uint16_t addr)
{ {
hpi_write_reg(COMM_CODE_ADDR, addr); hpi_write_reg(COMM_CODE_ADDR, addr);
@@ -571,7 +571,7 @@ UINT32 hpi_comm_callcode(UINT16 addr)
return hpi_mbx_read(); return hpi_mbx_read();
} }
UINT32 hpi_comm_write_ctrl_reg(UINT16 addr, UINT16 data, UINT16 logic) uint32_t hpi_comm_write_ctrl_reg(uint16_t addr, uint16_t data, uint16_t logic)
{ {
hpi_write_reg(COMM_CTRL_REG_ADDR, addr); hpi_write_reg(COMM_CTRL_REG_ADDR, addr);
@@ -583,9 +583,9 @@ UINT32 hpi_comm_write_ctrl_reg(UINT16 addr, UINT16 data, UINT16 logic)
return hpi_mbx_read(); return hpi_mbx_read();
} }
UINT32 hpi_comm_read_ctrl_reg(UINT16 addr) uint32_t hpi_comm_read_ctrl_reg(uint16_t addr)
{ {
UINT32 result; uint32_t result;
hpi_write_reg(COMM_CTRL_REG_ADDR, addr); hpi_write_reg(COMM_CTRL_REG_ADDR, addr);
@@ -596,17 +596,17 @@ UINT32 hpi_comm_read_ctrl_reg(UINT16 addr)
return result; return result;
cy67k3_write_HPI_ADDRESS(COMM_CTRL_REG_DATA); cy67k3_write_HPI_ADDRESS(COMM_CTRL_REG_DATA);
return (UINT32)cy67k3_read_HPI_DATA(); return (uint32_t)cy67k3_read_HPI_DATA();
} }
UINT32 hpi_comm_write_xmem(UINT16 addr, UINT8 *pData, UINT16 len) uint32_t hpi_comm_write_xmem(uint16_t addr, uint8_t *pData, uint16_t len)
{ {
return HPI_ERR_NOTIMPL; return HPI_ERR_NOTIMPL;
} }
UINT32 hpi_comm_read_xmem(UINT16 addr, UINT8 *pData, UINT16 len) uint32_t hpi_comm_read_xmem(uint16_t addr, uint8_t *pData, uint16_t len)
{ {
return HPI_ERR_NOTIMPL; return HPI_ERR_NOTIMPL;
@@ -614,15 +614,15 @@ UINT32 hpi_comm_read_xmem(UINT16 addr, UINT8 *pData, UINT16 len)
typedef struct _sreg_param_t typedef struct _sreg_param_t
{ {
UINT32 id; uint32_t id;
UINT16 val; uint16_t val;
} reg_param_t; } reg_param_t;
UINT32 hpi_comm_exec_int(UINT16 intnum, UINT32 nargs, ...) uint32_t hpi_comm_exec_int(uint16_t intnum, uint32_t nargs, ...)
{ {
int i; int i;
UINT32 result; uint32_t result;
va_list args; va_list args;
reg_param_t reg_param[MAX_NUM_REGS]; reg_param_t reg_param[MAX_NUM_REGS];
@@ -636,14 +636,14 @@ UINT32 hpi_comm_exec_int(UINT16 intnum, UINT32 nargs, ...)
for (i=0; i < nargs; i++) for (i=0; i < nargs; i++)
{ {
reg_param[i].id = va_arg(args, UINT32); reg_param[i].id = va_arg(args, uint32_t);
if (reg_param[i].id > MAX_NUM_REGS) if (reg_param[i].id > MAX_NUM_REGS)
{ {
fprintf(stderr, "hpi_comm_exec_int(): Invalid register R%d!\n", reg_param[i].id); fprintf(stderr, "hpi_comm_exec_int(): Invalid register R%d!\n", reg_param[i].id);
return HPI_ERR_INVPARAM; return HPI_ERR_INVPARAM;
} }
reg_param[i].val = (UINT16)va_arg(args, UINT32); reg_param[i].val = (uint16_t)va_arg(args, uint32_t);
} }
va_end(args); va_end(args);
@@ -660,12 +660,12 @@ UINT32 hpi_comm_exec_int(UINT16 intnum, UINT32 nargs, ...)
if (IS_ERROR(result)) if (IS_ERROR(result))
return result; return result;
return (UINT32)hpi_read_reg(COMM_R0); return (uint32_t)hpi_read_reg(COMM_R0);
} }
UINT32 usb_init(void) uint32_t usb_init(void)
{ {
INT32 i; int32_t i;
for (i=0; i < USB_MAX_NUM_PORTS; i++) for (i=0; i < USB_MAX_NUM_PORTS; i++)
{ {
@@ -674,9 +674,9 @@ UINT32 usb_init(void)
return 0; return 0;
} }
UINT32 usb_callback_register(UINT32 port, UINT32 type, fp_t pFunc, void *pArg) uint32_t usb_callback_register(uint32_t port, uint32_t type, fp_t pFunc, void *pArg)
{ {
UINT32 result; uint32_t result;
if (port >= USB_MAX_NUM_PORTS) if (port >= USB_MAX_NUM_PORTS)
return -1; return -1;
@@ -761,7 +761,7 @@ UINT32 usb_callback_register(UINT32 port, UINT32 type, fp_t pFunc, void *pArg)
return result; return result;
} }
UINT32 usb_irp_register(usb_irp_t *pIRP, UINT32 port, UINT32 ept, UINT32 size, UINT32 is_out) uint32_t usb_irp_register(usb_irp_t *pIRP, uint32_t port, uint32_t ept, uint32_t size, uint32_t is_out)
{ {
if (!pIRP) if (!pIRP)
@@ -792,9 +792,9 @@ UINT32 usb_irp_register(usb_irp_t *pIRP, UINT32 port, UINT32 ept, UINT32 size, U
return 0; return 0;
} }
UINT32 usb_irp_enqueue(usb_irp_t *pIRP) uint32_t usb_irp_enqueue(usb_irp_t *pIRP)
{ {
UINT32 result; uint32_t result;
if (!pIRP) if (!pIRP)
{ {
@@ -806,7 +806,7 @@ UINT32 usb_irp_enqueue(usb_irp_t *pIRP)
if (pIRP->is_out) if (pIRP->is_out)
{ {
hpi_write_ram(pIRP->cy_irp_addr, (UINT16*)&pIRP->cy_req, sizeof(cy_req_t)); hpi_write_ram(pIRP->cy_irp_addr, (uint16_t*)&pIRP->cy_req, sizeof(cy_req_t));
if (pIRP->port == 0) if (pIRP->port == 0)
result = hpi_comm_exec_int(SUSB1_RECEIVE_INT, 2, R1, pIRP->ept, R8, pIRP->cy_irp_addr); result = hpi_comm_exec_int(SUSB1_RECEIVE_INT, 2, R1, pIRP->ept, R8, pIRP->cy_irp_addr);
@@ -816,7 +816,7 @@ UINT32 usb_irp_enqueue(usb_irp_t *pIRP)
if (pIRP->is_in) if (pIRP->is_in)
{ {
pIRP->tx_in_progress = 1; pIRP->tx_in_progress = 1;
hpi_write_ram(pIRP->cy_irp_addr, (UINT16*)&pIRP->cy_req, sizeof(cy_req_t)); hpi_write_ram(pIRP->cy_irp_addr, (uint16_t*)&pIRP->cy_req, sizeof(cy_req_t));
if (pIRP->port == 0) if (pIRP->port == 0)
result = hpi_comm_exec_int(SUSB1_SEND_INT, 2, R1, pIRP->ept, R8, pIRP->cy_irp_addr); result = hpi_comm_exec_int(SUSB1_SEND_INT, 2, R1, pIRP->ept, R8, pIRP->cy_irp_addr);
@@ -831,15 +831,15 @@ UINT32 usb_irp_enqueue(usb_irp_t *pIRP)
} }
UINT32 fifo_alloc(fifo_t *pObj, UINT32 size) uint32_t fifo_alloc(fifo_t *pObj, uint32_t size)
{ {
pObj->pBuf = (UINT8*)malloc(size); pObj->pBuf = (uint8_t*)malloc(size);
if (!pObj->pBuf) if (!pObj->pBuf)
{ {
// printf ("fifo_alloc(): Error allocating memory!\n"); // printf ("fifo_alloc(): Error allocating memory!\n");
return -1; return -1;
} }
// printf ("fifo_alloc(): pBuf at %8.8X\n", (UINT32)pObj->pBuf); // printf ("fifo_alloc(): pBuf at %8.8X\n", (uint32_t)pObj->pBuf);
pObj->size = size; pObj->size = size;
pObj->pPtr_wr = pObj->pBuf; pObj->pPtr_wr = pObj->pBuf;
pObj->pPtr_rd = pObj->pBuf; pObj->pPtr_rd = pObj->pBuf;
@@ -847,7 +847,7 @@ UINT32 fifo_alloc(fifo_t *pObj, UINT32 size)
return 0; return 0;
} }
UINT32 fifo_free(fifo_t *pObj) uint32_t fifo_free(fifo_t *pObj)
{ {
if (pObj->pBuf) if (pObj->pBuf)
free(pObj->pBuf); free(pObj->pBuf);
@@ -855,7 +855,7 @@ UINT32 fifo_free(fifo_t *pObj)
return 0; return 0;
} }
UINT32 fifo_flush(fifo_t *pObj) uint32_t fifo_flush(fifo_t *pObj)
{ {
pObj->pPtr_wr = pObj->pBuf; pObj->pPtr_wr = pObj->pBuf;
pObj->pPtr_rd = pObj->pBuf; pObj->pPtr_rd = pObj->pBuf;
@@ -863,14 +863,14 @@ UINT32 fifo_flush(fifo_t *pObj)
return 0; return 0;
} }
UINT32 fifo_is_empty(fifo_t *pObj) uint32_t fifo_is_empty(fifo_t *pObj)
{ {
return (pObj->pPtr_wr == pObj->pPtr_rd); return (pObj->pPtr_wr == pObj->pPtr_rd);
} }
UINT32 fifo_is_full(fifo_t *pObj) uint32_t fifo_is_full(fifo_t *pObj)
{ {
UINT8 *pNext, *pEnd; uint8_t *pNext, *pEnd;
pEnd = pObj->pBuf + pObj->size; pEnd = pObj->pBuf + pObj->size;
pNext = pObj->pPtr_wr + 1; pNext = pObj->pPtr_wr + 1;
@@ -880,11 +880,11 @@ UINT32 fifo_is_full(fifo_t *pObj)
return (pNext == pObj->pPtr_rd); return (pNext == pObj->pPtr_rd);
} }
UINT32 fifo_read(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block) uint32_t fifo_read(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block)
{ {
UINT32 i; uint32_t i;
UINT32 wait_4ever, timeout_cnt, cnt; uint32_t wait_4ever, timeout_cnt, cnt;
UINT8 *pEnd; uint8_t *pEnd;
pEnd = pObj->pBuf + pObj->size; pEnd = pObj->pBuf + pObj->size;
wait_4ever = (timeout == 0); wait_4ever = (timeout == 0);
@@ -927,10 +927,10 @@ UINT32 fifo_read(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32
return cnt; return cnt;
} }
UINT32 fifo_write(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block) uint32_t fifo_write(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block)
{ {
UINT32 wait_4ever, timeout_cnt, cnt; uint32_t wait_4ever, timeout_cnt, cnt;
UINT8 *pEnd; uint8_t *pEnd;
pEnd = pObj->pBuf + pObj->size; pEnd = pObj->pBuf + pObj->size;
wait_4ever = (timeout == 0); wait_4ever = (timeout == 0);
src/hpi.h
+46 -46
View File
@@ -39,28 +39,28 @@ typedef void (*fp_t)(void*);
// Receive buffer on EP // Receive buffer on EP
typedef struct _scy_req_t typedef struct _scy_req_t
{ {
UINT16 next; uint16_t next;
UINT16 addr; uint16_t addr;
UINT16 size; uint16_t size;
UINT16 callback; uint16_t callback;
} cy_req_t; } cy_req_t;
typedef struct _sfifo_t typedef struct _sfifo_t
{ {
UINT32 size; uint32_t size;
UINT8 *pBuf; uint8_t *pBuf;
UINT8 * volatile pPtr_wr, * volatile pPtr_rd; uint8_t * volatile pPtr_wr, * volatile pPtr_rd;
} fifo_t; } fifo_t;
typedef struct _susb_irp_t typedef struct _susb_irp_t
{ {
UINT16 tsize; uint16_t tsize;
UINT32 is_in, is_out; uint32_t is_in, is_out;
UINT32 port, ept; uint32_t port, ept;
UINT16 cy_irp_addr; uint16_t cy_irp_addr;
fifo_t fifo; fifo_t fifo;
UINT32 tx_in_progress; uint32_t tx_in_progress;
cy_req_t cy_req; cy_req_t cy_req;
} usb_irp_t; } usb_irp_t;
@@ -339,46 +339,46 @@ typedef struct _susb_irp_t
// HPI low-level routines // HPI low-level routines
void cy67k3_isr(void); void cy67k3_isr(void);
void cy67k3_reset(void); void cy67k3_reset(void);
UINT16 cy67k3_read_HPI_DATA(void); uint16_t cy67k3_read_HPI_DATA(void);
UINT16 cy67k3_read_HPI_MAILBOX(void); uint16_t cy67k3_read_HPI_MAILBOX(void);
UINT16 cy67k3_read_HPI_ADDRESS(void); uint16_t cy67k3_read_HPI_ADDRESS(void);
UINT16 cy67k3_read_HPI_STATUS(void); uint16_t cy67k3_read_HPI_STATUS(void);
void cy67k3_write_HPI_DATA(UINT16 data); void cy67k3_write_HPI_DATA(uint16_t data);
void cy67k3_write_HPI_MAILBOX(UINT16 data); void cy67k3_write_HPI_MAILBOX(uint16_t data);
void cy67k3_write_HPI_ADDRESS(UINT16 data); void cy67k3_write_HPI_ADDRESS(uint16_t data);
void cy67k3_write_HPI_STATUS(UINT16 data); void cy67k3_write_HPI_STATUS(uint16_t data);
// HPI API // HPI API
UINT32 hpi_init(void); uint32_t hpi_init(void);
void hpi_mbx_write(UINT16 msgcode); void hpi_mbx_write(uint16_t msgcode);
UINT32 hpi_mbx_read(void); uint32_t hpi_mbx_read(void);
UINT32 hpi_read_reg(UINT16 addr); uint32_t hpi_read_reg(uint16_t addr);
UINT32 hpi_write_reg(UINT16 addr, UINT16 data); uint32_t hpi_write_reg(uint16_t addr, uint16_t data);
UINT32 hpi_write_ram(UINT16 addr, UINT16 *pData, UINT32 num_words); uint32_t hpi_write_ram(uint16_t addr, uint16_t *pData, uint32_t num_words);
UINT32 hpi_read_ram(UINT16 addr, UINT16 *pData, UINT32 num_words); uint32_t hpi_read_ram(uint16_t addr, uint16_t *pData, uint32_t num_words);
UINT32 hpi_comm_reset(void); uint32_t hpi_comm_reset(void);
UINT32 hpi_comm_jump2code(UINT16 addr); uint32_t hpi_comm_jump2code(uint16_t addr);
UINT32 hpi_comm_callcode(UINT16 addr); uint32_t hpi_comm_callcode(uint16_t addr);
UINT32 hpi_comm_write_ctrl_reg(UINT16 addr, UINT16 data, UINT16 logic); uint32_t hpi_comm_write_ctrl_reg(uint16_t addr, uint16_t data, uint16_t logic);
UINT32 hpi_comm_read_ctrl_reg(UINT16 addr); uint32_t hpi_comm_read_ctrl_reg(uint16_t addr);
UINT32 hpi_comm_write_xmem(UINT16 addr, UINT8 *pData, UINT16 len); uint32_t hpi_comm_write_xmem(uint16_t addr, uint8_t *pData, uint16_t len);
UINT32 hpi_comm_read_xmem(UINT16 addr, UINT8 *pData, UINT16 len); uint32_t hpi_comm_read_xmem(uint16_t addr, uint8_t *pData, uint16_t len);
UINT32 hpi_comm_exec_int(UINT16 intnum, UINT32 nargs, ...); uint32_t hpi_comm_exec_int(uint16_t intnum, uint32_t nargs, ...);
// USB API // USB API
UINT32 usb_init(void); uint32_t usb_init(void);
UINT32 usb_irp_register(usb_irp_t *pIRP, UINT32 port, UINT32 ept, UINT32 size, UINT32 is_out); uint32_t usb_irp_register(usb_irp_t *pIRP, uint32_t port, uint32_t ept, uint32_t size, uint32_t is_out);
UINT32 usb_irp_enqueue(usb_irp_t *pIRP); uint32_t usb_irp_enqueue(usb_irp_t *pIRP);
UINT32 usb_callback_register(UINT32 port, UINT32 type, fp_t pFunc, void *pArg); uint32_t usb_callback_register(uint32_t port, uint32_t type, fp_t pFunc, void *pArg);
#define FIFO_BLOCK 1 #define FIFO_BLOCK 1
#define FIFO_NONBLOCK 0 #define FIFO_NONBLOCK 0
UINT32 fifo_alloc(fifo_t *pObj, UINT32 size); uint32_t fifo_alloc(fifo_t *pObj, uint32_t size);
UINT32 fifo_free(fifo_t *pObj); uint32_t fifo_free(fifo_t *pObj);
UINT32 fifo_flush(fifo_t *pObj); uint32_t fifo_flush(fifo_t *pObj);
UINT32 fifo_is_full(fifo_t *pObj); uint32_t fifo_is_full(fifo_t *pObj);
UINT32 fifo_is_empty(fifo_t *pObj); uint32_t fifo_is_empty(fifo_t *pObj);
UINT32 fifo_read(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block); uint32_t fifo_read(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block);
UINT32 fifo_write(fifo_t *pObj, UINT8 *pData, UINT32 size, UINT32 timeout, UINT32 do_block); uint32_t fifo_write(fifo_t *pObj, uint8_t *pData, uint32_t size, uint32_t timeout, uint32_t do_block);
#endif // HPI_H #endif // HPI_H
src/jman/engine.c
+13 -13
View File
@@ -55,28 +55,28 @@ ri_var_t* V_CONSTANTWIDTH = NULL;
typedef struct _sjmalloc_t typedef struct _sjmalloc_t
{ {
UINT32 size; uint32_t size;
void* pMem; void* pMem;
struct _sjmalloc_t *pPrev; struct _sjmalloc_t *pPrev;
struct _sjmalloc_t *pNext; struct _sjmalloc_t *pNext;
} jmalloc_t; } jmalloc_t;
linkedlist_t *pMallocs = NULL; linkedlist_t *pMallocs = NULL;
UINT32 nmallocs = 0; uint32_t nmallocs = 0;
// Renderer functions // Renderer functions
void* jmalloc(UINT32 size) void* jmalloc(uint32_t size)
{ {
void *pMem; void *pMem;
pMem = malloc(size); pMem = malloc(size);
// pMallocs = LinkedList_add(pMallocs, (UINT32)pMem, (void*)&size, sizeof(void*)); // pMallocs = LinkedList_add(pMallocs, (uint32_t)pMem, (void*)&size, sizeof(void*));
nmallocs++; nmallocs++;
return pMem; return pMem;
} }
void jfree(void *pMem) void jfree(void *pMem)
{ {
// pMallocs = LinkedList_del(LinkedList_find_by_id(pMallocs, (UINT32)pMem)); // pMallocs = LinkedList_del(LinkedList_find_by_id(pMallocs, (uint32_t)pMem));
nmallocs--; nmallocs--;
free(pMem); free(pMem);
} }
@@ -84,11 +84,11 @@ void jfree(void *pMem)
void jstats() void jstats()
{ {
linkedlist_t *pList; linkedlist_t *pList;
UINT32 n= 0, size = 0; uint32_t n= 0, size = 0;
pList = LinkedList_find_first(pMallocs); pList = LinkedList_find_first(pMallocs);
while(pList) while(pList)
{ {
size += (UINT32)pList->size; size += (uint32_t)pList->size;
pList = pList->pNext; pList = pList->pNext;
n++; n++;
} }
@@ -174,12 +174,12 @@ void Engine_free(engine_t *pObj)
} }
void Engine_context_set(engine_t *pObj, UINT32 context, UINT32 level) void Engine_context_set(engine_t *pObj, uint32_t context, uint32_t level)
{ {
pObj->pContext[level] = context; pObj->pContext[level] = context;
} }
UINT32 Engine_context_get(engine_t *pObj, UINT32 level) uint32_t Engine_context_get(engine_t *pObj, uint32_t level)
{ {
if (!pObj->pContext) if (!pObj->pContext)
return ENGINE_CONTEXT_INVALID; return ENGINE_CONTEXT_INVALID;
@@ -207,7 +207,7 @@ void Engine_Render(engine_t *pObj)
object_t *pMesh; object_t *pMesh;
object_t *pObject; object_t *pObject;
RtFloat kf, fi; RtFloat kf, fi;
UINT32 im_width, im_height, x, y, i, j; uint32_t im_width, im_height, x, y, i, j;
image_t im; image_t im;
rgba_t *pCs; rgba_t *pCs;
double tictoc; double tictoc;
@@ -215,8 +215,8 @@ void Engine_Render(engine_t *pObj)
Tic(&tictoc); Tic(&tictoc);
kf = (RtFloat)pG->pOpt->format.xres/(pG->pOpt->format.yres*pG->pOpt->format.ar_f); kf = (RtFloat)pG->pOpt->format.xres/(pG->pOpt->format.yres*pG->pOpt->format.ar_f);
im_width = (UINT32)pG->pOpt->format.xres; im_width = (uint32_t)pG->pOpt->format.xres;
im_height = (UINT32)(kf*pG->pOpt->format.yres + 0.5); im_height = (uint32_t)(kf*pG->pOpt->format.yres + 0.5);
if (pG->pOpt->display.mode == RI_RGBA) if (pG->pOpt->display.mode == RI_RGBA)
ImageInit(&im, im_width, im_height, 4); ImageInit(&im, im_width, im_height, 4);
@@ -359,7 +359,7 @@ void Engine_DeleteScene(engine_t *pObj)
// -------------------------------------------------------------- // --------------------------------------------------------------
void Engine_SceneInfo(engine_t *pObj) void Engine_SceneInfo(engine_t *pObj)
{ {
UINT32 num_verts = 0, num_objects = 0; uint32_t num_verts = 0, num_objects = 0;
linkedlist_t *pObjList; linkedlist_t *pObjList;
polygon_t *pPoly; polygon_t *pPoly;
object_t *pObject; object_t *pObject;
src/jman/engine.h
+4 -4
View File
@@ -31,7 +31,7 @@ extern ri_var_t* V_ST;
extern ri_var_t* V_WIDTH; extern ri_var_t* V_WIDTH;
extern ri_var_t* V_CONSTANTWIDTH; extern ri_var_t* V_CONSTANTWIDTH;
typedef UINT32 context_t; typedef uint32_t context_t;
typedef struct _sengine_t typedef struct _sengine_t
{ {
@@ -50,8 +50,8 @@ typedef struct _sengine_t
// JayMan functions // JayMan functions
void Engine_init(engine_t *pObj, RtToken name); void Engine_init(engine_t *pObj, RtToken name);
void Engine_free(engine_t *pObj); void Engine_free(engine_t *pObj);
void Engine_context_set(engine_t *pObj, UINT32 context, UINT32 level); void Engine_context_set(engine_t *pObj, uint32_t context, uint32_t level);
UINT32 Engine_context_get(engine_t *pObj, UINT32 level); uint32_t Engine_context_get(engine_t *pObj, uint32_t level);
void Engine_context_push(engine_t *pObj); void Engine_context_push(engine_t *pObj);
void Engine_context_pop(engine_t *pObj); void Engine_context_pop(engine_t *pObj);
@@ -59,7 +59,7 @@ void Engine_Render(engine_t *pObj);
void Engine_DeleteScene(engine_t *pObj); void Engine_DeleteScene(engine_t *pObj);
void Engine_SceneInfo(engine_t *pObj); void Engine_SceneInfo(engine_t *pObj);
void* jmalloc(UINT32 size); void* jmalloc(uint32_t size);
void jfree(void *pMem); void jfree(void *pMem);
void jstats(void); void jstats(void);
src/jman/graph_state.c
+2 -2
View File
@@ -14,7 +14,7 @@ static char RI_DEFAULT_FILNAME[] = "ri.pic";
// Graphics state functions // Graphics state functions
void GS_init(graph_state_t *pObj) void GS_init(graph_state_t *pObj)
{ {
UINT32 i; uint32_t i;
pObj->pAttr_stack = Stack_push(NULL, &pObj->pAttr, sizeof(attr_t)); pObj->pAttr_stack = Stack_push(NULL, &pObj->pAttr, sizeof(attr_t));
pObj->pOpt_stack = Stack_push(NULL, &pObj->pOpt, sizeof(opt_t)); pObj->pOpt_stack = Stack_push(NULL, &pObj->pOpt, sizeof(opt_t));
@@ -95,7 +95,7 @@ void GS_xform_pop(graph_state_t *pObj)
GS_xform_set(pObj, pObj->curr_xform); GS_xform_set(pObj, pObj->curr_xform);
} }
void GS_xform_set(graph_state_t *pObj, UINT32 id) void GS_xform_set(graph_state_t *pObj, uint32_t id)
{ {
pObj->curr_xform = id; pObj->curr_xform = id;
pObj->pXform_curr = &pObj->pXform->space[id]; pObj->pXform_curr = &pObj->pXform->space[id];
src/jman/graph_state.h
+5 -5
View File
@@ -22,7 +22,7 @@ typedef struct _sprojection_t
{ {
RtToken type; RtToken type;
RtFloat fov; RtFloat fov;
UINT32 flags; uint32_t flags;
} projection_t; } projection_t;
@@ -64,9 +64,9 @@ typedef struct _sxform_t
typedef struct _sgraph_state_t typedef struct _sgraph_state_t
{ {
UINT32 frame; uint32_t frame;
UINT32 context; uint32_t context;
UINT32 curr_xform; uint32_t curr_xform;
opt_t *pOpt; opt_t *pOpt;
attr_t *pAttr; attr_t *pAttr;
xform_t *pXform; xform_t *pXform;
@@ -90,7 +90,7 @@ void GS_attr_push(graph_state_t *pObj);
void GS_attr_pop(graph_state_t *pObj); void GS_attr_pop(graph_state_t *pObj);
void GS_xform_push(graph_state_t *pObj); void GS_xform_push(graph_state_t *pObj);
void GS_xform_pop(graph_state_t *pObj); void GS_xform_pop(graph_state_t *pObj);
void GS_xform_set(graph_state_t *pObj, UINT32 id); void GS_xform_set(graph_state_t *pObj, uint32_t id);
#endif // GRAPH_STATE_H #endif // GRAPH_STATE_H
src/jman/grid.c
+9 -8
View File
@@ -1,3 +1,4 @@
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
@@ -10,9 +11,9 @@
#include "graph_state.h" #include "graph_state.h"
#include "object.h" #include "object.h"
void Grid_create(grid_t *pObj, UINT32 npu, UINT32 npv) void Grid_create(grid_t *pObj, uint32_t npu, uint32_t npv)
{ {
UINT32 i, j, k, nu, nv; uint32_t i, j, k, nu, nv;
ri_var_t *pVar; ri_var_t *pVar;
nu = npu + 1; nu = npu + 1;
@@ -105,7 +106,7 @@ void Grid_CopyVarByName(grid_t *pObj, RtToken pDstName, RtToken pSrcName)
void Grid_InitUV(grid_t *pObj) void Grid_InitUV(grid_t *pObj)
{ {
UINT32 i, j, k, nu, nv; uint32_t i, j, k, nu, nv;
RtFloat *pU, *pV, u, v, du, dv; RtFloat *pU, *pV, u, v, du, dv;
ri_var_t *pVar; ri_var_t *pVar;
@@ -146,7 +147,7 @@ void Grid_InitUV(grid_t *pObj)
void Grid_assign_derivs(grid_t *pObj) void Grid_assign_derivs(grid_t *pObj)
{ {
UINT32 i, j, k, nu, nv; uint32_t i, j, k, nu, nv;
RtPoint *pPoint, *pDPDU, *pDPDV, dpd2; RtPoint *pPoint, *pDPDU, *pDPDV, dpd2;
RtFloat du, dv, ik; RtFloat du, dv, ik;
ri_var_t *pVar; ri_var_t *pVar;
@@ -202,7 +203,7 @@ void Grid_assign_derivs(grid_t *pObj)
void Grid_calc_normal(grid_t *pObj, RtToken name) void Grid_calc_normal(grid_t *pObj, RtToken name)
{ {
UINT32 i; uint32_t i;
RtFloat *a, *b; RtFloat *a, *b;
RtPoint *pPoint, *pDPDU, *pDPDV, *pN; RtPoint *pPoint, *pDPDU, *pDPDV, *pN;
@@ -224,7 +225,7 @@ void Grid_calc_normal(grid_t *pObj, RtToken name)
void Grid_displace(grid_t *pObj) void Grid_displace(grid_t *pObj)
{ {
UINT32 i, j, k; uint32_t i, j, k;
RtPoint *pP, *pDPDU, *pDPDV, *pN; RtPoint *pP, *pDPDU, *pDPDV, *pN;
RtColor *pCs, *pCi; RtColor *pCs, *pCi;
RtFloat *pU, *pV, fd, kn, kd; RtFloat *pU, *pV, fd, kn, kd;
@@ -351,7 +352,7 @@ RtFloat* Specular(linkedlist_t *pLightList, RtPoint N, RtPoint P, RtPoint I, RtF
void Grid_shade(grid_t *pObj, RtMatrix *pXform, linkedlist_t *pLights) void Grid_shade(grid_t *pObj, RtMatrix *pXform, linkedlist_t *pLights)
{ {
UINT32 i, j, k; uint32_t i, j, k;
RtPoint *pP, *pDPDU, *pDPDV, *pN, *pI; RtPoint *pP, *pDPDU, *pDPDV, *pN, *pI;
RtColor *pCs, *pCi; RtColor *pCs, *pCi;
RtFloat *pU, *pV, fd, kn, vt, p[4], d[4], *pCl_diff, *pCl_spec; RtFloat *pU, *pV, fd, kn, vt, p[4], d[4], *pCl_diff, *pCl_spec;
@@ -391,7 +392,7 @@ void Grid_shade(grid_t *pObj, RtMatrix *pXform, linkedlist_t *pLights)
void Grid_shadeConstant(grid_t *pObj) void Grid_shadeConstant(grid_t *pObj)
{ {
UINT32 i; uint32_t i;
RtColor *pCs, *pCi; RtColor *pCs, *pCi;
pCs = (RtColor*)VarGetByName(&pObj->vars, "Cs"); pCs = (RtColor*)VarGetByName(&pObj->vars, "Cs");
src/jman/grid.h
+8 -8
View File
@@ -3,18 +3,18 @@
typedef struct _spoint_state_t typedef struct _spoint_state_t
{ {
UINT32 active; uint32_t active;
UINT32 shaded; uint32_t shaded;
UINT32 visible; uint32_t visible;
UINT32 has_face; uint32_t has_face;
UINT32 has_normal; uint32_t has_normal;
} point_state_t; } point_state_t;
typedef UINT32 pixelpos_t[2]; typedef uint32_t pixelpos_t[2];
typedef struct _sgrid_t typedef struct _sgrid_t
{ {
UINT32 nu, nv, npoints; uint32_t nu, nv, npoints;
var_list_t vars; var_list_t vars;
pixelpos_t *pPointPos; pixelpos_t *pPointPos;
point_state_t *pPointState; point_state_t *pPointState;
@@ -23,7 +23,7 @@ typedef struct _sgrid_t
void Grid_init(void); void Grid_init(void);
void Grid_free(grid_t *pObj); void Grid_free(grid_t *pObj);
void Grid_create(grid_t *pObj, UINT32 nu, UINT32 nv); void Grid_create(grid_t *pObj, uint32_t nu, uint32_t nv);
void Grid_assign_params(grid_t *pObj); void Grid_assign_params(grid_t *pObj);
void Grid_assign_derivs(grid_t *pObj); void Grid_assign_derivs(grid_t *pObj);
void Grid_calc_Ng(grid_t *pObj); void Grid_calc_Ng(grid_t *pObj);
src/jman/imageio.c
+18 -18
View File
@@ -39,16 +39,16 @@ void ImageInit(image_t *pObj, int im_width, int im_height, int num_ch)
pObj->im_width = im_width; pObj->im_width = im_width;
pObj->num_ch = num_ch; pObj->num_ch = num_ch;
pObj->num_pixel = im_height*im_width; pObj->num_pixel = im_height*im_width;
volatile UINT32 *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; volatile uint32_t *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
volatile UINT32 *pVGA_front = (UINT32*)SYS_VGA_FB_FRONT; volatile uint32_t *pVGA_front = (uint32_t*)SYS_VGA_FB_FRONT;
volatile UINT32 *pVGA_back = (UINT32*)SYS_VGA_FB_BACK; volatile uint32_t *pVGA_back = (uint32_t*)SYS_VGA_FB_BACK;
pObj->pColor_data = (UINT64*)jmalloc(pObj->num_pixel*sizeof(UINT32)); pObj->pColor_data = (uint64_t*)jmalloc(pObj->num_pixel*sizeof(uint32_t));
memset(pObj->pColor_data, 0, pObj->num_pixel*sizeof(UINT32)); memset(pObj->pColor_data, 0, pObj->num_pixel*sizeof(uint32_t));
printf("pPixelBuf : %8.8X\n", (UINT32)pObj->pColor_data); printf("pPixelBuf : %8.8X\n", (uint32_t)pObj->pColor_data);
*pVGA_front = (UINT32)pObj->pColor_data; *pVGA_front = (uint32_t)pObj->pColor_data;
*pVGA_back = (UINT32)pObj->pColor_data; *pVGA_back = (uint32_t)pObj->pColor_data;
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
} }
@@ -99,29 +99,29 @@ int ImageSaveTiff(image_t *pObj, char *filename)
} }
void ImageSetPixel(image_t *pObj, UINT32 u, UINT32 v, rgba_t color) void ImageSetPixel(image_t *pObj, uint32_t u, uint32_t v, rgba_t color)
{ {
UINT32 offset; uint32_t offset;
UINT32 *pRGB; uint32_t *pRGB;
UINT32 *pRGBA; uint32_t *pRGBA;
pRGB = (UINT32*)pObj->pColor_data; pRGB = (uint32_t*)pObj->pColor_data;
pRGBA = (UINT32*)pObj->pColor_data; pRGBA = (uint32_t*)pObj->pColor_data;
if (pObj->num_ch == 4) if (pObj->num_ch == 4)
{ {
if ((u < pObj->im_width) && (v < pObj->im_height)) if ((u < pObj->im_width) && (v < pObj->im_height))
{ {
offset = (UINT32)(pObj->im_width*v); offset = (uint32_t)(pObj->im_width*v);
pRGBA[u+offset] = ((UINT32)(255*color[0]) & 0xFF) | (((UINT32)(255*color[1]) & 0xFF) << 8) | (((UINT32)(255*color[2]) & 0xFF) << 16); pRGBA[u+offset] = ((uint32_t)(255*color[0]) & 0xFF) | (((uint32_t)(255*color[1]) & 0xFF) << 8) | (((uint32_t)(255*color[2]) & 0xFF) << 16);
} }
} }
else else
{ {
if ((u < pObj->im_width) && (v < pObj->im_height)) if ((u < pObj->im_width) && (v < pObj->im_height))
{ {
offset = (UINT32)(pObj->im_width*v); offset = (uint32_t)(pObj->im_width*v);
pRGB[u+offset] = ((UINT32)(255*color[0]) & 0xFF) | (((UINT32)(255*color[1]) & 0xFF) << 8) | (((UINT32)(255*color[2]) & 0xFF) << 16); pRGB[u+offset] = ((uint32_t)(255*color[0]) & 0xFF) | (((uint32_t)(255*color[1]) & 0xFF) << 8) | (((uint32_t)(255*color[2]) & 0xFF) << 16);
} }
} }
src/jman/imageio.h
+3 -3
View File
@@ -15,8 +15,8 @@
// ------------------------------------------------------------ // ------------------------------------------------------------
typedef struct _image_t typedef struct _image_t
{ {
UINT32 im_width, im_height, num_pixel, num_ch; uint32_t im_width, im_height, num_pixel, num_ch;
UINT64 *pColor_data; uint64_t *pColor_data;
} image_t; } image_t;
@@ -27,7 +27,7 @@ void ImageFree(image_t *pObj);
void ImageCopy(image_t *pSrc, image_t *pDst); void ImageCopy(image_t *pSrc, image_t *pDst);
int ImageLoadTiff(image_t *pObj, char *filename); int ImageLoadTiff(image_t *pObj, char *filename);
int ImageSaveTiff(image_t *pObj, char *filename); int ImageSaveTiff(image_t *pObj, char *filename);
void ImageSetPixel(image_t *pObj, UINT32 u, UINT32 v, rgba_t color); void ImageSetPixel(image_t *pObj, uint32_t u, uint32_t v, rgba_t color);
// ------------------------------------------------------------ // ------------------------------------------------------------
#endif // IMAGEIO_H #endif // IMAGEIO_H
src/jman/linklist.c
+7 -7
View File
@@ -15,9 +15,9 @@ linkedlist_t* LinkedList_free(linkedlist_t *pObj)
return pCurr; return pCurr;
} }
linkedlist_t* LinkedList_append(linkedlist_t *pObj, UINT32 num, UINT32 size) linkedlist_t* LinkedList_append(linkedlist_t *pObj, uint32_t num, uint32_t size)
{ {
UINT32 i; uint32_t i;
linkedlist_t *pCurr, *pLast; linkedlist_t *pCurr, *pLast;
char *pData = NULL; char *pData = NULL;
@@ -60,7 +60,7 @@ linkedlist_t* LinkedList_append(linkedlist_t *pObj, UINT32 num, UINT32 size)
} }
/* /*
linkedlist_t* LinkedList_append(linkedlist_t *pObj, UINT32 id, UINT32 size) linkedlist_t* LinkedList_append(linkedlist_t *pObj, uint32_t id, uint32_t size)
{ {
linkedlist_t *pCurr; linkedlist_t *pCurr;
@@ -90,7 +90,7 @@ linkedlist_t* LinkedList_append(linkedlist_t *pObj, UINT32 id, UINT32 size)
} }
*/ */
linkedlist_t* LinkedList_add(linkedlist_t *pObj, UINT32 num, void *pData, UINT32 size) linkedlist_t* LinkedList_add(linkedlist_t *pObj, uint32_t num, void *pData, uint32_t size)
{ {
linkedlist_t *pCurr; linkedlist_t *pCurr;
@@ -100,7 +100,7 @@ linkedlist_t* LinkedList_add(linkedlist_t *pObj, UINT32 num, void *pData, UINT32
} }
linkedlist_t* LinkedList_put(linkedlist_t *pObj, void *pData, UINT32 size) linkedlist_t* LinkedList_put(linkedlist_t *pObj, void *pData, uint32_t size)
{ {
linkedlist_t *pCurr; linkedlist_t *pCurr;
@@ -162,7 +162,7 @@ linkedlist_t* LinkedList_del(linkedlist_t *pObj)
return pCurr; return pCurr;
} }
linkedlist_t* LinkedList_ins(linkedlist_t *pObj, UINT32 num, void *pData, UINT32 size) linkedlist_t* LinkedList_ins(linkedlist_t *pObj, uint32_t num, void *pData, uint32_t size)
{ {
linkedlist_t *pCurr, *pNext; linkedlist_t *pCurr, *pNext;
@@ -212,7 +212,7 @@ linkedlist_t* LinkedList_find_last(linkedlist_t *pObj)
return pCurr; return pCurr;
} }
/* /*
linkedlist_t* LinkedList_find_by_id(linkedlist_t *pObj, UINT32 id) linkedlist_t* LinkedList_find_by_id(linkedlist_t *pObj, uint32_t id)
{ {
linkedlist_t *pCurr; linkedlist_t *pCurr;
src/jman/linklist.h
+6 -6
View File
@@ -7,8 +7,8 @@
typedef struct _slinkedlist_t typedef struct _slinkedlist_t
{ {
UINT32 id; uint32_t id;
UINT32 size; uint32_t size;
void *pData; void *pData;
struct _slinkedlist_t *pNext; struct _slinkedlist_t *pNext;
struct _slinkedlist_t *pPrev; struct _slinkedlist_t *pPrev;
@@ -16,10 +16,10 @@ typedef struct _slinkedlist_t
} linkedlist_t; } linkedlist_t;
linkedlist_t* LinkedList_free(linkedlist_t *pObj); linkedlist_t* LinkedList_free(linkedlist_t *pObj);
linkedlist_t* LinkedList_append(linkedlist_t *pObj, UINT32 num, UINT32 size); linkedlist_t* LinkedList_append(linkedlist_t *pObj, uint32_t num, uint32_t size);
linkedlist_t* LinkedList_add(linkedlist_t *pObj, UINT32 num, void *pData, UINT32 size); linkedlist_t* LinkedList_add(linkedlist_t *pObj, uint32_t num, void *pData, uint32_t size);
linkedlist_t* LinkedList_put(linkedlist_t *pObj, void *pData, UINT32 size); linkedlist_t* LinkedList_put(linkedlist_t *pObj, void *pData, uint32_t size);
linkedlist_t* LinkedList_ins(linkedlist_t *pObj, UINT32 num, void *pData, UINT32 size); linkedlist_t* LinkedList_ins(linkedlist_t *pObj, uint32_t num, void *pData, uint32_t size);
void* LinkedList_get(linkedlist_t *pObj); void* LinkedList_get(linkedlist_t *pObj);
linkedlist_t* LinkedList_del(linkedlist_t *pObj); linkedlist_t* LinkedList_del(linkedlist_t *pObj);
linkedlist_t* LinkedList_find_first(linkedlist_t *pObj); linkedlist_t* LinkedList_find_first(linkedlist_t *pObj);
src/jman/matrix.c
+16 -16
View File
@@ -54,9 +54,9 @@
// Ausgabe einer nxn-Matrix // Ausgabe einer nxn-Matrix
void PrintMatrix (RtMatrix M, UINT32 d) void PrintMatrix (RtMatrix M, uint32_t d)
{ {
UINT32 i,j; uint32_t i,j;
printf("\n"); printf("\n");
for (i=0;i<d;++i) for (i=0;i<d;++i)
{ {
@@ -69,9 +69,9 @@ void PrintMatrix (RtMatrix M, UINT32 d)
} }
// Ausgabe eines Vektors in Zeilenform // Ausgabe eines Vektors in Zeilenform
void PrintVector (RtFloat *u, UINT32 d) void PrintVector (RtFloat *u, uint32_t d)
{ {
UINT32 i; uint32_t i;
printf("\n\t ( "); printf("\n\t ( ");
for (i=0;i<d-1;++i) for (i=0;i<d-1;++i)
printf("%g, ",fabs(u[i])<min?0:u[i]); printf("%g, ",fabs(u[i])<min?0:u[i]);
@@ -80,9 +80,9 @@ void PrintVector (RtFloat *u, UINT32 d)
// Berechnung des Skalarprodukts <.,.> zwischen zwei Vektoren u, v; // Berechnung des Skalarprodukts <.,.> zwischen zwei Vektoren u, v;
// <u,v> = u[1]*v[1] + u[2]*v[2] + ... + u[n]*v[n] // <u,v> = u[1]*v[1] + u[2]*v[2] + ... + u[n]*v[n]
RtFloat ScalarProduct (RtFloat *u, RtFloat *v, UINT32 d) RtFloat ScalarProduct (RtFloat *u, RtFloat *v, uint32_t d)
{ {
UINT32 i; uint32_t i;
RtFloat s=0.0; RtFloat s=0.0;
for (i=0;i<d;++i) for (i=0;i<d;++i)
s += u[i]*v[i]; s += u[i]*v[i];
@@ -90,7 +90,7 @@ RtFloat ScalarProduct (RtFloat *u, RtFloat *v, UINT32 d)
} }
// Berechnung des Betrags eines Vektors // Berechnung des Betrags eines Vektors
RtFloat Norm (RtFloat *u, UINT32 d) RtFloat Norm (RtFloat *u, uint32_t d)
{ {
RtFloat m; RtFloat m;
m = (RtFloat)sqrt(ScalarProduct(u,u,d)); m = (RtFloat)sqrt(ScalarProduct(u,u,d));
@@ -100,7 +100,7 @@ RtFloat Norm (RtFloat *u, UINT32 d)
// Berechnung des Winkels zwischen zwei Vektoren u, v. // Berechnung des Winkels zwischen zwei Vektoren u, v.
// Verfahren: cos(u,v) = <u,v>/(|u|*|v|), wobei <.,.> das Skalarprodukt // Verfahren: cos(u,v) = <u,v>/(|u|*|v|), wobei <.,.> das Skalarprodukt
// zwischen zwei Vektoren und |.| der Betrag eines Vektors sind. // zwischen zwei Vektoren und |.| der Betrag eines Vektors sind.
RtFloat AngleBetweenVectors (RtFloat *u, RtFloat *v, UINT32 d) RtFloat AngleBetweenVectors (RtFloat *u, RtFloat *v, uint32_t d)
{ {
RtFloat p; RtFloat p;
p = (RtFloat)acos(ScalarProduct(u,v,d)/(Norm(u,d)*Norm(v,d))); p = (RtFloat)acos(ScalarProduct(u,v,d)/(Norm(u,d)*Norm(v,d)));
@@ -111,7 +111,7 @@ RtFloat AngleBetweenVectors (RtFloat *u, RtFloat *v, UINT32 d)
// Liefert die Einheitsmatrix in Id zurueck. // Liefert die Einheitsmatrix in Id zurueck.
void IdentityMatrix (RtMatrix *Id) void IdentityMatrix (RtMatrix *Id)
{ {
UINT32 i,j; uint32_t i,j;
for (i=0;i<4;++i) for (i=0;i<4;++i)
for (j=0;j<4;++j) for (j=0;j<4;++j)
(*Id)[i][j] = (RtFloat)(i==j); (*Id)[i][j] = (RtFloat)(i==j);
@@ -121,7 +121,7 @@ void IdentityMatrix (RtMatrix *Id)
// Das Ergebnis der Multiplikation von M und N steht in der Matrix MN. // Das Ergebnis der Multiplikation von M und N steht in der Matrix MN.
void MultiplyMatrices (RtMatrix M, RtMatrix N, RtMatrix *MN) void MultiplyMatrices (RtMatrix M, RtMatrix N, RtMatrix *MN)
{ {
INT32 i,j; int32_t i,j;
for (i=0; i<4; i++) for (i=0; i<4; i++)
{ {
for (j=0; j<4; j++) for (j=0; j<4; j++)
@@ -138,7 +138,7 @@ void MultiplyMatrices (RtMatrix M, RtMatrix N, RtMatrix *MN)
// Multiplikation einer 4x4-Matrix M und eines Spaltenvektors u // Multiplikation einer 4x4-Matrix M und eines Spaltenvektors u
void MultiplyMatrixVector (RtMatrix M, RtFloat *u, RtFloat *Mu) void MultiplyMatrixVector (RtMatrix M, RtFloat *u, RtFloat *Mu)
{ {
INT32 i; int32_t i;
for (i=0; i<4; i++) for (i=0; i<4; i++)
{ {
@@ -152,7 +152,7 @@ void MultiplyMatrixVector (RtMatrix M, RtFloat *u, RtFloat *Mu)
void MultiplyMatrixVector2 (RtMatrix M, RtFloat *u, RtFloat *Mu) void MultiplyMatrixVector2 (RtMatrix M, RtFloat *u, RtFloat *Mu)
{ {
INT32 i; int32_t i;
RtFloat res[3]; RtFloat res[3];
for (i=0; i < 3; i++) for (i=0; i < 3; i++)
@@ -168,7 +168,7 @@ void MultiplyMatrixVector2 (RtMatrix M, RtFloat *u, RtFloat *Mu)
// Multiplikation eines Zeilenvektors u und einer 4x4-Matrix M // Multiplikation eines Zeilenvektors u und einer 4x4-Matrix M
void MultiplyVectorMatrix (RtFloat *u, RtMatrix M, RtFloat *uM) void MultiplyVectorMatrix (RtFloat *u, RtMatrix M, RtFloat *uM)
{ {
INT32 i; int32_t i;
for (i=0;i<4;++i) for (i=0;i<4;++i)
{ {
@@ -183,7 +183,7 @@ void MultiplyVectorMatrix (RtFloat *u, RtMatrix M, RtFloat *uM)
// Transponieren einer 4x4-Matrix M; Mt: transponierte Matrix M // Transponieren einer 4x4-Matrix M; Mt: transponierte Matrix M
void TransposeMatrix (RtMatrix M, RtMatrix *Mt) void TransposeMatrix (RtMatrix M, RtMatrix *Mt)
{ {
INT32 i; int32_t i;
for (i=0; i<4; i++) for (i=0; i<4; i++)
{ {
(*Mt)[i][0] = M[0][i]; (*Mt)[i][0] = M[0][i];
@@ -208,7 +208,7 @@ void NewTranslationMatrix (RtFloat *tval, RtMatrix *T)
// Berechnung der Rotationsmatrix R aus M (Verfahren s. oben) // Berechnung der Rotationsmatrix R aus M (Verfahren s. oben)
void RotationMatrix (RtMatrix M, RtMatrix *R) void RotationMatrix (RtMatrix M, RtMatrix *R)
{ {
UINT32 i; uint32_t i;
for (i=0; i<4; i++) for (i=0; i<4; i++)
{ {
(*R)[i][0] = M[i][0]; (*R)[i][0] = M[i][0];
@@ -241,7 +241,7 @@ void InverseRotationMatrix (RtMatrix R, RtMatrix *Ri)
// (Verfahren s. oben) // (Verfahren s. oben)
void InverseTranslationMatrix (RtMatrix T, RtMatrix *Ti) void InverseTranslationMatrix (RtMatrix T, RtMatrix *Ti)
{ {
UINT32 i; uint32_t i;
//printf("T = "); PrintMatrix(T); //printf("T = "); PrintMatrix(T);
IdentityMatrix (Ti); IdentityMatrix (Ti);
for (i=0;i<3;++i) for (i=0;i<3;++i)
src/jman/object.c
+14 -14
View File
@@ -34,9 +34,9 @@ void Interpolate_linear_u(RtPoint P0, RtPoint P1, RtPoint* pP, RtFloat u)
} }
void Interpolate_linear(RtPoint P0, RtPoint P1, RtPoint *pP, UINT32 N) void Interpolate_linear(RtPoint P0, RtPoint P1, RtPoint *pP, uint32_t N)
{ {
UINT32 i; uint32_t i;
RtFloat dx, dy, dz, fx, fy, fz; RtFloat dx, dy, dz, fx, fy, fz;
fx = P0[0]; fx = P0[0];
@@ -55,13 +55,13 @@ void Interpolate_linear(RtPoint P0, RtPoint P1, RtPoint *pP, UINT32 N)
} }
RtInt Interpolate_cubic(RtPoint *pCP, UINT32 ncp, RtPoint *pIP, UINT32 nip, RtFloat umin, RtFloat umax, RtPointer Basis, RtInt step, RtInt dimcp) RtInt Interpolate_cubic(RtPoint *pCP, uint32_t ncp, RtPoint *pIP, uint32_t nip, RtFloat umin, RtFloat umax, RtPointer Basis, RtInt step, RtInt dimcp)
{ {
UINT32 i, j, jj, k, d, n, np; uint32_t i, j, jj, k, d, n, np;
RtFloat Bi[3][4], p[4], ut, u, du; RtFloat Bi[3][4], p[4], ut, u, du;
RtFloat *B = (RtFloat*)Basis; RtFloat *B = (RtFloat*)Basis;
INT32 ii; int32_t ii;
np = (ncp-4)/step + 1; np = (ncp-4)/step + 1;
@@ -102,7 +102,7 @@ RtInt Interpolate_cubic(RtPoint *pCP, UINT32 ncp, RtPoint *pIP, UINT32 nip, RtFl
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Polygon_init(object_t *pObj, UINT32 id, UINT32 nvertices) void Polygon_init(object_t *pObj, uint32_t id, uint32_t nvertices)
{ {
polygon_t *pObject; polygon_t *pObject;
ri_var_t *pVar; ri_var_t *pVar;
@@ -142,7 +142,7 @@ void Polygon_dice(object_t *pObj, RtInt npu, RtInt npv)
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Curve_init(object_t *pObj, UINT32 id, RtToken degree, RtInt nverts, RtToken wrap) void Curve_init(object_t *pObj, uint32_t id, RtToken degree, RtInt nverts, RtToken wrap)
{ {
curve_t *pObject; curve_t *pObject;
@@ -180,7 +180,7 @@ void Curve_bound_update(object_t *pObj)
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Patch_init(object_t *pObj, UINT32 id, RtToken type) void Patch_init(object_t *pObj, uint32_t id, RtToken type)
{ {
patch_t *pObject; patch_t *pObject;
@@ -300,7 +300,7 @@ void Patch_dice(object_t *pObj, RtInt npu, RtInt npv)
void Patch_bound_update(object_t *pObj) void Patch_bound_update(object_t *pObj)
{ {
UINT32 i, j, npoints; uint32_t i, j, npoints;
patch_t *pObject; patch_t *pObject;
RtPoint *pPoints; RtPoint *pPoints;
@@ -328,7 +328,7 @@ void Patch_bound_update(object_t *pObj)
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Patchmesh_init(object_t *pObj, UINT32 id, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, RtPointer pVerts) void Patchmesh_init(object_t *pObj, uint32_t id, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, RtPointer pVerts)
{ {
patchmesh_t *pObject; patchmesh_t *pObject;
ri_var_t *pVar; ri_var_t *pVar;
@@ -365,7 +365,7 @@ void Patchmesh_free(object_t *pObj)
void Patchmesh_get_patch(object_t *pObj, object_t *pDst, RtInt ip) void Patchmesh_get_patch(object_t *pObj, object_t *pDst, RtInt ip)
{ {
UINT32 i, j, k, npu, npv; uint32_t i, j, k, npu, npv;
RtInt x1, y1; RtInt x1, y1;
patch_t *pPatch; patch_t *pPatch;
ri_var_t *pVar; ri_var_t *pVar;
@@ -460,7 +460,7 @@ RtInt Patchmesh_get_npatches(object_t *pObj, RtInt *nupatches, RtInt *nvpatches)
void Patchmesh_bound_update(object_t *pObj) void Patchmesh_bound_update(object_t *pObj)
{ {
UINT32 i, j, m, n, N; uint32_t i, j, m, n, N;
patchmesh_t *pObject; patchmesh_t *pObject;
RtPoint *pPoints; RtPoint *pPoints;
object_t *pMesh; object_t *pMesh;
@@ -505,7 +505,7 @@ void Patchmesh_bound_update(object_t *pObj)
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Sphere_init(object_t *pObj, UINT32 id, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax) void Sphere_init(object_t *pObj, uint32_t id, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax)
{ {
sphere_t *pObject; sphere_t *pObject;
@@ -634,7 +634,7 @@ void Sphere_free(object_t *pObj)
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Light_init(object_t *pObj, UINT32 id) void Light_init(object_t *pObj, uint32_t id)
{ {
light_t *pObject; light_t *pObject;
src/jman/object.h
+23 -23
View File
@@ -18,36 +18,36 @@ extern RtToken OBJECT_TYPE_CURVE;
// -------------------------------------------------------------- // --------------------------------------------------------------
typedef struct _sstat_t typedef struct _sstat_t
{ {
UINT32 num_polygons; uint32_t num_polygons;
UINT32 num_patches; uint32_t num_patches;
UINT32 num_patchmeshes; uint32_t num_patchmeshes;
UINT32 num_lights; uint32_t num_lights;
UINT32 num_spheres; uint32_t num_spheres;
UINT32 num_curves; uint32_t num_curves;
} stat_t; } stat_t;
typedef struct _sscene_t typedef struct _sscene_t
{ {
stat_t stat; stat_t stat;
UINT32 num_objs; uint32_t num_objs;
linkedlist_t *pObjs; linkedlist_t *pObjs;
} scene_t; } scene_t;
typedef struct _spolygon_t typedef struct _spolygon_t
{ {
UINT32 id; uint32_t id;
UINT32 num_verts; uint32_t num_verts;
} polygon_t; } polygon_t;
typedef struct _scurve_t typedef struct _scurve_t
{ {
UINT32 id; uint32_t id;
RtToken type; RtToken type;
RtToken wrap; RtToken wrap;
UINT32 nverts; uint32_t nverts;
RtFloat width[2]; RtFloat width[2];
RtPointer pVerts; RtPointer pVerts;
@@ -55,14 +55,14 @@ typedef struct _scurve_t
typedef struct _spatch_t typedef struct _spatch_t
{ {
UINT32 id; uint32_t id;
RtToken type; RtToken type;
} patch_t; } patch_t;
typedef struct _spatchmesh_t typedef struct _spatchmesh_t
{ {
UINT32 id; uint32_t id;
RtInt nu, nv; RtInt nu, nv;
RtToken type; RtToken type;
RtToken uwrap, vwrap; RtToken uwrap, vwrap;
@@ -71,14 +71,14 @@ typedef struct _spatchmesh_t
typedef struct _slight_t typedef struct _slight_t
{ {
UINT32 id; uint32_t id;
RtBoolean onoff; RtBoolean onoff;
} light_t; } light_t;
typedef struct _ssphere_t typedef struct _ssphere_t
{ {
UINT32 id, is_full_sweep; uint32_t id, is_full_sweep;
RtFloat radius, zmin, zmax; RtFloat radius, zmin, zmax;
RtFloat phi_min, phi_max, theta_max; RtFloat phi_min, phi_max, theta_max;
@@ -95,8 +95,8 @@ typedef struct _sobj_stat_t
typedef struct _sobject_t typedef struct _sobject_t
{ {
UINT32 id; uint32_t id;
UINT32 main_context; uint32_t main_context;
RtToken type; RtToken type;
void *pObjData; void *pObjData;
RtMatrix *pXform; RtMatrix *pXform;
@@ -108,32 +108,32 @@ typedef struct _sobject_t
} object_t; } object_t;
void Polygon_init(object_t *pObj, UINT32 id, UINT32 nvertices); void Polygon_init(object_t *pObj, uint32_t id, uint32_t nvertices);
void Polygon_free(object_t *pObj); void Polygon_free(object_t *pObj);
void Polygon_dice(object_t *pObj, RtInt npu, RtInt npv); void Polygon_dice(object_t *pObj, RtInt npu, RtInt npv);
void Polygon_bound_update(object_t *pObj); void Polygon_bound_update(object_t *pObj);
void Curve_init(object_t *pObj, UINT32 id, RtToken degree, RtInt nverts, RtToken wrap); void Curve_init(object_t *pObj, uint32_t id, RtToken degree, RtInt nverts, RtToken wrap);
void Curve_free(object_t *pObj); void Curve_free(object_t *pObj);
void Curve_bound_update(object_t *pObj); void Curve_bound_update(object_t *pObj);
void Patch_init(object_t *pObj, UINT32 id, RtToken type); void Patch_init(object_t *pObj, uint32_t id, RtToken type);
void Patch_free(object_t *pObj); void Patch_free(object_t *pObj);
void Patch_dice(object_t *pObj, RtInt npu, RtInt npv); void Patch_dice(object_t *pObj, RtInt npu, RtInt npv);
void Patch_bound_update(object_t *pObj); void Patch_bound_update(object_t *pObj);
void Patchmesh_init(object_t *pObj, UINT32 id, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, RtPointer pVerts); void Patchmesh_init(object_t *pObj, uint32_t id, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, RtPointer pVerts);
void Patchmesh_free(object_t *pObj); void Patchmesh_free(object_t *pObj);
void Patchmesh_get_patch(object_t *pObj, object_t *pDst, RtInt ip); void Patchmesh_get_patch(object_t *pObj, object_t *pDst, RtInt ip);
RtInt Patchmesh_get_npatches(object_t *pObj, RtInt *nupatches, RtInt *nvpatches); RtInt Patchmesh_get_npatches(object_t *pObj, RtInt *nupatches, RtInt *nvpatches);
void Patchmesh_bound_update(object_t *pObj); void Patchmesh_bound_update(object_t *pObj);
void Sphere_init(object_t *pObj, UINT32 id, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax); void Sphere_init(object_t *pObj, uint32_t id, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax);
void Sphere_free(object_t *pObj); void Sphere_free(object_t *pObj);
void Sphere_dice(object_t *pObj, RtInt npu, RtInt npv); void Sphere_dice(object_t *pObj, RtInt npu, RtInt npv);
void Sphere_bound_update(object_t *pObj); void Sphere_bound_update(object_t *pObj);
void Light_init(object_t *pObj, UINT32 id); void Light_init(object_t *pObj, uint32_t id);
void Light_free(object_t *pObj); void Light_free(object_t *pObj);
void Scene_Add(scene_t *pObj, object_t *pObject); void Scene_Add(scene_t *pObj, object_t *pObject);
src/jman/render.c
+37 -37
View File
@@ -24,15 +24,15 @@ int sgn(int x)
{ {
return (x>0)-(x<0); return (x>0)-(x<0);
} }
typedef UINT32 point2D_t[2]; typedef uint32_t point2D_t[2];
typedef struct _spoint2Dz_t typedef struct _spoint2Dz_t
{ {
UINT32 x, y; uint32_t x, y;
double z; double z;
} point2Dz_t; } point2Dz_t;
UINT32 Bresenham(image_t *pIm, color_t cs, UINT32 *P0, UINT32 *P1, point2D_t *pPixels) uint32_t Bresenham(image_t *pIm, color_t cs, uint32_t *P0, uint32_t *P1, point2D_t *pPixels)
#define JMIN(a,b) ((a)<(b)?(a):(b)) #define JMIN(a,b) ((a)<(b)?(a):(b))
#define JMAX(a,b) ((a)>(b)?(a):(b)) #define JMAX(a,b) ((a)>(b)?(a):(b))
@@ -42,7 +42,7 @@ UINT32 Bresenham(image_t *pIm, color_t cs, UINT32 *P0, UINT32 *P1, point2D_t *pP
/*-------------------------------------------------------------- /*--------------------------------------------------------------
* Bresenham-Algorithmus: Linien auf Rastergeräten zeichnen * Bresenham-Algorithmus: Linien auf Rasterger�ten zeichnen
* *
* Eingabeparameter: * Eingabeparameter:
* P0 = Koordinaten des Startpunkts * P0 = Koordinaten des Startpunkts
@@ -54,7 +54,7 @@ UINT32 Bresenham(image_t *pIm, color_t cs, UINT32 *P0, UINT32 *P1, point2D_t *pP
*--------------------------------------------------------------- *---------------------------------------------------------------
*/ */
{ {
UINT32 count; uint32_t count;
int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err; int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;
@@ -86,7 +86,7 @@ UINT32 Bresenham(image_t *pIm, color_t cs, UINT32 *P0, UINT32 *P1, point2D_t *pP
if(dx<0) dx = -dx; if(dx<0) dx = -dx;
if(dy<0) dy = -dy; if(dy<0) dy = -dy;
/* feststellen, welche Entfernung größer ist */ /* feststellen, welche Entfernung gr��er ist */
if (dx>dy) if (dx>dy)
{ {
/* x ist schnelle Richtung */ /* x ist schnelle Richtung */
@@ -141,7 +141,7 @@ UINT32 Bresenham(image_t *pIm, color_t cs, UINT32 *P0, UINT32 *P1, point2D_t *pP
void RenderWire_polygon(render_t *pObj, object_t *pObject) void RenderWire_polygon(render_t *pObj, object_t *pObject)
{ {
RtMatrix world2cam; RtMatrix world2cam;
UINT32 i, j, cnt; uint32_t i, j, cnt;
rgba_t cs = {0}, cs_first; rgba_t cs = {0}, cs_first;
polygon_t *pPoly; polygon_t *pPoly;
RtPoint *pVerts; RtPoint *pVerts;
@@ -149,7 +149,7 @@ void RenderWire_polygon(render_t *pObj, object_t *pObject)
point2D_t *pPxl; point2D_t *pPxl;
RtFloat d[4], uv[2], p[4], dn; RtFloat d[4], uv[2], p[4], dn;
UINT32 b[2], b_first[2], b_prev[2]; uint32_t b[2], b_first[2], b_prev[2];
pPxl = (point2D_t*)malloc((pObj->pImage->im_height+pObj->pImage->im_width)*sizeof(point2D_t)); pPxl = (point2D_t*)malloc((pObj->pImage->im_height+pObj->pImage->im_width)*sizeof(point2D_t));
@@ -187,8 +187,8 @@ void RenderWire_polygon(render_t *pObj, object_t *pObject)
dn = (RtFloat)(1.0/d[2]); dn = (RtFloat)(1.0/d[2]);
uv[0] = pObj->ku*d[0]*dn; uv[0] = pObj->ku*d[0]*dn;
uv[1] = pObj->kv*d[1]*dn; uv[1] = pObj->kv*d[1]*dn;
b[0] = (UINT32)(pObj->pImage->im_width*(uv[0]+0.5)); b[0] = (uint32_t)(pObj->pImage->im_width*(uv[0]+0.5));
b[1] = (UINT32)(pObj->pImage->im_height*(uv[1]+0.5)); b[1] = (uint32_t)(pObj->pImage->im_height*(uv[1]+0.5));
if (i > 0) if (i > 0)
{ {
cnt = Bresenham(pObj->pImage, cs, b_prev, b, pPxl); cnt = Bresenham(pObj->pImage, cs, b_prev, b, pPxl);
@@ -216,14 +216,14 @@ void RenderWire_polygon(render_t *pObj, object_t *pObject)
void RenderGridPoints(render_t *pObj, object_t *pObject) void RenderGridPoints(render_t *pObj, object_t *pObject)
{ {
UINT32 i; uint32_t i;
RtMatrix world2cam; RtMatrix world2cam;
rgba_t cs = {1,1,1,1}; rgba_t cs = {1,1,1,1};
RtPoint *pPoint; RtPoint *pPoint;
RtColor *pColor; RtColor *pColor;
RtFloat d[4], uv[2], p[4], dn; RtFloat d[4], uv[2], p[4], dn;
UINT32 b[2]; uint32_t b[2];
MultiplyMatrices(pObj->pG->pXform->space[camera_space], *pObject->pXform, &world2cam); MultiplyMatrices(pObj->pG->pXform->space[camera_space], *pObject->pXform, &world2cam);
i=0; i=0;
@@ -244,16 +244,16 @@ void RenderGridPoints(render_t *pObj, object_t *pObject)
dn = (RtFloat)(1.0/d[2]); dn = (RtFloat)(1.0/d[2]);
uv[0] = pObj->ku*d[0]*dn; uv[0] = pObj->ku*d[0]*dn;
uv[1] = pObj->kv*d[1]*dn; uv[1] = pObj->kv*d[1]*dn;
b[0] = (UINT32)(pObj->pImage->im_width*(uv[0]+0.5)); b[0] = (uint32_t)(pObj->pImage->im_width*(uv[0]+0.5));
b[1] = (UINT32)(pObj->pImage->im_height*(uv[1]+0.5)); b[1] = (uint32_t)(pObj->pImage->im_height*(uv[1]+0.5));
ImageSetPixel(pObj->pImage, b[0], b[1], cs); ImageSetPixel(pObj->pImage, b[0], b[1], cs);
} }
} }
typedef struct _sedge_t typedef struct _sedge_t
{ {
INT32 xa, xb, ya, yb; int32_t xa, xb, ya, yb;
INT32 xmin, xmax, ymin, ymax; int32_t xmin, xmax, ymin, ymax;
RtFloat mi, b; RtFloat mi, b;
double za, zb, dz; double za, zb, dz;
} edge_t; } edge_t;
@@ -264,9 +264,9 @@ typedef struct _sactive_edge_t
} active_edge_t; } active_edge_t;
void edge_sort(edge_t *pEdges, edge_t **ppEdges, UINT32 nedges) void edge_sort(edge_t *pEdges, edge_t **ppEdges, uint32_t nedges)
{ {
UINT32 swapped, i; uint32_t swapped, i;
void *pTmp; void *pTmp;
for (i=0; i < nedges; i++) for (i=0; i < nedges; i++)
@@ -291,8 +291,8 @@ void edge_sort(edge_t *pEdges, edge_t **ppEdges, UINT32 nedges)
void RenderGridPatchesFilled(render_t *pObj, object_t *pObject) void RenderGridPatchesFilled(render_t *pObj, object_t *pObject)
{ {
UINT32 i, j, x, y, cnt, ii, jj, win, swapped, offset; uint32_t i, j, x, y, cnt, ii, jj, win, swapped, offset;
INT32 ymin, ymax, xmin, xmax, ys, xs, tmp; int32_t ymin, ymax, xmin, xmax, ys, xs, tmp;
RtMatrix world2cam; RtMatrix world2cam;
rgba_t cs = {1,1,1,1}; rgba_t cs = {1,1,1,1};
@@ -398,8 +398,8 @@ void RenderGridPatchesFilled(render_t *pObj, object_t *pObject)
dn = (RtFloat)1/z; dn = (RtFloat)1/z;
uv[0] = pObj->ku*(*ppVert[j])[0]*dn; uv[0] = pObj->ku*(*ppVert[j])[0]*dn;
uv[1] = pObj->kv*(*ppVert[j])[1]*dn; uv[1] = pObj->kv*(*ppVert[j])[1]*dn;
pPxl[j].x = (UINT32)(pObj->pImage->im_width*(uv[0]+0.5)); pPxl[j].x = (uint32_t)(pObj->pImage->im_width*(uv[0]+0.5));
pPxl[j].y = (UINT32)(pObj->pImage->im_height*(uv[1]+0.5)); pPxl[j].y = (uint32_t)(pObj->pImage->im_height*(uv[1]+0.5));
pPxl[j].z = z; pPxl[j].z = z;
} }
@@ -598,7 +598,7 @@ void RenderGridPatchesFilled(render_t *pObj, object_t *pObject)
void RenderGridPatches(render_t *pObj, object_t *pObject) void RenderGridPatches(render_t *pObj, object_t *pObject)
{ {
UINT32 i, j, x, y, cnt, offset; uint32_t i, j, x, y, cnt, offset;
RtMatrix world2cam; RtMatrix world2cam;
rgba_t cs = {1,1,1,1}; rgba_t cs = {1,1,1,1};
RtPoint *pPoint, *ppVert[4], *pPx; RtPoint *pPoint, *ppVert[4], *pPx;
@@ -609,7 +609,7 @@ void RenderGridPatches(render_t *pObj, object_t *pObject)
edge_t edges[4]; edge_t edges[4];
RtFloat d[4], uv[2], p[4], dn; RtFloat d[4], uv[2], p[4], dn;
UINT32 b[2], b_first[2], b_prev[2]; uint32_t b[2], b_first[2], b_prev[2];
double z, z_first, z_prev, dz, zn; double z, z_first, z_prev, dz, zn;
double tictoc; double tictoc;
@@ -704,8 +704,8 @@ void RenderGridPatches(render_t *pObj, object_t *pObject)
dn = (RtFloat)1/z; dn = (RtFloat)1/z;
uv[0] = pObj->ku*(*ppVert[j])[0]*dn; uv[0] = pObj->ku*(*ppVert[j])[0]*dn;
uv[1] = pObj->kv*(*ppVert[j])[1]*dn; uv[1] = pObj->kv*(*ppVert[j])[1]*dn;
b[0] = (UINT32)(pObj->pImage->im_width*(uv[0]+0.5)); b[0] = (uint32_t)(pObj->pImage->im_width*(uv[0]+0.5));
b[1] = (UINT32)(pObj->pImage->im_height*(uv[1]+0.5)); b[1] = (uint32_t)(pObj->pImage->im_height*(uv[1]+0.5));
if (j > 0) if (j > 0)
{ {
cnt = Bresenham(pObj->pImage, cs, b_prev, b, pPxl); cnt = Bresenham(pObj->pImage, cs, b_prev, b, pPxl);
@@ -751,7 +751,7 @@ void Render_calc_pixel_coverage(render_t *pObj, object_t *pObject, RtFloat *nx,
RtMatrix world2cam; RtMatrix world2cam;
RtFloat xmin, xmax, ymin, ymax; RtFloat xmin, xmax, ymin, ymax;
RtFloat d[4], uv[2], p[4], dn; RtFloat d[4], uv[2], p[4], dn;
UINT32 i; uint32_t i;
RtPoint pVerts[8]; RtPoint pVerts[8];
@@ -809,7 +809,7 @@ void Render_calc_pixel_coverage(render_t *pObj, object_t *pObject, RtFloat *nx,
void RenderBound(render_t *pObj, object_t *pObject) void RenderBound(render_t *pObj, object_t *pObject)
{ {
RtMatrix world2cam; RtMatrix world2cam;
UINT32 i; uint32_t i;
rgba_t cs = {0}; rgba_t cs = {0};
polygon_t *pPoly; polygon_t *pPoly;
RtPoint *pVerts; RtPoint *pVerts;
@@ -922,15 +922,15 @@ void RenderBound(render_t *pObj, object_t *pObject)
void Render_patchmesh(render_t *pObj, object_t *pObject) void Render_patchmesh(render_t *pObj, object_t *pObject)
{ {
UINT32 i, j, m, n, M, N; uint32_t i, j, m, n, M, N;
object_t patch; object_t patch;
RtFloat nx, ny; RtFloat nx, ny;
Patchmesh_bound_update(pObject); Patchmesh_bound_update(pObject);
Render_calc_pixel_coverage(pObj, pObject, &nx, &ny); Render_calc_pixel_coverage(pObj, pObject, &nx, &ny);
M = (UINT32)(nx/pObject->pAttr->shadingrate); M = (uint32_t)(nx/pObject->pAttr->shadingrate);
N = (UINT32)(ny/pObject->pAttr->shadingrate); N = (uint32_t)(ny/pObject->pAttr->shadingrate);
Patchmesh_get_npatches(pObject, &m, &n); Patchmesh_get_npatches(pObject, &m, &n);
@@ -955,7 +955,7 @@ void Render_patchmesh(render_t *pObj, object_t *pObject)
void Render_sphere(render_t *pObj, object_t *pObject) void Render_sphere(render_t *pObj, object_t *pObject)
{ {
UINT32 i, j, M, N; uint32_t i, j, M, N;
RtFloat nx, ny, ngx, ngy; RtFloat nx, ny, ngx, ngy;
Sphere_bound_update(pObject); Sphere_bound_update(pObject);
@@ -963,8 +963,8 @@ void Render_sphere(render_t *pObj, object_t *pObject)
ngx = nx / 16; ngx = nx / 16;
ngy = ny / 16; ngy = ny / 16;
M = (UINT32)(PI*ny/pObject->pAttr->shadingrate); M = (uint32_t)(PI*ny/pObject->pAttr->shadingrate);
N = (UINT32)(1.42*nx/pObject->pAttr->shadingrate); N = (uint32_t)(1.42*nx/pObject->pAttr->shadingrate);
Sphere_dice(pObject, M, N); Sphere_dice(pObject, M, N);
#ifdef RENDER_POINTS #ifdef RENDER_POINTS
@@ -978,15 +978,15 @@ void Render_sphere(render_t *pObj, object_t *pObject)
void Render_patch(render_t *pObj, object_t *pObject) void Render_patch(render_t *pObj, object_t *pObject)
{ {
UINT32 i, j, M, N; uint32_t i, j, M, N;
object_t patch, *pObject2; object_t patch, *pObject2;
RtFloat nx, ny; RtFloat nx, ny;
Patch_bound_update(pObject); Patch_bound_update(pObject);
Render_calc_pixel_coverage(pObj, pObject, &nx, &ny); Render_calc_pixel_coverage(pObj, pObject, &nx, &ny);
M = (UINT32)(nx/pObject->pAttr->shadingrate); M = (uint32_t)(nx/pObject->pAttr->shadingrate);
N = (UINT32)(ny/pObject->pAttr->shadingrate); N = (uint32_t)(ny/pObject->pAttr->shadingrate);
Patch_dice(pObject, M, N); Patch_dice(pObject, M, N);
#ifdef RENDER_POINTS #ifdef RENDER_POINTS
src/jman/ri.c
+9 -9
View File
@@ -112,7 +112,7 @@ RtVoid RiEnd (void)
// -------------------------------------------------------------- // --------------------------------------------------------------
RtVoid RiFrameBegin (RtInt number) RtVoid RiFrameBegin (RtInt number)
{ {
UINT32 i; uint32_t i;
if (Engine_context_get(&engine, ENGINE_CONTEXT_LEVEL_MAIN) == ENGINE_CONTEXT_INVALID) if (Engine_context_get(&engine, ENGINE_CONTEXT_LEVEL_MAIN) == ENGINE_CONTEXT_INVALID)
{ {
@@ -291,7 +291,7 @@ RtVoid RiTransformEnd (void)
// -------------------------------------------------------------- // --------------------------------------------------------------
RtToken RiDeclare (char *name, char *declaration) RtToken RiDeclare (char *name, char *declaration)
{ {
UINT32 i, len; uint32_t i, len;
RtToken pVar; RtToken pVar;
char *pClass; char *pClass;
@@ -436,7 +436,7 @@ RtVoid RiSkew (RtFloat angle, RtFloat dx1, RtFloat dy1, RtFloat dz1,
// -------------------------------------------------------------- // --------------------------------------------------------------
RtVoid RiTransform (RtMatrix transform) RtVoid RiTransform (RtMatrix transform)
{ {
UINT32 i, j; uint32_t i, j;
GS_xform_push(pG); GS_xform_push(pG);
@@ -636,7 +636,7 @@ RtVoid RiSides (RtInt nsides)
/* Geometric Primitives (and a couple gprim-specific attributes) */ /* Geometric Primitives (and a couple gprim-specific attributes) */
RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...) RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...)
{ {
UINT32 j, v, n, k; uint32_t j, v, n, k;
object_t *pObj; object_t *pObj;
RtToken token; RtToken token;
RtPoint *pPoint, *pVert; RtPoint *pPoint, *pVert;
@@ -652,7 +652,7 @@ RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...)
} }
pObj = (object_t*)jmalloc(npolys*sizeof(object_t)); pObj = (object_t*)jmalloc(npolys*sizeof(object_t));
for (n=0; n < (UINT32)npolys; n++) for (n=0; n < (uint32_t)npolys; n++)
{ {
Polygon_init(&pObj[n], ++pW->stat.num_polygons, nverts[n]); Polygon_init(&pObj[n], ++pW->stat.num_polygons, nverts[n]);
} }
@@ -664,7 +664,7 @@ RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...)
pPoint = (RtPoint*)va_arg(args, RtPointer); pPoint = (RtPoint*)va_arg(args, RtPointer);
v = 0; v = 0;
for (n=0; n < (UINT32)npolys; n++) for (n=0; n < (uint32_t)npolys; n++)
{ {
pVar = VarListFindByName(&engine.varList, token); pVar = VarListFindByName(&engine.varList, token);
if (!pVar) if (!pVar)
@@ -675,7 +675,7 @@ RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...)
pVar = VarListAdd(&pObj[n].vars, pVar); pVar = VarListAdd(&pObj[n].vars, pVar);
pVert = (RtPoint*)VarSet(pVar, NULL, nverts[n]); pVert = (RtPoint*)VarSet(pVar, NULL, nverts[n]);
for (j=0; j < (UINT32)nverts[n]; j++) for (j=0; j < (uint32_t)nverts[n]; j++)
{ {
k = verts[v++]; k = verts[v++];
pVert[j][0] = pPoint[k][0]; pVert[j][0] = pPoint[k][0];
@@ -685,7 +685,7 @@ RtVoid RiPointsPolygons (RtInt npolys, RtInt *nverts, RtInt *verts, ...)
} }
} }
}; };
for (n=0; n < (UINT32)npolys; n++) for (n=0; n < (uint32_t)npolys; n++)
{ {
Object_set_xform(&pObj[n], pG->pXform_curr); Object_set_xform(&pObj[n], pG->pXform_curr);
Object_set_attr(&pObj[n], pG->pAttr); Object_set_attr(&pObj[n], pG->pAttr);
@@ -759,7 +759,7 @@ RtVoid RiBasis (RtBasis ubasis, RtInt ustep, RtBasis vbasis, RtInt vstep)
RtVoid RiCurves (RtToken degree, RtInt ncurves, RtInt nverts[], RtToken wrap, ...) RtVoid RiCurves (RtToken degree, RtInt ncurves, RtInt nverts[], RtToken wrap, ...)
{ {
UINT32 n; uint32_t n;
object_t *pObj; object_t *pObj;
RtToken token; RtToken token;
RtPointer arg; RtPointer arg;
src/jman/ribgen.c
+12 -12
View File
@@ -15,7 +15,7 @@
// -------------------------------------------------------------- // --------------------------------------------------------------
void RibgenPrintVars(engine_t *pObj, ri_var_t *pVar, RtPointer arg) void RibgenPrintVars(engine_t *pObj, ri_var_t *pVar, RtPointer arg)
{ {
UINT32 i, j; uint32_t i, j;
RtPoint *pPoint; RtPoint *pPoint;
RtColor *pColor; RtColor *pColor;
RtFloat *pFloat; RtFloat *pFloat;
@@ -137,7 +137,7 @@ void Ribgen_TransformEnd(engine_t *pObj)
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_ConcatTransform(engine_t *pObj, RtMatrix transform) void Ribgen_ConcatTransform(engine_t *pObj, RtMatrix transform)
{ {
UINT32 i, j; uint32_t i, j;
if (!pObj->pFile) if (!pObj->pFile)
return; return;
@@ -189,7 +189,7 @@ void Ribgen_Scale(engine_t *pObj, RtFloat dx, RtFloat dy, RtFloat dz)
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_Transform(engine_t *pObj, RtMatrix transform) void Ribgen_Transform(engine_t *pObj, RtMatrix transform)
{ {
UINT32 i, j; uint32_t i, j;
if (!pObj->pFile) if (!pObj->pFile)
return; return;
@@ -346,7 +346,7 @@ void Ribgen_Illuminate (engine_t *pObj, RtInt id, RtBoolean onoff)
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_PointsPolygons(engine_t *pObj, RtInt npolys, RtInt *nverts, RtInt *verts, va_list args) void Ribgen_PointsPolygons(engine_t *pObj, RtInt npolys, RtInt *nverts, RtInt *verts, va_list args)
{ {
UINT32 j, v, n, num_verts = 0; uint32_t j, v, n, num_verts = 0;
RtToken token; RtToken token;
RtPoint *pPoint; RtPoint *pPoint;
@@ -362,17 +362,17 @@ void Ribgen_PointsPolygons(engine_t *pObj, RtInt npolys, RtInt *nverts, RtInt *v
pPoint = (RtPoint*)va_arg(args, RtPointer); pPoint = (RtPoint*)va_arg(args, RtPointer);
fprintf(pObj->pFile, " ["); fprintf(pObj->pFile, " [");
for (n=0; n < (UINT32)npolys; n++) for (n=0; n < (uint32_t)npolys; n++)
fprintf(pObj->pFile, " %d", nverts[n]); fprintf(pObj->pFile, " %d", nverts[n]);
fprintf(pObj->pFile, " ] ["); fprintf(pObj->pFile, " ] [");
v = 0; v = 0;
for (n=0; n < (UINT32)npolys; n++) for (n=0; n < (uint32_t)npolys; n++)
{ {
for (j=0; j < (UINT32)nverts[n]; j++) for (j=0; j < (uint32_t)nverts[n]; j++)
{ {
if ((UINT32)verts[v] > num_verts) if ((uint32_t)verts[v] > num_verts)
num_verts = verts[v]; num_verts = verts[v];
fprintf(pObj->pFile, " %d", verts[v]); fprintf(pObj->pFile, " %d", verts[v]);
@@ -464,7 +464,7 @@ void Ribgen_Basis (engine_t *pObj, RtBasis ubasis, RtInt ustep, RtBasis vbasis,
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_Curves(engine_t *pObj, object_t *pObject, RtToken type, RtInt ncurves, RtInt nverts[], RtToken wrap, va_list args) void Ribgen_Curves(engine_t *pObj, object_t *pObject, RtToken type, RtInt ncurves, RtInt nverts[], RtToken wrap, va_list args)
{ {
UINT32 i, n, num_verts = 0; uint32_t i, n, num_verts = 0;
RtToken token; RtToken token;
RtPointer arg; RtPointer arg;
ri_var_t *pVar; ri_var_t *pVar;
@@ -493,7 +493,7 @@ void Ribgen_Curves(engine_t *pObj, object_t *pObject, RtToken type, RtInt ncurve
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_Patch(engine_t *pObj, object_t *pObject, RtToken type, va_list args) void Ribgen_Patch(engine_t *pObj, object_t *pObject, RtToken type, va_list args)
{ {
UINT32 i, npoints; uint32_t i, npoints;
RtToken token; RtToken token;
RtPointer arg; RtPointer arg;
ri_var_t *pVar; ri_var_t *pVar;
@@ -519,7 +519,7 @@ void Ribgen_Patch(engine_t *pObj, object_t *pObject, RtToken type, va_list args)
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_Patchmesh(engine_t *pObj, object_t *pObject, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, va_list args) void Ribgen_Patchmesh(engine_t *pObj, object_t *pObject, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, va_list args)
{ {
UINT32 i; uint32_t i;
RtToken token; RtToken token;
RtPointer arg; RtPointer arg;
ri_var_t *pVar; ri_var_t *pVar;
@@ -558,7 +558,7 @@ void Ribgen_Sphere(engine_t *pObj, object_t *pObject, RtFloat radius, RtFloat zm
} }
// -------------------------------------------------------------- // --------------------------------------------------------------
void Ribgen_LightSource(engine_t *pObj, object_t *pObject, char *name, UINT32 id, va_list args) void Ribgen_LightSource(engine_t *pObj, object_t *pObject, char *name, uint32_t id, va_list args)
{ {
RtToken token; RtToken token;
RtPointer arg; RtPointer arg;
src/jman/ribgen.h
+1 -1
View File
@@ -35,7 +35,7 @@ void Ribgen_Curves(engine_t *pObj, object_t *pObject, RtToken type, RtInt ncurve
void Ribgen_Patch(engine_t *pObj, object_t *pObject, RtToken type, va_list args); void Ribgen_Patch(engine_t *pObj, object_t *pObject, RtToken type, va_list args);
void Ribgen_Patchmesh(engine_t *pObj, object_t *pObject, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, va_list args); void Ribgen_Patchmesh(engine_t *pObj, object_t *pObject, RtToken type, RtInt nu, RtToken uwrap, RtInt nv, RtToken vwrap, va_list args);
void Ribgen_Sphere(engine_t *pObj, object_t *pObject, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax, va_list args); void Ribgen_Sphere(engine_t *pObj, object_t *pObject, RtFloat radius, RtFloat zmin, RtFloat zmax, RtFloat thetamax, va_list args);
void Ribgen_LightSource(engine_t *pObj, object_t *pObject, char *name, UINT32 id, va_list args); void Ribgen_LightSource(engine_t *pObj, object_t *pObject, char *name, uint32_t id, va_list args);
void Ribgen_Surface(engine_t *pObj, char *name, va_list args); void Ribgen_Surface(engine_t *pObj, char *name, va_list args);
void Ribgen_Displacement(engine_t *pObj, char *name, va_list args); void Ribgen_Displacement(engine_t *pObj, char *name, va_list args);
src/jman/stack.c
+1 -1
View File
@@ -42,7 +42,7 @@ stack_t* Stack_free(stack_t *pObj)
return pObj; return pObj;
} }
stack_t* Stack_push(stack_t *pObj, void **ppData, UINT32 size) stack_t* Stack_push(stack_t *pObj, void **ppData, uint32_t size)
{ {
stack_t *pCurr; stack_t *pCurr;
src/jman/stack.h
+2 -2
View File
@@ -5,7 +5,7 @@
typedef struct _sstack_t typedef struct _sstack_t
{ {
UINT32 size; uint32_t size;
void *pData; void *pData;
struct _sstack_t *pNext; struct _sstack_t *pNext;
struct _sstack_t *pPrev; struct _sstack_t *pPrev;
@@ -14,7 +14,7 @@ typedef struct _sstack_t
stack_t* Stack_free_top(stack_t *pObj); stack_t* Stack_free_top(stack_t *pObj);
stack_t* Stack_free(stack_t *pObj); stack_t* Stack_free(stack_t *pObj);
stack_t* Stack_push(stack_t *pObj, void **ppData, UINT32 size); stack_t* Stack_push(stack_t *pObj, void **ppData, uint32_t size);
stack_t* Stack_pop(stack_t *pObj, void **ppData); stack_t* Stack_pop(stack_t *pObj, void **ppData);
#endif // STACK_H #endif // STACK_H
src/jman/types.h
+3 -23
View File
@@ -5,31 +5,11 @@
#ifndef TYPES_H #ifndef TYPES_H
#define TYPES_H #define TYPES_H
#ifndef UINT32 #include <stdint.h>
#define UINT32 unsigned int
#endif
#ifndef UINT16
#define UINT16 unsigned short
#endif
#ifndef UINT8
#define UINT8 unsigned char
#endif
#ifndef INT32
#define INT32 signed int
#endif
#ifndef INT16
#define INT16 signed short
#endif
#ifndef INT8
#define INT8 signed char
#endif
#ifndef ERROR_BASE
#define ERROR_BASE 0x80000000 #define ERROR_BASE 0x80000000
#endif
#ifndef IS_ERROR #ifndef IS_ERROR
#define IS_ERROR(e) ((e & ERROR_BASE) == ERROR_BASE) #define IS_ERROR(e) ((e & ERROR_BASE) == ERROR_BASE)
#endif #endif
src/jman/vars.c
+7 -7
View File
@@ -47,7 +47,7 @@ void VarListFree(var_list_t *pObj)
} }
// finds variable by its name // finds variable by its name
ri_var_t* VarListFindByName(var_list_t *pObj, UINT8 *name) ri_var_t* VarListFindByName(var_list_t *pObj, uint8_t *name)
{ {
linkedlist_t *pFirst, *pVarList; linkedlist_t *pFirst, *pVarList;
ri_var_t *pVar; ri_var_t *pVar;
@@ -105,12 +105,12 @@ void VarListPrint(var_list_t *pObj)
// Declare empty variable and add it to list of variables // Declare empty variable and add it to list of variables
ri_var_t* VarListDeclare(var_list_t *pObj, UINT8 *name, UINT8 *cls, UINT8 *type) ri_var_t* VarListDeclare(var_list_t *pObj, uint8_t *name, uint8_t *cls, uint8_t *type)
{ {
RtToken *pToken; RtToken *pToken;
RtInt *pSize; RtInt *pSize;
UINT32 *pEtypes; uint32_t *pEtypes;
UINT32 *pEclasses; uint32_t *pEclasses;
ri_var_t var; ri_var_t var;
@@ -183,7 +183,7 @@ ri_var_t* VarListAdd(var_list_t *pObj, ri_var_t *pVar)
} }
void VarListDelByName(var_list_t *pObj, UINT8 *name) void VarListDelByName(var_list_t *pObj, uint8_t *name)
{ {
VarListDel(pObj, VarListFindByName(pObj, name)); VarListDel(pObj, VarListFindByName(pObj, name));
} }
@@ -214,7 +214,7 @@ void VarListDel(var_list_t *pObj, ri_var_t *pVar)
} }
// Allocs empty variable // Allocs empty variable
RtPointer VarAlloc(ri_var_t *pObj, UINT32 nvalues) RtPointer VarAlloc(ri_var_t *pObj, uint32_t nvalues)
{ {
if (!nvalues) if (!nvalues)
return NULL; return NULL;
@@ -235,7 +235,7 @@ RtPointer VarAlloc(ri_var_t *pObj, UINT32 nvalues)
} }
// Allocs empty variable and copy data into it // Allocs empty variable and copy data into it
RtPointer VarSet(ri_var_t *pObj, RtPointer pValue, UINT32 nvalues) RtPointer VarSet(ri_var_t *pObj, RtPointer pValue, uint32_t nvalues)
{ {
RtPointer pData; RtPointer pData;
src/jman/vars.h
+10 -12
View File
@@ -1,19 +1,17 @@
#ifndef VARS_H #ifndef VARS_H
#define VARS_H #define VARS_H
#include <stdio.h> #include <stdint.h>
#include <stdlib.h>
#include <string.h>
typedef struct _sri_var_t typedef struct _sri_var_t
{ {
UINT32 etype; uint32_t etype;
UINT32 ecls; uint32_t ecls;
RtToken name; RtToken name;
RtToken type; RtToken type;
RtToken cls; RtToken cls;
RtPointer pValue; RtPointer pValue;
UINT32 value_size, nvalues; uint32_t value_size, nvalues;
} ri_var_t; } ri_var_t;
@@ -28,14 +26,14 @@ enum _vVarClass {VC_VERTEX, VC_UNIFORM, VC_VARYING, VC_CONSTANT};
void VarListInit(var_list_t *pObj); void VarListInit(var_list_t *pObj);
void VarListFree(var_list_t *pObj); void VarListFree(var_list_t *pObj);
ri_var_t* VarListFindByName(var_list_t *pObj, UINT8 *name); ri_var_t* VarListFindByName(var_list_t *pObj, uint8_t *name);
ri_var_t* VarListDeclare(var_list_t *pObj, UINT8 *name, UINT8 *cls, UINT8 *type); ri_var_t* VarListDeclare(var_list_t *pObj, uint8_t *name, uint8_t *cls, uint8_t *type);
ri_var_t* VarListAdd(var_list_t *pObj, ri_var_t *pVar); ri_var_t* VarListAdd(var_list_t *pObj, ri_var_t *pVar);
void VarListDelByName(var_list_t *pObj, UINT8 *name); void VarListDelByName(var_list_t *pObj, uint8_t *name);
void VarListDel(var_list_t *pObj, ri_var_t *pVar); void VarListDel(var_list_t *pObj, ri_var_t *pVar);
ri_var_t* VarListDeleteByName(var_list_t *pObj, UINT8 *name); ri_var_t* VarListDeleteByName(var_list_t *pObj, uint8_t *name);
RtPointer VarAlloc(ri_var_t *pObj, UINT32 nvalues); RtPointer VarAlloc(ri_var_t *pObj, uint32_t nvalues);
RtPointer VarSet(ri_var_t *pObj, RtPointer pValue, UINT32 nvalues); RtPointer VarSet(ri_var_t *pObj, RtPointer pValue, uint32_t nvalues);
RtPointer VarGet(ri_var_t *pObj); RtPointer VarGet(ri_var_t *pObj);
void VarListPrint(var_list_t *pObj); void VarListPrint(var_list_t *pObj);
src/libsys/gpio.c
+5 -5
View File
@@ -2,24 +2,24 @@
#include "gpio.h" #include "gpio.h"
// --------------------------------------------------------- // ---------------------------------------------------------
UINT32 gpio_init(gpio_if_t *pGPIO, UINT32 base_addr) uint32_t gpio_init(gpio_if_t *pGPIO, uint32_t base_addr)
{ {
pGPIO->pBase = (UINT32*)base_addr; pGPIO->pBase = (uint32_t*)base_addr;
return 0; return 0;
} }
UINT32 gpio_clean(gpio_if_t *pGPIO) uint32_t gpio_clean(gpio_if_t *pGPIO)
{ {
return 0; return 0;
} }
UINT32 gpio_write(gpio_if_t *pGPIO, UINT32 mask, UINT32 shift, UINT32 offset, UINT32 value) uint32_t gpio_write(gpio_if_t *pGPIO, uint32_t mask, uint32_t shift, uint32_t offset, uint32_t value)
{ {
*(pGPIO->pBase + offset) = (*(pGPIO->pBase + offset) & ~(mask << shift)) | ((value & mask) << shift); *(pGPIO->pBase + offset) = (*(pGPIO->pBase + offset) & ~(mask << shift)) | ((value & mask) << shift);
return 0; return 0;
} }
UINT32 gpio_read(gpio_if_t *pGPIO, UINT32 mask, UINT32 shift, UINT32 offset, UINT32 *pValue) uint32_t gpio_read(gpio_if_t *pGPIO, uint32_t mask, uint32_t shift, uint32_t offset, uint32_t *pValue)
{ {
*pValue = (*(pGPIO->pBase + offset) & (mask << shift)) >> shift; *pValue = (*(pGPIO->pBase + offset) & (mask << shift)) >> shift;
return 0; return 0;
src/libsys/gpio.h
+5 -5
View File
@@ -9,7 +9,7 @@
// --------------------------------------------------------- // ---------------------------------------------------------
typedef struct _sgpio_if_t typedef struct _sgpio_if_t
{ {
volatile UINT32 *pBase; volatile uint32_t *pBase;
} gpio_if_t; } gpio_if_t;
@@ -32,10 +32,10 @@ typedef struct _sgpio_if_t
gpio_read(gpio, mask, shift, GPIO_DIR_OFFSET, ret) gpio_read(gpio, mask, shift, GPIO_DIR_OFFSET, ret)
UINT32 gpio_init(gpio_if_t *pGPIO, UINT32 base_addr); uint32_t gpio_init(gpio_if_t *pGPIO, uint32_t base_addr);
UINT32 gpio_clean(gpio_if_t *pGPIO); uint32_t gpio_clean(gpio_if_t *pGPIO);
UINT32 gpio_write(gpio_if_t *pGPIO, UINT32 mask, UINT32 shift, UINT32 offset, UINT32 value); uint32_t gpio_write(gpio_if_t *pGPIO, uint32_t mask, uint32_t shift, uint32_t offset, uint32_t value);
UINT32 gpio_read(gpio_if_t *pGPIO, UINT32 mask, UINT32 shift, UINT32 offset, UINT32 *pValue); uint32_t gpio_read(gpio_if_t *pGPIO, uint32_t mask, uint32_t shift, uint32_t offset, uint32_t *pValue);
#endif // GPIO_H #endif // GPIO_H
src/libsys/libsys.c
+81 -81
View File
@@ -11,16 +11,16 @@
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// Forward declarations // Forward declarations
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
void flush(UINT32 port); void flush(uint32_t port);
UINT32 GetPort(int file); uint32_t GetPort(int file);
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// Types // Types
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
void libsys_init(void) void libsys_init(void)
{ {
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pITIM_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pITIM_ctrl = (uint32_t*)SYS_ITIM_CTRL;
Screen_clr(); Screen_clr();
@@ -62,7 +62,7 @@ enum
}; };
UINT32 GetPort(int file) uint32_t GetPort(int file)
{ {
if (file == 0) // STDIN if (file == 0) // STDIN
return PORT_IN_UART_0; return PORT_IN_UART_0;
@@ -90,34 +90,34 @@ enum
typedef struct _suart_if_t typedef struct _suart_if_t
{ {
volatile UINT32 *pCTRL; volatile uint32_t *pCTRL;
volatile UINT32 *pDATA; volatile uint32_t *pDATA;
volatile UINT32 *pBAUD; volatile uint32_t *pBAUD;
} uart_if_t; } uart_if_t;
typedef struct _sps2_if_t typedef struct _sps2_if_t
{ {
volatile UINT32 *pCTRL; volatile uint32_t *pCTRL;
volatile UINT32 *pDATA; volatile uint32_t *pDATA;
} ps2_if_t; } ps2_if_t;
typedef struct _svga_if_t typedef struct _svga_if_t
{ {
volatile UINT32 *pCTRL; volatile uint32_t *pCTRL;
volatile UINT32 *pDATA; volatile uint32_t *pDATA;
volatile UINT32 *pCSRX; volatile uint32_t *pCSRX;
volatile UINT32 *pCSRY; volatile uint32_t *pCSRY;
} vga_if_t; } vga_if_t;
typedef struct _scon_if_in_t typedef struct _scon_if_in_t
{ {
UINT32 type; uint32_t type;
void *pIF; void *pIF;
} con_if_in_t; } con_if_in_t;
typedef struct _scon_if_out_t typedef struct _scon_if_out_t
{ {
UINT32 type; uint32_t type;
void *pIF; void *pIF;
} con_if_out_t; } con_if_out_t;
@@ -126,15 +126,15 @@ typedef struct _scon_if_out_t
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
static uart_if_t uart_if[2] = static uart_if_t uart_if[2] =
{ {
{(UINT32*)SYS_UART0_STAT, (UINT32*)SYS_UART0_DATA, (UINT32*)SYS_UART0_BAUD}, {(uint32_t*)SYS_UART0_STAT, (uint32_t*)SYS_UART0_DATA, (uint32_t*)SYS_UART0_BAUD},
{(UINT32*)SYS_UART1_STAT, (UINT32*)SYS_UART1_DATA, (UINT32*)SYS_UART1_BAUD} {(uint32_t*)SYS_UART1_STAT, (uint32_t*)SYS_UART1_DATA, (uint32_t*)SYS_UART1_BAUD}
}; };
extern ps2_if_t ps2_if[]; extern ps2_if_t ps2_if[];
static vga_if_t vga_if = static vga_if_t vga_if =
{ {
(UINT32*)SYS_VGA_CTRL, (UINT32*)SYS_VGA_ASCII, (UINT32*)SYS_VGA_POSX, (UINT32*)SYS_VGA_POSY (uint32_t*)SYS_VGA_CTRL, (uint32_t*)SYS_VGA_ASCII, (uint32_t*)SYS_VGA_POSX, (uint32_t*)SYS_VGA_POSY
}; };
static con_if_in_t con_if_in[4] = static con_if_in_t con_if_in[4] =
@@ -156,9 +156,9 @@ static con_if_out_t con_if_out[4] =
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
// MIPS specific // MIPS specific
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
UINT32 CP0_SR_read(void) uint32_t CP0_SR_read(void)
{ {
UINT32 result; uint32_t result;
__asm__ __asm__
( (
@@ -169,7 +169,7 @@ UINT32 CP0_SR_read(void)
return result; return result;
} }
void CP0_SR_write(UINT32 val) void CP0_SR_write(uint32_t val)
{ {
__asm__ __asm__
( (
@@ -179,9 +179,9 @@ void CP0_SR_write(UINT32 val)
); );
} }
UINT32 CP0_CR_read(void) uint32_t CP0_CR_read(void)
{ {
UINT32 result; uint32_t result;
__asm__ __asm__
( (
@@ -192,7 +192,7 @@ UINT32 CP0_CR_read(void)
return result; return result;
} }
void CP0_CR_write(UINT32 val) void CP0_CR_write(uint32_t val)
{ {
__asm__ __asm__
( (
@@ -202,9 +202,9 @@ void CP0_CR_write(UINT32 val)
); );
} }
UINT32 CP0_TR_read(void) uint32_t CP0_TR_read(void)
{ {
UINT32 result; uint32_t result;
__asm__ __asm__
( (
@@ -215,7 +215,7 @@ UINT32 CP0_TR_read(void)
return result; return result;
} }
void CP0_TR_write(UINT32 val) void CP0_TR_write(uint32_t val)
{ {
__asm__ __asm__
( (
@@ -225,9 +225,9 @@ void CP0_TR_write(UINT32 val)
); );
} }
UINT32 CP0_PRID_read(void) uint32_t CP0_PRID_read(void)
{ {
UINT32 result; uint32_t result;
__asm__ __asm__
( (
@@ -238,7 +238,7 @@ UINT32 CP0_PRID_read(void)
return result; return result;
} }
void CP0_TR_write_ptr(UINT32* pPtr) void CP0_TR_write_ptr(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -248,7 +248,7 @@ void CP0_TR_write_ptr(UINT32* pPtr)
); );
} }
void CP0_TR_read_ptr(UINT32* pPtr) void CP0_TR_read_ptr(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -266,7 +266,7 @@ void ICACHE_invalidate_all(void)
); );
} }
void ICACHE_invalidate_at(UINT32* pPtr) void ICACHE_invalidate_at(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -285,7 +285,7 @@ void DCACHE_invalidate_all(void)
); );
} }
void DCACHE_invalidate_at(UINT32* pPtr) void DCACHE_invalidate_at(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -302,10 +302,10 @@ void DCACHE_invalidate_at(UINT32* pPtr)
//keymap for the AT keyboard SG layout //keymap for the AT keyboard SG layout
typedef struct typedef struct
{ {
UINT8 scancode; uint8_t scancode;
UINT8 unshifted; uint8_t unshifted;
UINT8 shifted; uint8_t shifted;
UINT8 altered; uint8_t altered;
} libsys_key_entry_t; } libsys_key_entry_t;
#define SHIFTED (1<<0) #define SHIFTED (1<<0)
@@ -318,7 +318,7 @@ static const libsys_key_entry_t __keymap_german[] =
{0x32, 'b', 'B', 'b'}, {0x32, 'b', 'B', 'b'},
{0x21, 'c', 'C', 'c'}, {0x21, 'c', 'C', 'c'},
{0x23, 'd', 'D', 'd'}, {0x23, 'd', 'D', 'd'},
{0x24, 'e', 'E', '€'}, {0x24, 'e', 'E', '�'},
{0x2b, 'f', 'F', 'f'}, {0x2b, 'f', 'F', 'f'},
{0x34, 'g', 'G', 'g'}, {0x34, 'g', 'G', 'g'},
{0x33, 'h', 'H', 'h'}, {0x33, 'h', 'H', 'h'},
@@ -326,7 +326,7 @@ static const libsys_key_entry_t __keymap_german[] =
{0x3b, 'j', 'J', 'j'}, {0x3b, 'j', 'J', 'j'},
{0x42, 'k', 'K', 'k'}, {0x42, 'k', 'K', 'k'},
{0x4b, 'l', 'L', 'l'}, {0x4b, 'l', 'L', 'l'},
{0x3a, 'm', 'M', 'µ'}, {0x3a, 'm', 'M', '�'},
{0x31, 'n', 'N', 'n'}, {0x31, 'n', 'N', 'n'},
{0x44, 'o', 'O', 'o'}, {0x44, 'o', 'O', 'o'},
{0x4d, 'p', 'P', 'p'}, {0x4d, 'p', 'P', 'p'},
@@ -342,7 +342,7 @@ static const libsys_key_entry_t __keymap_german[] =
{0x35, 'z', 'Z', 'z'}, {0x35, 'z', 'Z', 'z'},
{0x16, '1', '!', '1'}, {0x16, '1', '!', '1'},
{0x1e, '2', '"', '2'}, {0x1e, '2', '"', '2'},
{0x26, '3', '§', '3'}, {0x26, '3', '�', '3'},
{0x25, '4', '$', '4'}, {0x25, '4', '$', '4'},
{0x2e, '5', '%', '5'}, {0x2e, '5', '%', '5'},
{0x36, '6', '&', '6'}, {0x36, '6', '&', '6'},
@@ -350,18 +350,18 @@ static const libsys_key_entry_t __keymap_german[] =
{0x3e, '8', '(', '['}, {0x3e, '8', '(', '['},
{0x46, '9', ')', ']'}, {0x46, '9', ')', ']'},
{0x45, '0', '=', '}'}, {0x45, '0', '=', '}'},
{0x4e, 'ß', '?', '\\'}, {0x4e, '�', '?', '\\'},
{0x29, ' ', ' ', ' '}, {0x29, ' ', ' ', ' '},
{0x41, ',', ';', ','}, {0x41, ',', ';', ','},
{0x49, '.', ':', '.'}, {0x49, '.', ':', '.'},
{0x4a, '-', '_', '-'}, {0x4a, '-', '_', '-'},
{0x52, 'ä', 'Ä', 'ä'}, {0x52, '�', '�', '�'},
{0x4c, 'ö', 'Ö', 'ö'}, {0x4c, '�', '�', '�'},
{0x54, 'ü', 'Ü', 'ü'}, {0x54, '�', '�', '�'},
{0x5a, '\n', '\n', '\n'}, //RETURN {0x5a, '\n', '\n', '\n'}, //RETURN
{0x5b, '+', '*', '~'}, {0x5b, '+', '*', '~'},
{0x5d, '#', '\'', '#'}, {0x5d, '#', '\'', '#'},
{0x0e, '^', '°', '^'}, {0x0e, '^', '�', '^'},
{0x61, '<', '>', '|'}, {0x61, '<', '>', '|'},
{0x66, '\b', '\b', '\b'}, {0x66, '\b', '\b', '\b'},
{0} //sentinel {0} //sentinel
@@ -414,7 +414,7 @@ static char __findkey(char scancode, int mode)
#define ARROW_LEFT (SPECIALKEY|EXTENDED|0x6b) #define ARROW_LEFT (SPECIALKEY|EXTENDED|0x6b)
#define ARROW_RIGHT (SPECIALKEY|EXTENDED|0x74) #define ARROW_RIGHT (SPECIALKEY|EXTENDED|0x74)
UINT32 PS2_readchar(ps2_if_t *pIF) uint32_t PS2_readchar(ps2_if_t *pIF)
{ {
if (!pIF) if (!pIF)
return -1; return -1;
@@ -425,15 +425,15 @@ UINT32 PS2_readchar(ps2_if_t *pIF)
} }
UINT32 con_readchar(ps2_if_t *pIF) uint32_t con_readchar(ps2_if_t *pIF)
{ {
UINT8 c; uint8_t c;
static char mode = 0; static char mode = 0;
static char nextrelease = 0; static char nextrelease = 0;
static char extended = 0; static char extended = 0;
int flags = 0; int flags = 0;
int char_valid = 0; int char_valid = 0;
UINT8 key; uint8_t key;
key = PS2_readchar(pIF); key = PS2_readchar(pIF);
@@ -520,12 +520,12 @@ void UART_writechar(uart_if_t *pIF, char c)
while((SYS_UART_BIT_TX_HALFFULL & *pIF->pCTRL) != 0); while((SYS_UART_BIT_TX_HALFFULL & *pIF->pCTRL) != 0);
*pIF->pDATA = (UINT32)c; *pIF->pDATA = (uint32_t)c;
} }
void cg_writechar(vga_if_t *pIF, char c) void cg_writechar(vga_if_t *pIF, char c)
{ {
UINT32 code; uint32_t code;
if (!pIF) if (!pIF)
return; return;
@@ -533,27 +533,27 @@ void cg_writechar(vga_if_t *pIF, char c)
// Output translation // Output translation
switch(c) switch(c)
{ {
case 'Ä': case '�':
code = 196; code = 196;
break; break;
case 'ä': case '�':
code = 228; code = 228;
break; break;
case 'Ö': case '�':
code = 214; code = 214;
break; break;
case 'ö': case '�':
code = 246; code = 246;
break; break;
case 'Ü': case '�':
code = 220; code = 220;
break; break;
case 'ü': case '�':
code = 252; code = 252;
break; break;
@@ -561,24 +561,24 @@ void cg_writechar(vga_if_t *pIF, char c)
code = 230; code = 230;
break; break;
case '§': case '�':
code = 167; code = 167;
break; break;
case 'ß': case '�':
code = 223; code = 223;
break; break;
case '°': case '�':
code = 176; code = 176;
break; break;
case 'µ': case '�':
code = 181; code = 181;
break; break;
default: default:
code = (UINT32)c; code = (uint32_t)c;
break; break;
} }
@@ -586,7 +586,7 @@ void cg_writechar(vga_if_t *pIF, char c)
*pIF->pDATA = code; *pIF->pDATA = code;
} }
void cg_set_csr_x(vga_if_t *pIF, UINT32 coord) void cg_set_csr_x(vga_if_t *pIF, uint32_t coord)
{ {
if (!pIF) if (!pIF)
return; return;
@@ -596,7 +596,7 @@ void cg_set_csr_x(vga_if_t *pIF, UINT32 coord)
*pIF->pCSRX = coord; *pIF->pCSRX = coord;
} }
void cg_set_csr_y(vga_if_t *pIF, UINT32 coord) void cg_set_csr_y(vga_if_t *pIF, uint32_t coord)
{ {
if (!pIF) if (!pIF)
return; return;
@@ -643,39 +643,39 @@ void Screen_line_clr(void)
cg_clr_line(&vga_if); cg_clr_line(&vga_if);
} }
void Screen_csr_set_x(UINT32 coord) void Screen_csr_set_x(uint32_t coord)
{ {
cg_set_csr_x(&vga_if, coord); cg_set_csr_x(&vga_if, coord);
} }
void Screen_csr_set_y(UINT32 coord) void Screen_csr_set_y(uint32_t coord)
{ {
cg_set_csr_y(&vga_if, coord); cg_set_csr_y(&vga_if, coord);
} }
UINT32 Screen_get_resx(void) uint32_t Screen_get_resx(void)
{ {
UINT32 volatile *pVGA_res = (UINT32*)SYS_VGA_RES; uint32_t volatile *pVGA_res = (uint32_t*)SYS_VGA_RES;
return (0xFFF & (*pVGA_res >> 0)); return (0xFFF & (*pVGA_res >> 0));
} }
UINT32 Screen_get_resy(void) uint32_t Screen_get_resy(void)
{ {
UINT32 volatile *pVGA_res = (UINT32*)SYS_VGA_RES; uint32_t volatile *pVGA_res = (uint32_t*)SYS_VGA_RES;
return (0xFFF & (*pVGA_res >> 12)); return (0xFFF & (*pVGA_res >> 12));
} }
UINT32 Screen_get_fps(void) uint32_t Screen_get_fps(void)
{ {
UINT32 volatile *pVGA_res = (UINT32*)SYS_VGA_RES; uint32_t volatile *pVGA_res = (uint32_t*)SYS_VGA_RES;
return (0xFF & (*pVGA_res >> 24)); return (0xFF & (*pVGA_res >> 24));
} }
// --------------------------------------------------------------------------------- // ---------------------------------------------------------------------------------
void flush(UINT32 port) void flush(uint32_t port)
{ {
int c; int c;
con_if_in_t *pIF; con_if_in_t *pIF;
@@ -701,7 +701,7 @@ void flush(UINT32 port)
} while(c > 0); } while(c > 0);
} }
char readchar(UINT32 port) char readchar(uint32_t port)
{ {
int c; int c;
con_if_in_t *pIF; con_if_in_t *pIF;
@@ -729,7 +729,7 @@ char readchar(UINT32 port)
return (char)c; return (char)c;
} }
void writechar(UINT32 port, char c) void writechar(uint32_t port, char c)
{ {
con_if_out_t *pIF; con_if_out_t *pIF;
@@ -750,7 +750,7 @@ void writechar(UINT32 port, char c)
} }
} }
void _putchar(UINT32 port, char c) void _putchar(uint32_t port, char c)
{ {
con_if_out_t *pIF; con_if_out_t *pIF;
@@ -951,7 +951,7 @@ int close(int file)
int read(int file, char *ptr, int len) int read(int file, char *ptr, int len)
{ {
UINT32 port; uint32_t port;
int i; int i;
char c; char c;
@@ -984,7 +984,7 @@ int read(int file, char *ptr, int len)
int write(int file, char *ptr, int len) int write(int file, char *ptr, int len)
{ {
UINT32 port; uint32_t port;
int i = 0; int i = 0;
// sputs("write ("); print_word(file); sputs(")\n"); // sputs("write ("); print_word(file); sputs(")\n");
@@ -1087,12 +1087,12 @@ void print_word(int word)
// _Return: none // _Return: none
// //
// --------------------------------------------------------------------------- // ---------------------------------------------------------------------------
void PrintBuffer8(UINT8 *pBuf, int nbpr, int len) void PrintBuffer8(uint8_t *pBuf, int nbpr, int len)
{ {
memdump(pBuf, 1, nbpr, len); memdump(pBuf, 1, nbpr, len);
} }
void memdump(UINT8 *pBuf, int print_offset_only, int num_bytes_per_row, int len) void memdump(uint8_t *pBuf, int print_offset_only, int num_bytes_per_row, int len)
{ {
int i, j, cnt_hex, cnt_asc, base; int i, j, cnt_hex, cnt_asc, base;
unsigned char c; unsigned char c;
src/libsys/libsys.h
+29 -48
View File
@@ -1,30 +1,11 @@
#ifndef LIBSYS_H #ifndef LIBSYS_H
#define LIBSYS_H #define LIBSYS_H
#include <stdint.h>
// --------------------------------------------------------- // ---------------------------------------------------------
// Types // Types
// --------------------------------------------------------- // ---------------------------------------------------------
#define INT8 signed char
#define INT16 signed short
#define INT32 signed int
#define INT64 signed long long
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#define UINT64 unsigned long long
#define INT INT32
#define UINT UINT32
#define FLOAT32 float
#define FLOAT64 double
#define int8_t signed char
#define int16_t signed short
#define int32_t signed int
#define int64_t signed long long
#define uint8_t unsigned char
#define uint16_t unsigned short
#define uint32_t unsigned int
#define uint64_t unsigned long long
#define NO_ERROR LSYS_SUCCESS #define NO_ERROR LSYS_SUCCESS
#define ERROR LSYS_ERR_BASE #define ERROR LSYS_ERR_BASE
@@ -278,7 +259,7 @@ void ICACHE_invalidate_all(void)
); );
} }
void ICACHE_invalidate_at(UINT32* pPtr) void ICACHE_invalidate_at(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -297,7 +278,7 @@ void DCACHE_invalidate_all(void)
); );
} }
void DCACHE_invalidate_at(UINT32* pPtr) void DCACHE_invalidate_at(uint32_t* pPtr)
{ {
__asm__ __asm__
( (
@@ -311,7 +292,7 @@ void DCACHE_invalidate_at(UINT32* pPtr)
#define CP0_read(idx) \ #define CP0_read(idx) \
({ \ ({ \
UINT32 result; \ uint32_t result; \
__asm__ __volatile__ \ __asm__ __volatile__ \
( \ ( \
"mfc0\t%0,$"#idx"\n" \ "mfc0\t%0,$"#idx"\n" \
@@ -351,34 +332,34 @@ void DCACHE_invalidate_at(UINT32* pPtr)
); \ ); \
}) })
UINT32 CP0_SR_read(void); uint32_t CP0_SR_read(void);
void CP0_SR_write(UINT32 val); void CP0_SR_write(uint32_t val);
UINT32 CP0_CR_read(void); uint32_t CP0_CR_read(void);
void CP0_CR_write(UINT32 val); void CP0_CR_write(uint32_t val);
UINT32 CP0_PRID_read(void); uint32_t CP0_PRID_read(void);
UINT32 CP0_TR_read(void); uint32_t CP0_TR_read(void);
void CP0_TR_write(UINT32 val); void CP0_TR_write(uint32_t val);
void CP0_TR_write_ptr(UINT32* pPtr); void CP0_TR_write_ptr(uint32_t* pPtr);
void CP0_TR_read_ptr(UINT32* pPtr); void CP0_TR_read_ptr(uint32_t* pPtr);
void ICACHE_invalidate_all(void); void ICACHE_invalidate_all(void);
void ICACHE_invalidate_at(UINT32* pPtr); void ICACHE_invalidate_at(uint32_t* pPtr);
void DCACHE_invalidate_all(void); void DCACHE_invalidate_all(void);
void DCACHE_invalidate_at(UINT32* pPtr); void DCACHE_invalidate_at(uint32_t* pPtr);
#define CALC_BAUD(b) \ #define CALC_BAUD(b) \
((UINT32)((float)CPU_FREQ_HZ/(16*b) + 0.5f) - 1); ((uint32_t)((float)CPU_FREQ_HZ/(16*b) + 0.5f) - 1);
#define UART0_setbaud(b) \ #define UART0_setbaud(b) \
*((UINT32*)SYS_UART0_BAUD) = CALC_BAUD(b); *((uint32_t*)SYS_UART0_BAUD) = CALC_BAUD(b);
#define UART1_setbaud(b) \ #define UART1_setbaud(b) \
*((UINT32*)SYS_UART1_BAUD) = CALC_BAUD(b); *((uint32_t*)SYS_UART1_BAUD) = CALC_BAUD(b);
#define UART2_setbaud(b) \ #define UART2_setbaud(b) \
*((UINT32*)SYS_UART2_BAUD) = CALC_BAUD(b); *((uint32_t*)SYS_UART2_BAUD) = CALC_BAUD(b);
char readchar(UINT32 port); char readchar(uint32_t port);
void writechar(UINT32 port, char c); void writechar(uint32_t port, char c);
int write(int file, char *ptr, int len); int write(int file, char *ptr, int len);
int sputs(char const *pStr); int sputs(char const *pStr);
void print_byte(char byte); void print_byte(char byte);
@@ -389,16 +370,16 @@ void usleep(unsigned us);
char _getchar(void); char _getchar(void);
void PrintBuffer8(UINT8 *pBuf, int nbpr, int len); void PrintBuffer8(uint8_t *pBuf, int nbpr, int len);
void memdump(UINT8 *pBuf, int print_offset_only, int num_bytes_per_row, int len); void memdump(uint8_t *pBuf, int print_offset_only, int num_bytes_per_row, int len);
void Screen_clr(void); void Screen_clr(void);
void Screen_line_clr(void); void Screen_line_clr(void);
void Screen_csr_set_x(UINT32 coord); void Screen_csr_set_x(uint32_t coord);
void Screen_csr_set_y(UINT32 coord); void Screen_csr_set_y(uint32_t coord);
UINT32 Screen_get_resx(void); uint32_t Screen_get_resx(void);
UINT32 Screen_get_resy(void); uint32_t Screen_get_resy(void);
UINT32 Screen_get_fps(void); uint32_t Screen_get_fps(void);
src/libsys/mips_dbg.c
+218 -218
View File
@@ -37,8 +37,8 @@ static char *g_state_names[STATE_NUM_ENTRIES] = {"Init", "Run", "Single step", "
typedef struct _sbp_t typedef struct _sbp_t
{ {
UINT32 *pAddr; uint32_t *pAddr;
UINT32 instr; uint32_t instr;
} bp_t; } bp_t;
static EXCEPTION_CONTEXT xcp_last; static EXCEPTION_CONTEXT xcp_last;
@@ -48,17 +48,17 @@ static bp_t mgmt_bp_ru[2];
static int g_is_ss; static int g_is_ss;
static int g_bp_count; static int g_bp_count;
int IsBreak(UINT32 instr) int IsBreak(uint32_t instr)
{ {
return ((instr & 0xFC00003F) == 0x0000000D); return ((instr & 0xFC00003F) == 0x0000000D);
} }
UINT32 BreakGetType(UINT32 instr) uint32_t BreakGetType(uint32_t instr)
{ {
return (instr >> 6) & BP_MASK_TYPE; return (instr >> 6) & BP_MASK_TYPE;
} }
char* reg_changed(UINT32 reg1, UINT32 reg2) char* reg_changed(uint32_t reg1, uint32_t reg2)
{ {
static char chg_str[2] = {0}; static char chg_str[2] = {0};
@@ -69,80 +69,80 @@ char* reg_changed(UINT32 reg1, UINT32 reg2)
return chg_str; return chg_str;
} }
void set_mgmt_break(UINT32 *pAddr_break) void set_mgmt_break(uint32_t *pAddr_break)
{ {
mgmt_bp_ss[0].pAddr = NULL; mgmt_bp_ss[0].pAddr = NULL;
mgmt_bp_ss[0].pAddr = 0; mgmt_bp_ss[0].pAddr = 0;
// Don't overwrite user breaks // Don't overwrite user breaks
if (IsBreak(*pAddr_break) && (BreakGetType(*pAddr_break) == BP_USER_BASE)) if (IsBreak(*pAddr_break) && (BreakGetType(*pAddr_break) == BP_USER_BASE))
{ {
// sputs("Instruction at address ");print_word((long)pAddr_break);sputs(" is user break\n"); // sputs("Instruction at address ");print_word((long)pAddr_break);sputs(" is user break\n");
} }
else else
{ {
// Save original instruction // Save original instruction
mgmt_bp_ss[0].pAddr = pAddr_break; mgmt_bp_ss[0].pAddr = pAddr_break;
mgmt_bp_ss[0].instr = *(mgmt_bp_ss[0].pAddr); mgmt_bp_ss[0].instr = *(mgmt_bp_ss[0].pAddr);
// Replace instruction with managment breakpoint // Replace instruction with managment breakpoint
*(mgmt_bp_ss[0].pAddr) = BP_MGMT_SS(1); *(mgmt_bp_ss[0].pAddr) = BP_MGMT_SS(1);
ICACHE_invalidate_at(mgmt_bp_ss[0].pAddr); ICACHE_invalidate_at(mgmt_bp_ss[0].pAddr);
} }
} }
void singlestep(struct xcptcontext * xcp, UINT32 *pAddr_curr, UINT32 is_branch_shadow) void singlestep(struct xcptcontext * xcp, uint32_t *pAddr_curr, uint32_t is_branch_shadow)
{ {
int junk; int junk;
UINT32 branch_addr, reg, result, bp_type; uint32_t branch_addr, reg, result, bp_type;
UINT32 *pInstr, *pAddr_prev, *pAddr_next; uint32_t *pInstr, *pAddr_prev, *pAddr_next;
pAddr_prev = pAddr_curr - 1; pAddr_prev = pAddr_curr - 1;
pAddr_next = pAddr_curr + 1; pAddr_next = pAddr_curr + 1;
set_mgmt_break(pAddr_next); set_mgmt_break(pAddr_next);
mgmt_bp_ss[1].pAddr = NULL; mgmt_bp_ss[1].pAddr = NULL;
mgmt_bp_ss[1].pAddr = 0; mgmt_bp_ss[1].pAddr = 0;
// We have two possible management breaks, if previous instruction was branch or jump // We have two possible management breaks, if previous instruction was branch or jump
if (is_branch_shadow) if (is_branch_shadow)
{ {
result = tdisasm(g_buf, (long)pAddr_prev, *pAddr_prev, 0, &junk, &branch_addr, &reg); result = tdisasm(g_buf, (long)pAddr_prev, *pAddr_prev, 0, &junk, &branch_addr, &reg);
// Is jump target stored in register // Is jump target stored in register
if (result == 3) if (result == 3)
{ {
branch_addr = xcp->regs[reg&0x1F]; branch_addr = xcp->regs[reg&0x1F];
} }
// Don't overwrite user breaks // Don't overwrite user breaks
if (IsBreak(branch_addr) && (BreakGetType(branch_addr) == BP_USER_BASE)) if (IsBreak(branch_addr) && (BreakGetType(branch_addr) == BP_USER_BASE))
{ {
// sputs("Instruction at branch address ");print_word((long)branch_addr);sputs(" is user break\n"); // sputs("Instruction at branch address ");print_word((long)branch_addr);sputs(" is user break\n");
} }
else else
{ {
// Save original instruction // Save original instruction
mgmt_bp_ss[1].pAddr = (UINT32*)branch_addr; mgmt_bp_ss[1].pAddr = (uint32_t*)branch_addr;
mgmt_bp_ss[1].instr = *(mgmt_bp_ss[1].pAddr); mgmt_bp_ss[1].instr = *(mgmt_bp_ss[1].pAddr);
// Replace instruction with managment breakpoint // Replace instruction with managment breakpoint
*(mgmt_bp_ss[1].pAddr) = BP_MGMT_SS(2); *(mgmt_bp_ss[1].pAddr) = BP_MGMT_SS(2);
ICACHE_invalidate_at(mgmt_bp_ss[1].pAddr); ICACHE_invalidate_at(mgmt_bp_ss[1].pAddr);
} }
} }
} }
void dbg_handler(struct xcptcontext * xcp) void dbg_handler(struct xcptcontext * xcp)
{ {
UINT32 bp_addr, bp_index = 0, branch_addr, reg, result, bp_type; uint32_t bp_addr, bp_index = 0, branch_addr, reg, result, bp_type;
int junk, i, leave_isr, is_branch_shadow, is_user_bp; int junk, i, leave_isr, is_branch_shadow, is_user_bp;
UINT32 *pInstr, *pAddr_curr, *pAddr_prev, *pAddr_next; uint32_t *pInstr, *pAddr_curr, *pAddr_prev, *pAddr_next;
instr_info_t info; instr_info_t info;
is_user_bp = 0; is_user_bp = 0;
pAddr_curr = (UINT32*)xcp->epc; pAddr_curr = (uint32_t*)xcp->epc;
is_branch_shadow = ((xcp->cr & 0x80000000) == 0x80000000); is_branch_shadow = ((xcp->cr & 0x80000000) == 0x80000000);
if (is_branch_shadow) if (is_branch_shadow)
pAddr_curr++; pAddr_curr++;
@@ -209,92 +209,92 @@ void dbg_handler(struct xcptcontext * xcp)
} }
} }
sputs("\n"); sputs("\n");
PRINT_REG_CHG(" Status : ", xcp->sr, reg_changed(xcp->sr, xcp_last.sr)); PRINT_REG_CHG(" Status : ", xcp->sr, reg_changed(xcp->sr, xcp_last.sr));
PRINT_REG_CHG(" Cause : ", xcp->cr, reg_changed(xcp->cr, xcp_last.cr)); PRINT_REG_CHG(" Cause : ", xcp->cr, reg_changed(xcp->cr, xcp_last.cr));
PRINT_REG_CHG(" EPC : ", xcp->epc, reg_changed(xcp->epc, xcp_last.epc)); PRINT_REG_CHG(" EPC : ", xcp->epc, reg_changed(xcp->epc, xcp_last.epc));
PRINT_REG_CHG("BadAddr : ", xcp->baddr, reg_changed(xcp->baddr, xcp_last.baddr)); PRINT_REG_CHG("BadAddr : ", xcp->baddr, reg_changed(xcp->baddr, xcp_last.baddr));
sputs("\n"); sputs("\n");
PRINT_REG_CHG(" MDLO : ", xcp->mdlo, reg_changed(xcp->mdlo, xcp_last.mdlo)); PRINT_REG_CHG(" MDLO : ", xcp->mdlo, reg_changed(xcp->mdlo, xcp_last.mdlo));
PRINT_REG_CHG(" MDHI : ", xcp->mdhi, reg_changed(xcp->mdhi, xcp_last.mdhi)); PRINT_REG_CHG(" MDHI : ", xcp->mdhi, reg_changed(xcp->mdhi, xcp_last.mdhi));
sputs("\n"); sputs("\n");
sputs("Registers:\n"); sputs("Registers:\n");
PRINT_REG_CHG(" 0 (ze) : ", xcp->regs[0], reg_changed(xcp->regs[0], xcp_last.regs[0])); PRINT_REG_CHG(" 0 (ze) : ", xcp->regs[0], reg_changed(xcp->regs[0], xcp_last.regs[0]));
PRINT_REG_CHG(" 1 (at) : ", xcp->regs[1], reg_changed(xcp->regs[1], xcp_last.regs[1])); PRINT_REG_CHG(" 1 (at) : ", xcp->regs[1], reg_changed(xcp->regs[1], xcp_last.regs[1]));
PRINT_REG_CHG(" 2 (v0) : ", xcp->regs[2], reg_changed(xcp->regs[2], xcp_last.regs[2])); PRINT_REG_CHG(" 2 (v0) : ", xcp->regs[2], reg_changed(xcp->regs[2], xcp_last.regs[2]));
PRINT_REG_CHG(" 3 (v1) : ", xcp->regs[3], reg_changed(xcp->regs[3], xcp_last.regs[3])); PRINT_REG_CHG(" 3 (v1) : ", xcp->regs[3], reg_changed(xcp->regs[3], xcp_last.regs[3]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG(" 4 (a0) : ", xcp->regs[4], reg_changed(xcp->regs[4], xcp_last.regs[4])); PRINT_REG_CHG(" 4 (a0) : ", xcp->regs[4], reg_changed(xcp->regs[4], xcp_last.regs[4]));
PRINT_REG_CHG(" 5 (a1) : ", xcp->regs[5], reg_changed(xcp->regs[5], xcp_last.regs[5])); PRINT_REG_CHG(" 5 (a1) : ", xcp->regs[5], reg_changed(xcp->regs[5], xcp_last.regs[5]));
PRINT_REG_CHG(" 6 (a2) : ", xcp->regs[6], reg_changed(xcp->regs[6], xcp_last.regs[6])); PRINT_REG_CHG(" 6 (a2) : ", xcp->regs[6], reg_changed(xcp->regs[6], xcp_last.regs[6]));
PRINT_REG_CHG(" 7 (a3) : ", xcp->regs[7], reg_changed(xcp->regs[7], xcp_last.regs[7])); PRINT_REG_CHG(" 7 (a3) : ", xcp->regs[7], reg_changed(xcp->regs[7], xcp_last.regs[7]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG(" 8 (t0) : ", xcp->regs[8], reg_changed(xcp->regs[8], xcp_last.regs[8])); PRINT_REG_CHG(" 8 (t0) : ", xcp->regs[8], reg_changed(xcp->regs[8], xcp_last.regs[8]));
PRINT_REG_CHG(" 9 (t1) : ", xcp->regs[9], reg_changed(xcp->regs[9], xcp_last.regs[9])); PRINT_REG_CHG(" 9 (t1) : ", xcp->regs[9], reg_changed(xcp->regs[9], xcp_last.regs[9]));
PRINT_REG_CHG("10 (t2) : ", xcp->regs[10], reg_changed(xcp->regs[10], xcp_last.regs[10])); PRINT_REG_CHG("10 (t2) : ", xcp->regs[10], reg_changed(xcp->regs[10], xcp_last.regs[10]));
PRINT_REG_CHG("11 (t3) : ", xcp->regs[11], reg_changed(xcp->regs[11], xcp_last.regs[11])); PRINT_REG_CHG("11 (t3) : ", xcp->regs[11], reg_changed(xcp->regs[11], xcp_last.regs[11]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG("12 (t4) : ", xcp->regs[12], reg_changed(xcp->regs[12], xcp_last.regs[12])); PRINT_REG_CHG("12 (t4) : ", xcp->regs[12], reg_changed(xcp->regs[12], xcp_last.regs[12]));
PRINT_REG_CHG("13 (t5) : ", xcp->regs[13], reg_changed(xcp->regs[13], xcp_last.regs[13])); PRINT_REG_CHG("13 (t5) : ", xcp->regs[13], reg_changed(xcp->regs[13], xcp_last.regs[13]));
PRINT_REG_CHG("14 (t6) : ", xcp->regs[14], reg_changed(xcp->regs[14], xcp_last.regs[14])); PRINT_REG_CHG("14 (t6) : ", xcp->regs[14], reg_changed(xcp->regs[14], xcp_last.regs[14]));
PRINT_REG_CHG("15 (t7) : ", xcp->regs[15], reg_changed(xcp->regs[15], xcp_last.regs[15])); PRINT_REG_CHG("15 (t7) : ", xcp->regs[15], reg_changed(xcp->regs[15], xcp_last.regs[15]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG("16 (s0) : ", xcp->regs[16], reg_changed(xcp->regs[16], xcp_last.regs[16])); PRINT_REG_CHG("16 (s0) : ", xcp->regs[16], reg_changed(xcp->regs[16], xcp_last.regs[16]));
PRINT_REG_CHG("17 (s1) : ", xcp->regs[17], reg_changed(xcp->regs[17], xcp_last.regs[17])); PRINT_REG_CHG("17 (s1) : ", xcp->regs[17], reg_changed(xcp->regs[17], xcp_last.regs[17]));
PRINT_REG_CHG("18 (s2) : ", xcp->regs[18], reg_changed(xcp->regs[18], xcp_last.regs[18])); PRINT_REG_CHG("18 (s2) : ", xcp->regs[18], reg_changed(xcp->regs[18], xcp_last.regs[18]));
PRINT_REG_CHG("19 (s3) : ", xcp->regs[19], reg_changed(xcp->regs[19], xcp_last.regs[19])); PRINT_REG_CHG("19 (s3) : ", xcp->regs[19], reg_changed(xcp->regs[19], xcp_last.regs[19]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG("20 (s4) : ", xcp->regs[20], reg_changed(xcp->regs[20], xcp_last.regs[20])); PRINT_REG_CHG("20 (s4) : ", xcp->regs[20], reg_changed(xcp->regs[20], xcp_last.regs[20]));
PRINT_REG_CHG("21 (s5) : ", xcp->regs[21], reg_changed(xcp->regs[21], xcp_last.regs[21])); PRINT_REG_CHG("21 (s5) : ", xcp->regs[21], reg_changed(xcp->regs[21], xcp_last.regs[21]));
PRINT_REG_CHG("22 (s6) : ", xcp->regs[22], reg_changed(xcp->regs[22], xcp_last.regs[22])); PRINT_REG_CHG("22 (s6) : ", xcp->regs[22], reg_changed(xcp->regs[22], xcp_last.regs[22]));
PRINT_REG_CHG("23 (s7) : ", xcp->regs[23], reg_changed(xcp->regs[23], xcp_last.regs[23])); PRINT_REG_CHG("23 (s7) : ", xcp->regs[23], reg_changed(xcp->regs[23], xcp_last.regs[23]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG("24 (s8) : ", xcp->regs[24], reg_changed(xcp->regs[24], xcp_last.regs[24])); PRINT_REG_CHG("24 (s8) : ", xcp->regs[24], reg_changed(xcp->regs[24], xcp_last.regs[24]));
PRINT_REG_CHG("25 (s9) : ", xcp->regs[25], reg_changed(xcp->regs[25], xcp_last.regs[25])); PRINT_REG_CHG("25 (s9) : ", xcp->regs[25], reg_changed(xcp->regs[25], xcp_last.regs[25]));
PRINT_REG_CHG("26 (k0) : ", xcp->regs[26], reg_changed(xcp->regs[26], xcp_last.regs[26])); PRINT_REG_CHG("26 (k0) : ", xcp->regs[26], reg_changed(xcp->regs[26], xcp_last.regs[26]));
PRINT_REG_CHG("27 (k1) : ", xcp->regs[27], reg_changed(xcp->regs[27], xcp_last.regs[27])); PRINT_REG_CHG("27 (k1) : ", xcp->regs[27], reg_changed(xcp->regs[27], xcp_last.regs[27]));
sputs("\n"); sputs("\n");
PRINT_REG_CHG("28 (gp) : ", xcp->regs[28], reg_changed(xcp->regs[28], xcp_last.regs[28])); PRINT_REG_CHG("28 (gp) : ", xcp->regs[28], reg_changed(xcp->regs[28], xcp_last.regs[28]));
PRINT_REG_CHG("29 (sp) : ", xcp->regs[29], reg_changed(xcp->regs[29], xcp_last.regs[29])); PRINT_REG_CHG("29 (sp) : ", xcp->regs[29], reg_changed(xcp->regs[29], xcp_last.regs[29]));
PRINT_REG_CHG("30 (fp) : ", xcp->regs[30], reg_changed(xcp->regs[30], xcp_last.regs[30])); PRINT_REG_CHG("30 (fp) : ", xcp->regs[30], reg_changed(xcp->regs[30], xcp_last.regs[30]));
PRINT_REG_CHG("31 (ra) : ", xcp->regs[31], reg_changed(xcp->regs[31], xcp_last.regs[31])); PRINT_REG_CHG("31 (ra) : ", xcp->regs[31], reg_changed(xcp->regs[31], xcp_last.regs[31]));
sputs("\n"); sputs("\n");
sputs("\n"); sputs("\n");
// sputs(g_state_names[g_state]);sputs("\n"); // sputs(g_state_names[g_state]);sputs("\n");
// sputs("\n"); // sputs("\n");
pInstr = pAddr_prev; pInstr = pAddr_prev;
// Disassemble instructions // Disassemble instructions
for (i=0; i < 3; i++) for (i=0; i < 3; i++)
{ {
print_word((long)pInstr); print_word((long)pInstr);
if (pInstr != pAddr_curr) if (pInstr != pAddr_curr)
{ {
if (IsBreak(*pInstr) && (BreakGetType(*pInstr) == BP_USER_BASE)) if (IsBreak(*pInstr) && (BreakGetType(*pInstr) == BP_USER_BASE))
{ {
tdisasm(g_buf, (long)user_bp[BP_GET_ID(*pInstr)].pAddr, user_bp[BP_GET_ID(*pInstr)].instr, 0, &junk, &junk, &junk); tdisasm(g_buf, (long)user_bp[BP_GET_ID(*pInstr)].pAddr, user_bp[BP_GET_ID(*pInstr)].instr, 0, &junk, &junk, &junk);
sputs(": b("); print_byte((char)BP_GET_ID(*pInstr)); sputs(") "); sputs(": b("); print_byte((char)BP_GET_ID(*pInstr)); sputs(") ");
} }
else else
{ {
tdisasm(g_buf, (long)pInstr, *pInstr, 0, &junk, &junk, &junk); tdisasm(g_buf, (long)pInstr, *pInstr, 0, &junk, &junk, &junk);
sputs(": "); sputs(": ");
} }
} }
else else
{ {
tdisasm(g_buf, (long)pInstr, *pInstr, 0, &junk, &junk, &junk); tdisasm(g_buf, (long)pInstr, *pInstr, 0, &junk, &junk, &junk);
if (is_user_bp) if (is_user_bp)
{ {
sputs(": b("); print_byte((char)bp_index); sputs(")-> "); sputs(": b("); print_byte((char)bp_index); sputs(")-> ");
} }
else else
{ {
sputs(": -> "); sputs(": -> ");
} }
} }
sputs(g_buf); sputs(g_buf);
sputs("\n"); sputs("\n");
@@ -323,7 +323,7 @@ void dbg_handler(struct xcptcontext * xcp)
branch_addr = xcp->regs[reg&0x1F]; branch_addr = xcp->regs[reg&0x1F];
} }
// Save original instruction // Save original instruction
mgmt_bp_ru[1].pAddr = (UINT32*)branch_addr; mgmt_bp_ru[1].pAddr = (uint32_t*)branch_addr;
mgmt_bp_ru[1].instr = *(mgmt_bp_ru[1].pAddr); mgmt_bp_ru[1].instr = *(mgmt_bp_ru[1].pAddr);
// Replace instruction with managment breakpoint // Replace instruction with managment breakpoint
*(mgmt_bp_ru[1].pAddr) = BP_MGMT_RU(bp_index); *(mgmt_bp_ru[1].pAddr) = BP_MGMT_RU(bp_index);
@@ -354,8 +354,8 @@ void dbg_handler(struct xcptcontext * xcp)
printf("Enter breakpoint: "); printf("Enter breakpoint: ");
scanf("%x", &bp_addr); scanf("%x", &bp_addr);
printf("Insert breakpoint at %.8X\n", bp_addr); printf("Insert breakpoint at %.8X\n", bp_addr);
user_bp[g_bp_count].pAddr = (UINT32*)bp_addr; user_bp[g_bp_count].pAddr = (uint32_t*)bp_addr;
user_bp[g_bp_count].instr = *(user_bp[g_bp_count].pAddr); user_bp[g_bp_count].instr = *(user_bp[g_bp_count].pAddr);
*(user_bp[g_bp_count].pAddr) = BP_USER(g_bp_count); *(user_bp[g_bp_count].pAddr) = BP_USER(g_bp_count);
@@ -384,82 +384,82 @@ void dbg_handler(struct xcptcontext * xcp)
xcp->epc += 4; // Skip ordinary program breaks xcp->epc += 4; // Skip ordinary program breaks
} }
} }
singlestep(xcp, pAddr_curr, is_branch_shadow); singlestep(xcp, pAddr_curr, is_branch_shadow);
break;
case 'e':
g_state = STATE_STEP_SINGLE;
g_is_ss = 1;
leave_isr = 1;
if (is_user_bp)
break;
if (IsBreak(*pAddr_curr))
{
if (BreakGetType(*pAddr_curr) == BP_USER_BASE)
{
break;
}
else
{
xcp->epc += 4; // Skip ordinary program breaks
}
}
pInstr = pAddr_curr;
do
{
result = instr_info(*pInstr, &info);
if (result == INSTR_TYPE_JUMP)
{
if (info.rs == 0x1F)
break;
}
else if (result == INSTR_TYPE_LOAD)
{
if (info.rs == 0x1F)
break;
}
pInstr++;
} while(1);
// sputs("Return found at "); print_word((long)pInstr);sputs("\n");
set_mgmt_break(pInstr);
break; break;
case 'e':
g_state = STATE_STEP_SINGLE;
g_is_ss = 1;
leave_isr = 1;
if (is_user_bp)
break;
if (IsBreak(*pAddr_curr))
{
if (BreakGetType(*pAddr_curr) == BP_USER_BASE)
{
break;
}
else
{
xcp->epc += 4; // Skip ordinary program breaks
}
}
pInstr = pAddr_curr;
do
{
result = instr_info(*pInstr, &info);
if (result == INSTR_TYPE_JUMP)
{
if (info.rs == 0x1F)
break;
}
else if (result == INSTR_TYPE_LOAD)
{
if (info.rs == 0x1F)
break;
}
pInstr++;
} while(1);
// sputs("Return found at "); print_word((long)pInstr);sputs("\n");
set_mgmt_break(pInstr);
break;
case 'p': case 'p':
g_state = STATE_STEP_PROC; g_state = STATE_STEP_PROC;
g_is_ss = 1; g_is_ss = 1;
leave_isr = 1; leave_isr = 1;
if (is_user_bp) if (is_user_bp)
break; break;
if (IsBreak(*pAddr_curr)) if (IsBreak(*pAddr_curr))
{ {
if (BreakGetType(*pAddr_curr) == BP_USER_BASE) if (BreakGetType(*pAddr_curr) == BP_USER_BASE)
{ {
break; break;
} }
else else
{ {
xcp->epc += 4; // Skip ordinary program breaks xcp->epc += 4; // Skip ordinary program breaks
} }
} }
result = instr_info(*pAddr_curr, &info); result = instr_info(*pAddr_curr, &info);
if ((result == INSTR_TYPE_JUMP) && (info.flags & INSTR_FLAGS_JUMP_LINK)) if ((result == INSTR_TYPE_JUMP) && (info.flags & INSTR_FLAGS_JUMP_LINK))
{ {
singlestep(xcp, pAddr_next, 0); singlestep(xcp, pAddr_next, 0);
// sputs("Skip sub-routine\n"); // sputs("Skip sub-routine\n");
} }
else else
{ {
singlestep(xcp, pAddr_curr, is_branch_shadow); singlestep(xcp, pAddr_curr, is_branch_shadow);
} }
break; break;
default: default:
@@ -467,7 +467,7 @@ void dbg_handler(struct xcptcontext * xcp)
} }
} while (!leave_isr); } while (!leave_isr);
memcpy(&xcp_last, xcp, sizeof(EXCEPTION_CONTEXT)); memcpy(&xcp_last, xcp, sizeof(EXCEPTION_CONTEXT));
} }
void debug_int(struct xcptcontext * xcp) void debug_int(struct xcptcontext * xcp)
src/libsys/mips_gfx.c
+100 -100
View File
@@ -12,7 +12,7 @@ static vga_hw_t *g_pRegs;
// ------------------------------------------------------------- // -------------------------------------------------------------
// Functions // Functions
// ------------------------------------------------------------- // -------------------------------------------------------------
void __gfx_block_set_8(UINT32* pDst, UINT32 value) void __gfx_block_set_8(uint32_t* pDst, uint32_t value)
{ {
__asm__ volatile __asm__ volatile
( (
@@ -29,7 +29,7 @@ void __gfx_block_set_8(UINT32* pDst, UINT32 value)
); );
} }
void __gfx_block_copy_8(UINT32* pDst, UINT32* pSrc) void __gfx_block_copy_8(uint32_t* pDst, uint32_t* pSrc)
{ {
__asm__ volatile __asm__ volatile
( (
@@ -59,7 +59,7 @@ void __gfx_block_copy_8(UINT32* pDst, UINT32* pSrc)
); );
} }
void _GFX_copy32(UINT32* pDst, UINT32* pSrc, UINT32 ndwords) void _GFX_copy32(uint32_t* pDst, uint32_t* pSrc, uint32_t ndwords)
{ {
while (ndwords > 3) while (ndwords > 3)
{ {
@@ -75,7 +75,7 @@ void _GFX_copy32(UINT32* pDst, UINT32* pSrc, UINT32 ndwords)
} }
} }
void _GFX_memset32(UINT32* pDst, UINT32 value, UINT32 ndwords) void _GFX_memset32(uint32_t* pDst, uint32_t value, uint32_t ndwords)
{ {
while (ndwords > 3) while (ndwords > 3)
{ {
@@ -90,10 +90,10 @@ void _GFX_memset32(UINT32* pDst, UINT32 value, UINT32 ndwords)
} }
} }
void _GFX_copy32_hw(UINT32* pDst, UINT32* pSrc, UINT32 ndwords, UINT32 wait_finish) void _GFX_copy32_hw(uint32_t* pDst, uint32_t* pSrc, uint32_t ndwords, uint32_t wait_finish)
{ {
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = 0; g_pRegs->pVGA_src0_dimx = 0;
g_pRegs->pVGA_dst_dimx = 0; g_pRegs->pVGA_dst_dimx = 0;
g_pRegs->pVGA_nx = ndwords; g_pRegs->pVGA_nx = ndwords;
@@ -111,9 +111,9 @@ void _GFX_copy32_hw(UINT32* pDst, UINT32* pSrc, UINT32 ndwords, UINT32 wait_fini
} }
void _GFX_memset32_hw(UINT32* pDst, UINT32 value, UINT32 ndwords, UINT32 wait_finish) void _GFX_memset32_hw(uint32_t* pDst, uint32_t value, uint32_t ndwords, uint32_t wait_finish)
{ {
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = 0; g_pRegs->pVGA_src0_dimx = 0;
g_pRegs->pVGA_dst_dimx = 0; g_pRegs->pVGA_dst_dimx = 0;
g_pRegs->pVGA_nx = ndwords; g_pRegs->pVGA_nx = ndwords;
@@ -131,10 +131,10 @@ void _GFX_memset32_hw(UINT32* pDst, UINT32 value, UINT32 ndwords, UINT32 wait_fi
} }
void _GFX_BLIT_const(UINT32* pDst, UINT32 xdim_dst, UINT32 xmin, UINT32 ymin, UINT32 xmax, UINT32 ymax, UINT32 value) void _GFX_BLIT_const(uint32_t* pDst, uint32_t xdim_dst, uint32_t xmin, uint32_t ymin, uint32_t xmax, uint32_t ymax, uint32_t value)
{ {
UINT32 xmax8, x, y; uint32_t xmax8, x, y;
UINT32 *pStart, *pEnd; uint32_t *pStart, *pEnd;
xmax8 = xmax - ((xmax-xmin)%8); xmax8 = xmax - ((xmax-xmin)%8);
for (y=ymin; y < ymax; y += xdim_dst) for (y=ymin; y < ymax; y += xdim_dst)
@@ -154,13 +154,13 @@ void _GFX_BLIT_const(UINT32* pDst, UINT32 xdim_dst, UINT32 xmin, UINT32 ymin, UI
} }
} }
void _GFX_BLIT_const_hw(UINT32* pDst, UINT32 xdim_dst, UINT32 xmin, UINT32 ymin, UINT32 xmax, UINT32 ymax, UINT32 value, UINT32 wait_finish) void _GFX_BLIT_const_hw(uint32_t* pDst, uint32_t xdim_dst, uint32_t xmin, uint32_t ymin, uint32_t xmax, uint32_t ymax, uint32_t value, uint32_t wait_finish)
{ {
UINT32 *pStart, *pEnd; uint32_t *pStart, *pEnd;
pStart = (UINT32*)&pDst[xmin + ymin*xdim_dst]; pStart = (uint32_t*)&pDst[xmin + ymin*xdim_dst];
g_pRegs->pVGA_dst = (UINT32)pStart; g_pRegs->pVGA_dst = (uint32_t)pStart;
g_pRegs->pVGA_dst_dimx = xdim_dst; g_pRegs->pVGA_dst_dimx = xdim_dst;
g_pRegs->pVGA_nx = xmax - xmin + 1; g_pRegs->pVGA_nx = xmax - xmin + 1;
g_pRegs->pVGA_ny = ymax - ymin + 1; g_pRegs->pVGA_ny = ymax - ymin + 1;
@@ -185,14 +185,14 @@ void GFX_DirtyRectSetClean(gfx_t *pObj, buf_t *pBuf)
pBuf->is_dirty = 0; pBuf->is_dirty = 0;
} }
void GFX_DirtyRectInit(gfx_t *pObj, buf_t *pBuf, UINT32 w, UINT32 h) void GFX_DirtyRectInit(gfx_t *pObj, buf_t *pBuf, uint32_t w, uint32_t h)
{ {
pBuf->w = w; pBuf->w = w;
pBuf->h = h; pBuf->h = h;
GFX_DirtyRectSetClean(pObj, pBuf); GFX_DirtyRectSetClean(pObj, pBuf);
} }
void GFX_DirtyRectUpdate(gfx_t *pObj, buf_t *pBuf, UINT32 xmin, UINT32 xmax, UINT32 ymin, UINT32 ymax) void GFX_DirtyRectUpdate(gfx_t *pObj, buf_t *pBuf, uint32_t xmin, uint32_t xmax, uint32_t ymin, uint32_t ymax)
{ {
if (xmin < pBuf->dirty.xmin) if (xmin < pBuf->dirty.xmin)
@@ -231,9 +231,9 @@ void GFX_DirtyRectUpdate(gfx_t *pObj, buf_t *pBuf, UINT32 xmin, UINT32 xmax, UIN
void GFX_DirtyRectCopy(gfx_t *pObj, buf_t *pBuf) void GFX_DirtyRectCopy(gfx_t *pObj, buf_t *pBuf)
{ {
UINT32 xmin, xmax, xmax8, ymin, ymax, x, y; uint32_t xmin, xmax, xmax8, ymin, ymax, x, y;
UINT32 *pDst, *pDst_end; uint32_t *pDst, *pDst_end;
UINT32 *pSrc, *pSrc_end; uint32_t *pSrc, *pSrc_end;
xmin = pBuf->dirty.xmin; xmin = pBuf->dirty.xmin;
xmax = pBuf->dirty.xmax; xmax = pBuf->dirty.xmax;
@@ -245,15 +245,15 @@ void GFX_DirtyRectCopy(gfx_t *pObj, buf_t *pBuf)
ymax *= pBuf->w; ymax *= pBuf->w;
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pSrc = (UINT32*)&pBuf->pLast->pFB[xmin + ymin]; pSrc = (uint32_t*)&pBuf->pLast->pFB[xmin + ymin];
pDst = (UINT32*)&pBuf->pFB[xmin + ymin]; pDst = (uint32_t*)&pBuf->pFB[xmin + ymin];
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = (UINT32)pBuf->w; g_pRegs->pVGA_src0_dimx = (uint32_t)pBuf->w;
g_pRegs->pVGA_dst_dimx = (UINT32)pBuf->w; g_pRegs->pVGA_dst_dimx = (uint32_t)pBuf->w;
g_pRegs->pVGA_nx = (UINT32)(pBuf->dirty.xmax-pBuf->dirty.xmin); g_pRegs->pVGA_nx = (uint32_t)(pBuf->dirty.xmax-pBuf->dirty.xmin);
g_pRegs->pVGA_ny = (UINT32)(pBuf->dirty.ymax-pBuf->dirty.ymin); g_pRegs->pVGA_ny = (uint32_t)(pBuf->dirty.ymax-pBuf->dirty.ymin);
g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL; g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -289,7 +289,7 @@ void GFX_init(gfx_t *pObj)
{ {
int i; int i;
buf_t *pBuf; buf_t *pBuf;
UINT32 w, h, fps; uint32_t w, h, fps;
g_pRegs = (vga_hw_t*)SYS_VGA_CTRL; g_pRegs = (vga_hw_t*)SYS_VGA_CTRL;
@@ -305,19 +305,19 @@ void GFX_init(gfx_t *pObj)
pObj->h = h; pObj->h = h;
// Init background buffer // Init background buffer
pObj->pBG = (UINT32*)calloc(w * h, sizeof(buf_t)); pObj->pBG = (uint32_t*)calloc(w * h, sizeof(buf_t));
// Init framebuffers // Init framebuffers
pObj->pBuf = (buf_t*)calloc(1, sizeof(buf_t)); pObj->pBuf = (buf_t*)calloc(1, sizeof(buf_t));
pBuf = pObj->pBuf; pBuf = pObj->pBuf;
pBuf->pFB = (UINT32*)calloc((w+8) * h, sizeof(UINT32)); // w+8 because of dirty rectangle 8 byte min. x-size pBuf->pFB = (uint32_t*)calloc((w+8) * h, sizeof(uint32_t)); // w+8 because of dirty rectangle 8 byte min. x-size
for (i=1; i < GFX_NUM_FRAME_BUFFERS; i++) for (i=1; i < GFX_NUM_FRAME_BUFFERS; i++)
{ {
pBuf->pNext = (buf_t*)calloc(1, sizeof(buf_t)); pBuf->pNext = (buf_t*)calloc(1, sizeof(buf_t));
pBuf->pNext->pLast = pBuf; pBuf->pNext->pLast = pBuf;
pBuf = pBuf->pNext; pBuf = pBuf->pNext;
pBuf->pFB = (UINT32*)calloc((w+8) * h, sizeof(UINT32)); // w+8 because of dirty rectangle 8 byte min. x-size pBuf->pFB = (uint32_t*)calloc((w+8) * h, sizeof(uint32_t)); // w+8 because of dirty rectangle 8 byte min. x-size
} }
pObj->pBuf->pLast = pBuf; pObj->pBuf->pLast = pBuf;
pBuf->pNext = pObj->pBuf; pBuf->pNext = pObj->pBuf;
@@ -331,19 +331,19 @@ void GFX_init(gfx_t *pObj)
pBuf = pBuf->pNext; pBuf = pBuf->pNext;
} }
g_pRegs->pVGA_front = (UINT32)pObj->pBuf->pLast->pFB; g_pRegs->pVGA_front = (uint32_t)pObj->pBuf->pLast->pFB;
g_pRegs->pVGA_back = (UINT32)pObj->pBuf->pLast->pFB; g_pRegs->pVGA_back = (uint32_t)pObj->pBuf->pLast->pFB;
g_pRegs->pVGA_ctrl |= SYS_VGA_BIT_MSTEN; g_pRegs->pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
} }
void GFX_set_background(gfx_t *pObj, UINT32 *pImage, UINT32 image_nx, UINT32 image_ny, UINT32 image_scale_x, UINT32 image_scale_y) void GFX_set_background(gfx_t *pObj, uint32_t *pImage, uint32_t image_nx, uint32_t image_ny, uint32_t image_scale_x, uint32_t image_scale_y)
{ {
UINT32 off_x, off_y; uint32_t off_x, off_y;
UINT32 i, j; uint32_t i, j;
UINT32 *pDst, *pSrc; uint32_t *pDst, *pSrc;
buf_t *pBuf; buf_t *pBuf;
if (!pImage) if (!pImage)
@@ -354,15 +354,15 @@ void GFX_set_background(gfx_t *pObj, UINT32 *pImage, UINT32 image_nx, UINT32 ima
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pDst = ((UINT32*)pObj->pBG) + pObj->w*off_y + off_x; pDst = ((uint32_t*)pObj->pBG) + pObj->w*off_y + off_x;
pSrc = pImage; pSrc = pImage;
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = (UINT32)0; g_pRegs->pVGA_src0_dimx = (uint32_t)0;
g_pRegs->pVGA_dst_dimx = (UINT32)0; g_pRegs->pVGA_dst_dimx = (uint32_t)0;
g_pRegs->pVGA_nx = (UINT32)image_ny*image_nx; g_pRegs->pVGA_nx = (uint32_t)image_ny*image_nx;
g_pRegs->pVGA_ny = (UINT32)1; g_pRegs->pVGA_ny = (uint32_t)1;
g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL; g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -374,12 +374,12 @@ void GFX_set_background(gfx_t *pObj, UINT32 *pImage, UINT32 image_nx, UINT32 ima
pDst = pBuf->pFB; pDst = pBuf->pFB;
pSrc = pObj->pBG; pSrc = pObj->pBG;
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = (UINT32)0; g_pRegs->pVGA_src0_dimx = (uint32_t)0;
g_pRegs->pVGA_dst_dimx = (UINT32)0; g_pRegs->pVGA_dst_dimx = (uint32_t)0;
g_pRegs->pVGA_nx = (UINT32)image_ny*image_nx; g_pRegs->pVGA_nx = (uint32_t)image_ny*image_nx;
g_pRegs->pVGA_ny = (UINT32)1; g_pRegs->pVGA_ny = (uint32_t)1;
g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL; g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -390,7 +390,7 @@ void GFX_set_background(gfx_t *pObj, UINT32 *pImage, UINT32 image_nx, UINT32 ima
#else #else
pDst = ((UINT32*)pObj->pBG) + pObj->w*off_y + off_x; pDst = ((uint32_t*)pObj->pBG) + pObj->w*off_y + off_x;
pSrc = pImage; pSrc = pImage;
for (i=0; i < image_ny*image_nx; i += 8) for (i=0; i < image_ny*image_nx; i += 8)
@@ -423,13 +423,13 @@ void GFX_set_background(gfx_t *pObj, UINT32 *pImage, UINT32 image_nx, UINT32 ima
} }
void GFX_frame(gfx_t *pObj, UINT32 sync_mode) void GFX_frame(gfx_t *pObj, uint32_t sync_mode)
{ {
// Wait until back buffer becomes front // Wait until back buffer becomes front
if (sync_mode == GFX_FRAME_SYNC) if (sync_mode == GFX_FRAME_SYNC)
{ {
while(g_pRegs->pVGA_front == (UINT32)pObj->pBuf->pFB); while(g_pRegs->pVGA_front == (uint32_t)pObj->pBuf->pFB);
} }
GFX_copy_front2back(pObj); GFX_copy_front2back(pObj);
@@ -445,7 +445,7 @@ void GFX_frame(gfx_t *pObj, UINT32 sync_mode)
void GFX_show(gfx_t *pObj) void GFX_show(gfx_t *pObj)
{ {
g_pRegs->pVGA_back = (UINT32)pObj->pBuf->pFB; g_pRegs->pVGA_back = (uint32_t)pObj->pBuf->pFB;
pObj->pBuf = pObj->pBuf->pNext; pObj->pBuf = pObj->pBuf->pNext;
} }
@@ -469,22 +469,22 @@ void GFX_copy_front2back(gfx_t *pObj)
} }
} }
void GFX_get_FB_front(gfx_t *pObj, UINT32 **ppFB) void GFX_get_FB_front(gfx_t *pObj, uint32_t **ppFB)
{ {
*ppFB = pObj->pBuf->pLast->pFB; *ppFB = pObj->pBuf->pLast->pFB;
} }
void box_create(box_t *pObj, UINT32 w, UINT32 h) void box_create(box_t *pObj, uint32_t w, uint32_t h)
{ {
pObj->w = w; pObj->w = w;
pObj->h = h; pObj->h = h;
} }
void GFX_restore(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy) void GFX_restore(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy)
{ {
UINT32 xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny; uint32_t xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny;
UINT32 *pDst, *pDst_end; uint32_t *pDst, *pDst_end;
UINT32 *pSrc, *pSrc_end; uint32_t *pSrc, *pSrc_end;
buf_t *pBuf; buf_t *pBuf;
if (pBox) if (pBox)
@@ -529,15 +529,15 @@ void GFX_restore(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy)
ymax *= pObj->w; ymax *= pObj->w;
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pSrc = (UINT32*)&pObj->pBG[xmin + ymin]; pSrc = (uint32_t*)&pObj->pBG[xmin + ymin];
pDst = (UINT32*)&pBuf->pFB[xmin + ymin]; pDst = (uint32_t*)&pBuf->pFB[xmin + ymin];
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_src0_dimx = (UINT32)pObj->w; g_pRegs->pVGA_src0_dimx = (uint32_t)pObj->w;
g_pRegs->pVGA_dst_dimx = (UINT32)pObj->w; g_pRegs->pVGA_dst_dimx = (uint32_t)pObj->w;
g_pRegs->pVGA_nx = (UINT32)nx; g_pRegs->pVGA_nx = (uint32_t)nx;
g_pRegs->pVGA_ny = (UINT32)ny; g_pRegs->pVGA_ny = (uint32_t)ny;
g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL; g_pRegs->pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -569,10 +569,10 @@ void GFX_restore(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy)
} }
void GFX_box_draw_direct(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 color) void GFX_box_draw_direct(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy, uint32_t color)
{ {
UINT32 xmin, xmax, xmax8, ymin, ymax, x, y; uint32_t xmin, xmax, xmax8, ymin, ymax, x, y;
UINT32 *pFB, *pFB_end; uint32_t *pFB, *pFB_end;
buf_t *pBuf; buf_t *pBuf;
pBuf = pObj->pBuf->pLast; pBuf = pObj->pBuf->pLast;
@@ -609,10 +609,10 @@ void GFX_box_draw_direct(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UIN
} }
void GFX_box_draw(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 color) void GFX_box_draw(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy, uint32_t color)
{ {
UINT32 xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny; uint32_t xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny;
UINT32 *pFB, *pFB_end; uint32_t *pFB, *pFB_end;
buf_t *pBuf; buf_t *pBuf;
xmin = posx; xmin = posx;
@@ -646,12 +646,12 @@ void GFX_box_draw(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 col
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pFB = (UINT32*)&pBuf->pFB[xmin + ymin]; pFB = (uint32_t*)&pBuf->pFB[xmin + ymin];
g_pRegs->pVGA_dst = (UINT32)pFB; g_pRegs->pVGA_dst = (uint32_t)pFB;
g_pRegs->pVGA_dst_dimx = (UINT32)pObj->w; g_pRegs->pVGA_dst_dimx = (uint32_t)pObj->w;
g_pRegs->pVGA_nx = (UINT32)nx; g_pRegs->pVGA_nx = (uint32_t)nx;
g_pRegs->pVGA_ny = (UINT32)ny; g_pRegs->pVGA_ny = (uint32_t)ny;
g_pRegs->pVGA_color = color; g_pRegs->pVGA_color = color;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -681,10 +681,10 @@ void GFX_box_draw(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 col
#endif #endif
} }
void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 color) void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy, uint32_t color)
{ {
UINT32 xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny; uint32_t xmin, xmax, xmax8, ymin, ymax, x, y, nx, ny;
UINT32 *pFB, *pFB_end; uint32_t *pFB, *pFB_end;
xmin = posx; xmin = posx;
xmax = pBox->w + posx - 0; xmax = pBox->w + posx - 0;
@@ -705,12 +705,12 @@ void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pFB = (UINT32*)&pObj->pBG[xmin + ymin]; pFB = (uint32_t*)&pObj->pBG[xmin + ymin];
g_pRegs->pVGA_dst = (UINT32)pFB; g_pRegs->pVGA_dst = (uint32_t)pFB;
g_pRegs->pVGA_dst_dimx = (UINT32)pObj->w; g_pRegs->pVGA_dst_dimx = (uint32_t)pObj->w;
g_pRegs->pVGA_nx = (UINT32)nx; g_pRegs->pVGA_nx = (uint32_t)nx;
g_pRegs->pVGA_ny = (UINT32)ny; g_pRegs->pVGA_ny = (uint32_t)ny;
g_pRegs->pVGA_color = color; g_pRegs->pVGA_color = color;
while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY); while (g_pRegs->pVGA_ctrl & SYS_VGA_BIT_BLIT_BSY);
@@ -739,15 +739,15 @@ void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32
} }
void GFX_box_blit_bg(gfx_t *pObj, box_t *pBox, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst) void GFX_box_blit_bg(gfx_t *pObj, box_t *pBox, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst)
{ {
UINT32 x_src, y_src, xmax8_src; uint32_t x_src, y_src, xmax8_src;
UINT32 x_dst, y_dst, xmax8_dst; uint32_t x_dst, y_dst, xmax8_dst;
UINT32 xmin_src, xmax_src, ymin_src, ymax_src; uint32_t xmin_src, xmax_src, ymin_src, ymax_src;
UINT32 xmin_dst, xmax_dst, ymin_dst, ymax_dst; uint32_t xmin_dst, xmax_dst, ymin_dst, ymax_dst;
UINT32 *pDst, *pDst_end; uint32_t *pDst, *pDst_end;
UINT32 *pSrc, *pSrc_end; uint32_t *pSrc, *pSrc_end;
buf_t *pBuf; buf_t *pBuf;
pBuf = pObj->pBuf->pNext; pBuf = pObj->pBuf->pNext;
@@ -781,12 +781,12 @@ void GFX_box_blit_bg(gfx_t *pObj, box_t *pBox, UINT32 pos_x_src, UINT32 pos_y_sr
pBuf = pObj->pBuf; pBuf = pObj->pBuf;
#ifdef USE_HW_BLITTER #ifdef USE_HW_BLITTER
pSrc = (UINT32*)&pObj->pBG[xmin_src + ymin_src*pObj->w]; pSrc = (uint32_t*)&pObj->pBG[xmin_src + ymin_src*pObj->w];
pDst = (UINT32*)&pBuf->pFB[xmin_dst + ymin_dst*pObj->w]; pDst = (uint32_t*)&pBuf->pFB[xmin_dst + ymin_dst*pObj->w];
g_pRegs->pVGA_src0 = (UINT32)pSrc; g_pRegs->pVGA_src0 = (uint32_t)pSrc;
g_pRegs->pVGA_src0_dimx = pObj->w; g_pRegs->pVGA_src0_dimx = pObj->w;
g_pRegs->pVGA_dst = (UINT32)pDst; g_pRegs->pVGA_dst = (uint32_t)pDst;
g_pRegs->pVGA_dst_dimx = pObj->w; g_pRegs->pVGA_dst_dimx = pObj->w;
g_pRegs->pVGA_nx = pBox->w; g_pRegs->pVGA_nx = pBox->w;
g_pRegs->pVGA_ny = pBox->h; g_pRegs->pVGA_ny = pBox->h;
src/libsys/mips_gfx.h
+46 -46
View File
@@ -12,58 +12,58 @@
// ------------------------------------------------------------- // -------------------------------------------------------------
typedef struct _sbox_t typedef struct _sbox_t
{ {
UINT32 w, h; uint32_t w, h;
} box_t; } box_t;
typedef struct _srect_t typedef struct _srect_t
{ {
UINT32 xmin, xmax; uint32_t xmin, xmax;
UINT32 ymin, ymax; uint32_t ymin, ymax;
} rect_t; } rect_t;
typedef struct _svga_hw_t typedef struct _svga_hw_t
{ {
UINT32 volatile pVGA_ctrl; // 0xA0030000 // R/W uint32_t volatile pVGA_ctrl; // 0xA0030000 // R/W
UINT32 volatile pVGA_ascii; // 0xA0030004 // R/W uint32_t volatile pVGA_ascii; // 0xA0030004 // R/W
UINT32 volatile pVGA_posx; // 0xA0030008 // R/W uint32_t volatile pVGA_posx; // 0xA0030008 // R/W
UINT32 volatile pVGA_posy; // 0xA003000C // R/W uint32_t volatile pVGA_posy; // 0xA003000C // R/W
UINT32 volatile pVGA_cgcol; // 0xA0030010 // R/W uint32_t volatile pVGA_cgcol; // 0xA0030010 // R/W
UINT32 volatile pVGA_res; // 0xA0030014 // RO uint32_t volatile pVGA_res; // 0xA0030014 // RO
UINT32 volatile pVGA_front; // 0xA0030018 // R/W uint32_t volatile pVGA_front; // 0xA0030018 // R/W
UINT32 volatile pVGA_back; // 0xA003001C // R/W uint32_t volatile pVGA_back; // 0xA003001C // R/W
UINT32 volatile pVGA_src0; // 0xA0030020 // R/W uint32_t volatile pVGA_src0; // 0xA0030020 // R/W
UINT32 volatile pVGA_src0_dimx; // 0xA0030024 // R/W uint32_t volatile pVGA_src0_dimx; // 0xA0030024 // R/W
UINT32 volatile pVGA_gap0; // 0xA0030028 // R/W uint32_t volatile pVGA_gap0; // 0xA0030028 // R/W
UINT32 volatile pVGA_gap1; // 0xA003002C // R/W uint32_t volatile pVGA_gap1; // 0xA003002C // R/W
UINT32 volatile pVGA_src1; // 0xA0030030 // R/W uint32_t volatile pVGA_src1; // 0xA0030030 // R/W
UINT32 volatile pVGA_src1_dimx; // 0xA0030034 // R/W uint32_t volatile pVGA_src1_dimx; // 0xA0030034 // R/W
UINT32 volatile pVGA_gap2; // 0xA0030038 // R/W uint32_t volatile pVGA_gap2; // 0xA0030038 // R/W
UINT32 volatile pVGA_gap3; // 0xA003003C // R/W uint32_t volatile pVGA_gap3; // 0xA003003C // R/W
UINT32 volatile pVGA_dst; // 0xA0030040 // R/W uint32_t volatile pVGA_dst; // 0xA0030040 // R/W
UINT32 volatile pVGA_dst_dimx; // 0xA0030044 // R/W uint32_t volatile pVGA_dst_dimx; // 0xA0030044 // R/W
UINT32 volatile pVGA_gap4; // 0xA0030048 // R/W uint32_t volatile pVGA_gap4; // 0xA0030048 // R/W
UINT32 volatile pVGA_gap5; // 0xA003004C // R/W uint32_t volatile pVGA_gap5; // 0xA003004C // R/W
UINT32 volatile pVGA_nx; // 0xA0030050 // R/W uint32_t volatile pVGA_nx; // 0xA0030050 // R/W
UINT32 volatile pVGA_ny; // 0xA0030054 // R/W uint32_t volatile pVGA_ny; // 0xA0030054 // R/W
UINT32 volatile pVGA_color; // 0xA0030058 // R/W uint32_t volatile pVGA_color; // 0xA0030058 // R/W
} vga_hw_t; } vga_hw_t;
typedef struct _sbuf_t typedef struct _sbuf_t
{ {
UINT32 *pFB; uint32_t *pFB;
struct _sbuf_t *pNext; struct _sbuf_t *pNext;
struct _sbuf_t *pLast; struct _sbuf_t *pLast;
UINT32 is_dirty; uint32_t is_dirty;
rect_t dirty; rect_t dirty;
UINT32 w, h; uint32_t w, h;
} buf_t; } buf_t;
typedef struct _sgfx_t typedef struct _sgfx_t
{ {
UINT32 w, h; uint32_t w, h;
buf_t *pBuf; buf_t *pBuf;
UINT32 *pBG; uint32_t *pBG;
rect_t restore; rect_t restore;
} gfx_t; } gfx_t;
@@ -71,23 +71,23 @@ typedef struct _sgfx_t
// ------------------------------------------------------------- // -------------------------------------------------------------
// Functions // Functions
// ------------------------------------------------------------- // -------------------------------------------------------------
void __gfx_block_set_8(UINT32* pDst, UINT32 value); void __gfx_block_set_8(uint32_t* pDst, uint32_t value);
void __gfx_block_copy_8(UINT32* pDst, UINT32* pSrc); void __gfx_block_copy_8(uint32_t* pDst, uint32_t* pSrc);
void _GFX_copy32(UINT32* pDst, UINT32* pSrc, UINT32 ndwords); void _GFX_copy32(uint32_t* pDst, uint32_t* pSrc, uint32_t ndwords);
void _GFX_copy32_hw(UINT32* pDst, UINT32* pSrc, UINT32 ndwords, UINT32 wait_finish); void _GFX_copy32_hw(uint32_t* pDst, uint32_t* pSrc, uint32_t ndwords, uint32_t wait_finish);
void _GFX_memset32(UINT32* pDst, UINT32 value, UINT32 ndwords); void _GFX_memset32(uint32_t* pDst, uint32_t value, uint32_t ndwords);
void _GFX_memset32_hw(UINT32* pDst, UINT32 value, UINT32 ndwords, UINT32 wait_finish); void _GFX_memset32_hw(uint32_t* pDst, uint32_t value, uint32_t ndwords, uint32_t wait_finish);
void _GFX_BLIT_const(UINT32* pDst, UINT32 xdim_dst, UINT32 xmin, UINT32 ymin, UINT32 xmax, UINT32 ymax, UINT32 value); void _GFX_BLIT_const(uint32_t* pDst, uint32_t xdim_dst, uint32_t xmin, uint32_t ymin, uint32_t xmax, uint32_t ymax, uint32_t value);
void _GFX_BLIT_const_hw(UINT32* pDst, UINT32 xdim_dst, UINT32 xmin, UINT32 ymin, UINT32 xmax, UINT32 ymax, UINT32 value, UINT32 wait_finish); void _GFX_BLIT_const_hw(uint32_t* pDst, uint32_t xdim_dst, uint32_t xmin, uint32_t ymin, uint32_t xmax, uint32_t ymax, uint32_t value, uint32_t wait_finish);
void GFX_init(gfx_t *pObj); void GFX_init(gfx_t *pObj);
void GFX_frame(gfx_t *pObj, UINT32 sync_mode); void GFX_frame(gfx_t *pObj, uint32_t sync_mode);
void GFX_show(gfx_t *pObj); void GFX_show(gfx_t *pObj);
void GFX_copy_front2back(gfx_t *pObj); void GFX_copy_front2back(gfx_t *pObj);
void GFX_get_FB_front(gfx_t *pObj, UINT32 **ppFB); void GFX_get_FB_front(gfx_t *pObj, uint32_t **ppFB);
void box_create(box_t *pObj, UINT32 w, UINT32 h); void box_create(box_t *pObj, uint32_t w, uint32_t h);
void GFX_restore(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy); void GFX_restore(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy);
void GFX_box_draw(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 color); void GFX_box_draw(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy, uint32_t color);
void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, UINT32 posx, UINT32 posy, UINT32 color); void GFX_box_draw_bg(gfx_t *pObj, box_t *pBox, uint32_t posx, uint32_t posy, uint32_t color);
void GFX_box_blit_bg(gfx_t *pObj, box_t *pBox, UINT32 pos_x_src, UINT32 pos_y_src, UINT32 pos_x_dst, UINT32 pos_y_dst); void GFX_box_blit_bg(gfx_t *pObj, box_t *pBox, uint32_t pos_x_src, uint32_t pos_y_src, uint32_t pos_x_dst, uint32_t pos_y_dst);
#endif // GFX_H #endif // GFX_H
src/libsys/mips_ps2.c
+14 -14
View File
@@ -6,16 +6,16 @@
ps2_if_t ps2_if[2] = ps2_if_t ps2_if[2] =
{ {
{ps2_type_unknown, (UINT32*)SYS_PS2_0_STAT, (UINT32*)SYS_PS2_0_DATA}, {ps2_type_unknown, (uint32_t*)SYS_PS2_0_STAT, (uint32_t*)SYS_PS2_0_DATA},
{ps2_type_unknown, (UINT32*)SYS_PS2_1_STAT, (UINT32*)SYS_PS2_1_DATA} {ps2_type_unknown, (uint32_t*)SYS_PS2_1_STAT, (uint32_t*)SYS_PS2_1_DATA}
}; };
UINT32 PS2_get_num_if(void) uint32_t PS2_get_num_if(void)
{ {
return (sizeof(ps2_if)/sizeof(ps2_if_t)); return (sizeof(ps2_if)/sizeof(ps2_if_t));
} }
ps2_if_t *PS2_get_if(UINT32 port) ps2_if_t *PS2_get_if(uint32_t port)
{ {
if (port < PS2_get_num_if()) if (port < PS2_get_num_if())
return &ps2_if[port]; return &ps2_if[port];
@@ -23,7 +23,7 @@ ps2_if_t *PS2_get_if(UINT32 port)
return NULL; return NULL;
} }
void PS2_byte_write(UINT32 port, UINT8 byte) void PS2_byte_write(uint32_t port, uint8_t byte)
{ {
ps2_if_t *pIF; ps2_if_t *pIF;
@@ -31,10 +31,10 @@ void PS2_byte_write(UINT32 port, UINT8 byte)
while(!(*pIF->pCTRL & SYS_PS2_BIT_TX_EMPTY)); while(!(*pIF->pCTRL & SYS_PS2_BIT_TX_EMPTY));
*pIF->pDATA = (UINT32)byte; *pIF->pDATA = (uint32_t)byte;
} }
UINT32 PS2_byte_read(UINT32 port, UINT32 timeout_ms) uint32_t PS2_byte_read(uint32_t port, uint32_t timeout_ms)
{ {
ps2_if_t *pIF; ps2_if_t *pIF;
@@ -48,12 +48,12 @@ UINT32 PS2_byte_read(UINT32 port, UINT32 timeout_ms)
sleep(1); sleep(1);
} }
return (UINT32)*pIF->pDATA; return (uint32_t)*pIF->pDATA;
} }
UINT32 PS2_cmd(UINT32 port, UINT8 cmd, UINT32 ack_timeout_ms) uint32_t PS2_cmd(uint32_t port, uint8_t cmd, uint32_t ack_timeout_ms)
{ {
UINT32 result; uint32_t result;
PS2_byte_write(port, cmd); PS2_byte_write(port, cmd);
result = PS2_byte_read(port, ack_timeout_ms); result = PS2_byte_read(port, ack_timeout_ms);
@@ -65,21 +65,21 @@ UINT32 PS2_cmd(UINT32 port, UINT8 cmd, UINT32 ack_timeout_ms)
return 0; return 0;
} }
void PS2_flush(UINT32 port) void PS2_flush(uint32_t port)
{ {
while (!IS_ERROR(PS2_byte_read(port, 10))); while (!IS_ERROR(PS2_byte_read(port, 10)));
} }
UINT32 PS2_init(UINT32 port) uint32_t PS2_init(uint32_t port)
{ {
int i; int i;
ps2_if_t *pIF; ps2_if_t *pIF;
UINT8 id[2]; uint8_t id[2];
pIF = &ps2_if[port]; pIF = &ps2_if[port];
pIF->type = ps2_type_unknown; pIF->type = ps2_type_unknown;
UINT32 result; uint32_t result;
// Disable RX-interrupt // Disable RX-interrupt
*pIF->pCTRL &= ~SYS_PS2_BIT_RX_INTEN; *pIF->pCTRL &= ~SYS_PS2_BIT_RX_INTEN;
src/libsys/mips_ps2.h
+10 -10
View File
@@ -15,9 +15,9 @@ enum
typedef struct _sps2_if_t typedef struct _sps2_if_t
{ {
UINT32 type; uint32_t type;
volatile UINT32 *pCTRL; volatile uint32_t *pCTRL;
volatile UINT32 *pDATA; volatile uint32_t *pDATA;
} ps2_if_t; } ps2_if_t;
// -------------------------------------------------- // --------------------------------------------------
@@ -32,12 +32,12 @@ typedef struct _sps2_if_t
// -------------------------------------------------- // --------------------------------------------------
// Functions // Functions
// -------------------------------------------------- // --------------------------------------------------
UINT32 PS2_get_num_if(void); uint32_t PS2_get_num_if(void);
ps2_if_t *PS2_get_if(UINT32 port); ps2_if_t *PS2_get_if(uint32_t port);
UINT32 PS2_init(UINT32 port); uint32_t PS2_init(uint32_t port);
void PS2_byte_write(UINT32 port, UINT8 byte); void PS2_byte_write(uint32_t port, uint8_t byte);
UINT32 PS2_byte_read(UINT32 port, UINT32 timeout_ms); uint32_t PS2_byte_read(uint32_t port, uint32_t timeout_ms);
UINT32 PS2_cmd(UINT32 port, UINT8 cmd, UINT32 ack_timeout_ms); uint32_t PS2_cmd(uint32_t port, uint8_t cmd, uint32_t ack_timeout_ms);
void PS2_flush(UINT32 port); void PS2_flush(uint32_t port);
#endif // PS2_H #endif // PS2_H
src/life.c
+15 -15
View File
@@ -30,7 +30,7 @@
#define MATRIX( row, col ) (*(matrix + (NX*col) + row )) #define MATRIX( row, col ) (*(matrix + (NX*col) + row ))
#define FUTURE( row, col ) (*(future + (NX*col) + row )) #define FUTURE( row, col ) (*(future + (NX*col) + row ))
UINT32 *g_gx_buff; uint32_t *g_gx_buff;
int clock_lfsr32() int clock_lfsr32()
{ {
@@ -48,16 +48,16 @@ int random1023() {
typedef struct _scolor_t typedef struct _scolor_t
{ {
UINT8 r, g, b, a; uint8_t r, g, b, a;
} __attribute__ ((__packed__)) color_t; } __attribute__ ((__packed__)) color_t;
void DrawPixel(UINT32 x, UINT32 y, color_t *pColor) void DrawPixel(uint32_t x, uint32_t y, color_t *pColor)
{ {
int i, j; int i, j;
for (i=0; i < SCALE_Y; i++) for (i=0; i < SCALE_Y; i++)
for (j=0; j < SCALE_X; j++) for (j=0; j < SCALE_X; j++)
g_gx_buff[(OFFSET_X+SCALE_X*x+j) + SCREEN_X*(OFFSET_Y+SCALE_Y*y+i)] = *((UINT32*)pColor); g_gx_buff[(OFFSET_X+SCALE_X*x+j) + SCREEN_X*(OFFSET_Y+SCALE_Y*y+i)] = *((uint32_t*)pColor);
} }
@@ -66,7 +66,7 @@ void displayBoard1( int* matrix )
{ {
int x, y; int x, y;
int mask, accu; int mask, accu;
UINT32 color; uint32_t color;
for( x=0; x < NX; x++ ) for( x=0; x < NX; x++ )
{ {
@@ -74,7 +74,7 @@ void displayBoard1( int* matrix )
accu = 0x00; accu = 0x00;
for( y=0; y < NY; y++ ) for( y=0; y < NY; y++ )
{ {
color = (UINT32)-(MATRIX(x,y) & 0x1); color = (uint32_t)-(MATRIX(x,y) & 0x1);
DrawPixel(x, y, (color_t*)&color); DrawPixel(x, y, (color_t*)&color);
// if (MATRIX( x, y ) != OCCUPIED) // if (MATRIX( x, y ) != OCCUPIED)
// { // {
@@ -188,19 +188,19 @@ void nextGeneration( int* matrix, int* future ) {
void gx_init(void) void gx_init(void)
{ {
volatile UINT32 *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; volatile uint32_t *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
volatile UINT32 *pVGA_front = (UINT32*)SYS_VGA_FB_FRONT; volatile uint32_t *pVGA_front = (uint32_t*)SYS_VGA_FB_FRONT;
volatile UINT32 *pVGA_back = (UINT32*)SYS_VGA_FB_BACK; volatile uint32_t *pVGA_back = (uint32_t*)SYS_VGA_FB_BACK;
sleep(500); sleep(500);
g_gx_buff = (UINT32*)malloc(SCREEN_X*SCREEN_Y*sizeof(UINT32)); g_gx_buff = (uint32_t*)malloc(SCREEN_X*SCREEN_Y*sizeof(uint32_t));
memset(g_gx_buff, 0, SCREEN_X*SCREEN_Y*sizeof(UINT32)); memset(g_gx_buff, 0, SCREEN_X*SCREEN_Y*sizeof(uint32_t));
printf("g_gx_buff : %8.8X\n", (UINT32)g_gx_buff); printf("g_gx_buff : %8.8X\n", (uint32_t)g_gx_buff);
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
*pVGA_front = (UINT32)g_gx_buff; *pVGA_front = (uint32_t)g_gx_buff;
*pVGA_back = (UINT32)g_gx_buff; *pVGA_back = (uint32_t)g_gx_buff;
} }
@@ -210,7 +210,7 @@ int main( int argc, char* argv[] ) {
int* matrix; int* matrix;
int* future; int* future;
volatile UINT32 *pBtn = (UINT32*)SYS_GPIO_0_DATA; volatile uint32_t *pBtn = (uint32_t*)SYS_GPIO_0_DATA;
// lcdEnableDisplay( 1 ); // lcdEnableDisplay( 1 );
// lcdSetColor( 1 ); // lcdSetColor( 1 );
src/lwl.c
+2 -2
View File
@@ -1,8 +1,8 @@
#include "libsys.h" #include "libsys.h"
int non_aligned_load(UINT32* pMem) int non_aligned_load(uint32_t* pMem)
{ {
UINT32 result; uint32_t result;
__asm__ __asm__
( (
"li $t0, 0x01234567\n" "li $t0, 0x01234567\n"
src/r3.c
+12 -12
View File
@@ -16,7 +16,7 @@
* ./r3 | xv - * ./r3 | xv -
*/ */
#include "libsys.h" #include "libsys.h"
UINT32 *pP; uint32_t *pP;
xsize = 800; xsize = 800;
ysize = 600; ysize = 600;
@@ -300,7 +300,7 @@ trace_ray(orig_x, orig_y, orig_z,
closest_i_saved = closest_i_saved<4? closest_i_saved+1 : 7, closest_i_saved = closest_i_saved<4? closest_i_saved+1 : 7,
*/ */
/* /*
tvinga grĺskalor: closest_i_saved = 7, tvinga gr�skalor: closest_i_saved = 7,
*/ */
closest_i_saved = closest_i_saved<22? 7 : closest_i_saved = closest_i_saved<22? 7 :
( (
@@ -441,23 +441,23 @@ do_line(y)
main() main()
{ {
#ifdef JMIPS_VGA #ifdef JMIPS_VGA
volatile UINT32 *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; volatile uint32_t *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
volatile UINT32 *pVGA_front = (UINT32*)SYS_VGA_FB_FRONT; volatile uint32_t *pVGA_front = (uint32_t*)SYS_VGA_FB_FRONT;
volatile UINT32 *pVGA_back = (UINT32*)SYS_VGA_FB_BACK; volatile uint32_t *pVGA_back = (uint32_t*)SYS_VGA_FB_BACK;
UINT64 *pPixelBuf; uint64_t *pPixelBuf;
xsize = Screen_get_resx(); xsize = Screen_get_resx();
ysize = Screen_get_resy(); ysize = Screen_get_resy();
pPixelBuf = (UINT64*)malloc(xsize*ysize*sizeof(UINT32)); pPixelBuf = (uint64_t*)malloc(xsize*ysize*sizeof(uint32_t));
pP = (UINT32*)pPixelBuf; pP = (uint32_t*)pPixelBuf;
printf("pPixelBuf : %8.8X\n", (UINT32)pPixelBuf); printf("pPixelBuf : %8.8X\n", (uint32_t)pPixelBuf);
*pVGA_front = (UINT32)pPixelBuf; *pVGA_front = (uint32_t)pPixelBuf;
*pVGA_back = (UINT32)pPixelBuf; *pVGA_back = (uint32_t)pPixelBuf;
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
memset(pPixelBuf, 0, xsize*ysize*sizeof(UINT32)); memset(pPixelBuf, 0, xsize*ysize*sizeof(uint32_t));
#else #else
/* Output PPM file header ... */ /* Output PPM file header ... */
src/rmd160_test.c
+1 -1
View File
@@ -58,7 +58,7 @@ int main (void)
{ {
int result, i, j, cnt; int result, i, j, cnt;
byte *hashcode; byte *hashcode;
UINT32 start, stop; uint32_t start, stop;
for (i=0; i < MSG_SIZE/8; i++) for (i=0; i < MSG_SIZE/8; i++)
msg[i] = 0x55; msg[i] = 0x55;
src/test_exception.c
+4 -4
View File
@@ -13,7 +13,7 @@ void _exc_break(void)
); );
} }
void _exc_syscall(UINT32 code, UINT32 arg) void _exc_syscall(uint32_t code, uint32_t arg)
{ {
__asm __asm
( (
@@ -195,7 +195,7 @@ int main(void)
while(1) while(1)
{ {
printf("Welche exception möchten Sie testen?\n"); printf("Welche exception m�chten Sie testen?\n");
printf(" 1 : Reserved instruction\n"); printf(" 1 : Reserved instruction\n");
printf(" 2 : Privileged address (BadVAddr = 0x80000000)\n"); printf(" 2 : Privileged address (BadVAddr = 0x80000000)\n");
printf(" 3 : Arithmetic overflow\n"); printf(" 3 : Arithmetic overflow\n");
@@ -229,9 +229,9 @@ int main(void)
break; break;
case 4: case 4:
_exc_syscall(4, (UINT32)((char*)"Hallo Syscall (")); _exc_syscall(4, (uint32_t)((char*)"Hallo Syscall ("));
_exc_syscall(1, 12345678); _exc_syscall(1, 12345678);
_exc_syscall(4, (UINT32)((char*)")\n")); _exc_syscall(4, (uint32_t)((char*)")\n"));
break; break;
case 5: case 5:
src/test_fft.c
+5 -5
View File
@@ -11,19 +11,19 @@
#define FFT_MAX_LEN 1024 #define FFT_MAX_LEN 1024
FLOAT32 fft_buf_real[FFT_MAX_LEN]; float32_t fft_buf_real[FFT_MAX_LEN];
FLOAT32 fft_buf_imag[FFT_MAX_LEN]; float32_t fft_buf_imag[FFT_MAX_LEN];
int main() int main()
{ {
UINT32 i, start, end; uint32_t i, start, end;
fft_t fft; fft_t fft;
FFTinit(&fft, 1024); FFTinit(&fft, 1024);
memset (fft_buf_real, 0, FFT_MAX_LEN*sizeof(FLOAT32)); memset (fft_buf_real, 0, FFT_MAX_LEN*sizeof(float32_t));
memset (fft_buf_imag, 0, FFT_MAX_LEN*sizeof(FLOAT32)); memset (fft_buf_imag, 0, FFT_MAX_LEN*sizeof(float32_t));
start = clock(); start = clock();
src/test_hpi.c
+139 -137
View File
@@ -2,24 +2,26 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include "libsys.h"
#include <libsys/libsys.h>
#include <libsys/gpio.h>
#include "cfiflash.h" #include "cfiflash.h"
#include "gpio.h"
#include "hpi.h" #include "hpi.h"
static volatile UINT32 _g_uart_msg; static volatile uint32_t _g_uart_msg;
static volatile UINT32 _g_rst; static volatile uint32_t _g_rst;
static volatile UINT32 _g_sus; static volatile uint32_t _g_sus;
static volatile UINT32 _g_cfg; static volatile uint32_t _g_cfg;
gpio_if_t _g_gpio; gpio_if_t _g_gpio;
#define CMD_SYNC_EB 0xC24755AA #define CMD_SYNC_EB 0xC24755AA
#define CMD_SYNC_EL 0x47C2AA55 #define CMD_SYNC_EL 0x47C2AA55
#define TRANSFER_SIZE 64 #define TRANSFER_SIZE 64
UINT32 conv32(UINT32 data) uint32_t conv32(uint32_t data)
{ {
UINT32 result; uint32_t result;
result = (0xFF00FF00 & (data << 8)) result = (0xFF00FF00 & (data << 8))
| (0x00FF00FF & (data >> 8)); | (0x00FF00FF & (data >> 8));
@@ -27,12 +29,12 @@ UINT32 conv32(UINT32 data)
return result; return result;
} }
UINT16 conv16(UINT16 data) uint16_t conv16(uint16_t data)
{ {
return (0xFF00 & (data << 8)) | (0x00FF & (data >> 8)); return (0xFF00 & (data << 8)) | (0x00FF & (data >> 8));
} }
UINT16 makeBuffer16(UINT16 *pDst, UINT8 *pSrc, UINT32 size) uint16_t makeBuffer16(uint16_t *pDst, uint8_t *pSrc, uint32_t size)
{ {
int i; int i;
@@ -41,7 +43,7 @@ UINT16 makeBuffer16(UINT16 *pDst, UINT8 *pSrc, UINT32 size)
for (i=0; i < size/2; i++) for (i=0; i < size/2; i++)
{ {
pDst[i] = conv16(*((UINT16*)pSrc)); pDst[i] = conv16(*((uint16_t*)pSrc));
pSrc+=2; pSrc+=2;
} }
return size; return size;
@@ -50,8 +52,8 @@ UINT16 makeBuffer16(UINT16 *pDst, UINT8 *pSrc, UINT32 size)
void uart_handler(void) void uart_handler(void)
{ {
volatile UINT32 *pUART_stat = (UINT32*)SYS_UART_STAT; volatile uint32_t *pUART_stat = (uint32_t*)SYS_UART_STAT;
volatile UINT32 *pUART_data = (UINT32*)SYS_UART_DATA; volatile uint32_t *pUART_data = (uint32_t*)SYS_UART_DATA;
while((SYS_PS2_BIT_RX_AVAIL & *pUART_stat)) while((SYS_PS2_BIT_RX_AVAIL & *pUART_stat))
{ {
@@ -60,10 +62,10 @@ void uart_handler(void)
} }
void PrintDevRegs(UINT devid) void PrintDevRegs(uint32_t devid)
{ {
int i; int i;
UINT32 reg_base1, reg_base2, reg_addr; uint32_t reg_base1, reg_base2, reg_addr;
if ((devid < 1) || (devid > 2)) if ((devid < 1) || (devid > 2))
return; return;
@@ -117,68 +119,68 @@ void PrintDevRegs(UINT devid)
typedef struct _sdev_descr_t typedef struct _sdev_descr_t
{ {
UINT8 size; // length uint8_t size; // length
UINT8 type; // desc type uint8_t type; // desc type
UINT16 usb_spec; // USB spec uint16_t usb_spec; // USB spec
UINT8 devclass; // device class uint8_t devclass; // device class
UINT8 subclass; // sub class uint8_t subclass; // sub class
UINT8 protocol; // protocol uint8_t protocol; // protocol
UINT8 max_packet_size; // max packet size for endpoint 0 uint8_t max_packet_size; // max packet size for endpoint 0
UINT16 vendor_id; // Vendor ID uint16_t vendor_id; // Vendor ID
UINT16 product_id; // Product ID uint16_t product_id; // Product ID
UINT16 device_id; // device release number uint16_t device_id; // device release number
UINT8 man_str_index; // index of manufacture string uint8_t man_str_index; // index of manufacture string
UINT8 prod_str_index; // index of product string uint8_t prod_str_index; // index of product string
UINT8 sn_str_index; // index of serial number string uint8_t sn_str_index; // index of serial number string
UINT8 nconfs; // number of configurations uint8_t nconfs; // number of configurations
} __attribute__ ((__packed__)) dev_descr_t; } __attribute__ ((__packed__)) dev_descr_t;
typedef struct _sep_descr_t typedef struct _sep_descr_t
{ {
UINT8 size; // length of this config uint8_t size; // length of this config
UINT8 type; // type (endpoint) uint8_t type; // type (endpoint)
UINT8 type_num; // type/number (Host use WriteFile) uint8_t type_num; // type/number (Host use WriteFile)
UINT8 bulk; // Bulk uint8_t bulk; // Bulk
UINT16 pkt_size; // packet size uint16_t pkt_size; // packet size
UINT8 interval; // interval uint8_t interval; // interval
} __attribute__ ((__packed__)) ep_descr_t; } __attribute__ ((__packed__)) ep_descr_t;
typedef struct _sconf_descr_t typedef struct _sconf_descr_t
{ {
UINT8 size; // length of this config uint8_t size; // length of this config
UINT8 type; // desc type uint8_t type; // desc type
UINT16 total_size; // Total configuration desc length including this config and following descriptions uint16_t total_size; // Total configuration desc length including this config and following descriptions
UINT8 nifaces; // Number of interface descriptions following this uint8_t nifaces; // Number of interface descriptions following this
UINT8 conf_id; // config number uint8_t conf_id; // config number
UINT8 conf_str_index; // index of string describing config uint8_t conf_str_index; // index of string describing config
UINT8 attr; // attributes (e.g. bus powered) uint8_t attr; // attributes (e.g. bus powered)
UINT8 current; // 2mA x <current> (max. 250 => 500mA) uint8_t current; // 2mA x <current> (max. 250 => 500mA)
} __attribute__ ((__packed__)) conf_descr_t; } __attribute__ ((__packed__)) conf_descr_t;
typedef struct _siface_descr_t typedef struct _siface_descr_t
{ {
UINT8 size; // length of this config uint8_t size; // length of this config
UINT8 type; // desc type uint8_t type; // desc type
UINT8 base; // base number uint8_t base; // base number
UINT8 alt; // alt uint8_t alt; // alt
UINT8 neps; // number of endpoint description following this uint8_t neps; // number of endpoint description following this
UINT8 iface_class; // interface class (vendor) uint8_t iface_class; // interface class (vendor)
UINT8 subclass; // subclass uint8_t subclass; // subclass
UINT8 iface_proto; // interface proto (vendor) uint8_t iface_proto; // interface proto (vendor)
UINT8 iface_str_index; uint8_t iface_str_index;
} __attribute__ ((__packed__)) iface_descr_t; } __attribute__ ((__packed__)) iface_descr_t;
typedef struct _sotg_descr_t typedef struct _sotg_descr_t
{ {
UINT8 size; // length of this config uint8_t size; // length of this config
UINT8 type; // type (OTG) uint8_t type; // type (OTG)
UINT8 hnp_srp; // HNP|SRP support uint8_t hnp_srp; // HNP|SRP support
} __attribute__ ((__packed__)) otg_descr_t; } __attribute__ ((__packed__)) otg_descr_t;
typedef struct _sstr_descr_hdr_t typedef struct _sstr_descr_hdr_t
{ {
UINT8 size; // length of this config uint8_t size; // length of this config
UINT8 type; // type uint8_t type; // type
} __attribute__ ((__packed__)) str_descr_hdr_t; } __attribute__ ((__packed__)) str_descr_hdr_t;
typedef struct _scfg_inst_t typedef struct _scfg_inst_t
@@ -188,7 +190,7 @@ typedef struct _scfg_inst_t
} cfg_inst_t; } cfg_inst_t;
UINT32 dev_write(UINT16 *pDevDescrString, UINT16 VID, UINT16 PID) uint32_t dev_write(uint16_t *pDevDescrString, uint16_t VID, uint16_t PID)
{ {
dev_descr_t d; dev_descr_t d;
@@ -207,17 +209,17 @@ UINT32 dev_write(UINT16 *pDevDescrString, UINT16 VID, UINT16 PID)
d.sn_str_index = 0x03; // index of serial number string d.sn_str_index = 0x03; // index of serial number string
d.nconfs = 0x01; // number of configurations d.nconfs = 0x01; // number of configurations
return makeBuffer16(pDevDescrString, (UINT8*)&d, sizeof(dev_descr_t)); return makeBuffer16(pDevDescrString, (uint8_t*)&d, sizeof(dev_descr_t));
} }
UINT32 conf_write(UINT16 *pConfDescr, UINT32 neps, ep_descr_t *pEP) uint32_t conf_write(uint16_t *pConfDescr, uint32_t neps, ep_descr_t *pEP)
{ {
UINT32 i, pos, size; uint32_t i, pos, size;
ep_descr_t ep; ep_descr_t ep;
conf_descr_t cfg; conf_descr_t cfg;
iface_descr_t iface; iface_descr_t iface;
otg_descr_t otg_descr; otg_descr_t otg_descr;
UINT8 *pStr8 = (UINT8*)pConfDescr; uint8_t *pStr8 = (uint8_t*)pConfDescr;
// Fill config description // Fill config description
cfg.size = sizeof(conf_descr_t); cfg.size = sizeof(conf_descr_t);
@@ -281,13 +283,13 @@ UINT32 conf_write(UINT16 *pConfDescr, UINT32 neps, ep_descr_t *pEP)
} }
UINT32 str_write(UINT16 *pStrDescr, UINT8 *pStr0, UINT8 *pStr1, UINT8 *pStr2) uint32_t str_write(uint16_t *pStrDescr, uint8_t *pStr0, uint8_t *pStr1, uint8_t *pStr2)
{ {
int i; int i;
UINT32 pos, size, strsize; uint32_t pos, size, strsize;
str_descr_hdr_t *pStrHdr; str_descr_hdr_t *pStrHdr;
UINT8 *pStr8 = (UINT8*)pStrDescr; uint8_t *pStr8 = (uint8_t*)pStrDescr;
UINT16 *pStr16; uint16_t *pStr16;
pos = 0; pos = 0;
size = sizeof(str_descr_hdr_t); size = sizeof(str_descr_hdr_t);
@@ -310,10 +312,10 @@ UINT32 str_write(UINT16 *pStrDescr, UINT8 *pStr0, UINT8 *pStr1, UINT8 *pStr2)
pos += size; pos += size;
size = 2*strsize; size = 2*strsize;
pStr16 = (UINT16*)&pStr8[pos]; pStr16 = (uint16_t*)&pStr8[pos];
for (i=0; i < strsize; i++) for (i=0; i < strsize; i++)
pStr16[i] = conv16((UINT16)pStr0[i]); pStr16[i] = conv16((uint16_t)pStr0[i]);
// String 1 // String 1
pos += size; pos += size;
@@ -326,10 +328,10 @@ UINT32 str_write(UINT16 *pStrDescr, UINT8 *pStr0, UINT8 *pStr1, UINT8 *pStr2)
pos += size; pos += size;
size = 2*strsize; size = 2*strsize;
pStr16 = (UINT16*)&pStr8[pos]; pStr16 = (uint16_t*)&pStr8[pos];
for (i=0; i < strsize; i++) for (i=0; i < strsize; i++)
pStr16[i] = conv16((UINT16)pStr1[i]); pStr16[i] = conv16((uint16_t)pStr1[i]);
// String 2 // String 2
pos += size; pos += size;
@@ -342,10 +344,10 @@ UINT32 str_write(UINT16 *pStrDescr, UINT8 *pStr0, UINT8 *pStr1, UINT8 *pStr2)
pos += size; pos += size;
size = 2*strsize; size = 2*strsize;
pStr16 = (UINT16*)&pStr8[pos]; pStr16 = (uint16_t*)&pStr8[pos];
for (i=0; i < strsize; i++) for (i=0; i < strsize; i++)
pStr16[i] = conv16((UINT16)pStr2[i]); pStr16[i] = conv16((uint16_t)pStr2[i]);
pos += size; pos += size;
@@ -354,11 +356,11 @@ UINT32 str_write(UINT16 *pStrDescr, UINT8 *pStr0, UINT8 *pStr1, UINT8 *pStr2)
void ep0_func(void *pArg) void ep0_func(void *pArg)
{ {
UINT32 result; uint32_t result;
UINT16 buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize; uint16_t buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize;
usb_irp_t *pIRP = (usb_irp_t*)pArg; usb_irp_t *pIRP = (usb_irp_t*)pArg;
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS0); ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS0);
ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES0); ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES0);
ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT0); ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT0);
@@ -371,11 +373,11 @@ void ep0_func(void *pArg)
void ep1_func(void *pArg) void ep1_func(void *pArg)
{ {
UINT32 result; uint32_t result;
UINT16 buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize; uint16_t buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize;
usb_irp_t *pIRP = (usb_irp_t*)pArg; usb_irp_t *pIRP = (usb_irp_t*)pArg;
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS1); ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS1);
ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES1); ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES1);
ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT1); ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT1);
@@ -383,16 +385,16 @@ void ep1_func(void *pArg)
tsize = pIRP->tsize; tsize = pIRP->tsize;
if (ep_status & 0x0020) if (ep_status & 0x0020)
{ {
printf("Length exception result %4.4X with count = %d\n", ep_status, (INT16)ep_cntres); printf("Length exception result %4.4X with count = %d\n", ep_status, (int16_t)ep_cntres);
if (ep_status & 0x0400) if (ep_status & 0x0400)
tsize = (UINT16)((INT16)tsize - (INT16)ep_cntres); tsize = (uint16_t)((int16_t)tsize - (int16_t)ep_cntres);
if (ep_status & 0x0800) if (ep_status & 0x0800)
tsize = (UINT16)((INT16)tsize - (INT16)ep_cntres); tsize = (uint16_t)((int16_t)tsize - (int16_t)ep_cntres);
} }
usb_irp_enqueue(pIRP); usb_irp_enqueue(pIRP);
result = hpi_read_ram(pIRP->cy_req.addr, buf, tsize); result = hpi_read_ram(pIRP->cy_req.addr, buf, tsize);
fifo_write(&pIRP->fifo, (UINT8*)buf, result, 0, FIFO_BLOCK); fifo_write(&pIRP->fifo, (uint8_t*)buf, result, 0, FIFO_BLOCK);
// printf("Read %d bytes\n", result); // printf("Read %d bytes\n", result);
@@ -400,11 +402,11 @@ void ep1_func(void *pArg)
void ep2_func(void *pArg) void ep2_func(void *pArg)
{ {
UINT32 result; uint32_t result;
UINT16 buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize; uint16_t buf[USB_MAX_IMG_SIZE/2], ep_cntres, ep_status, ep_count, tsize;
usb_irp_t *pIRP = (usb_irp_t*)pArg; usb_irp_t *pIRP = (usb_irp_t*)pArg;
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS2); ep_status = hpi_read_reg (SUSB2_REG_EP_STATUS2);
ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES2); ep_cntres = hpi_read_reg (SUSB2_REG_EP_CNTRES2);
ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT2); ep_count = hpi_read_reg (SUSB2_REG_EP_COUNT2);
@@ -412,20 +414,20 @@ void ep2_func(void *pArg)
tsize = pIRP->tsize; tsize = pIRP->tsize;
if (ep_status & 0x0020) if (ep_status & 0x0020)
{ {
printf("Length exception result %4.4X with count = %d\n", ep_status, (INT16)ep_cntres); printf("Length exception result %4.4X with count = %d\n", ep_status, (int16_t)ep_cntres);
if (ep_status & 0x0400) if (ep_status & 0x0400)
tsize = (UINT16)((INT16)tsize - (INT16)ep_cntres); tsize = (uint16_t)((int16_t)tsize - (int16_t)ep_cntres);
if (ep_status & 0x0800) if (ep_status & 0x0800)
tsize = (UINT16)((INT16)tsize - (INT16)ep_cntres); tsize = (uint16_t)((int16_t)tsize - (int16_t)ep_cntres);
} }
pIRP->tx_in_progress = 0; pIRP->tx_in_progress = 0;
result = fifo_read(&pIRP->fifo, (UINT8*)buf, pIRP->tsize, 0, FIFO_NONBLOCK); result = fifo_read(&pIRP->fifo, (uint8_t*)buf, pIRP->tsize, 0, FIFO_NONBLOCK);
if (!result) if (!result)
return; return;
pIRP->cy_req.size = result; pIRP->cy_req.size = result;
hpi_write_ram(pIRP->cy_req.addr, (UINT16*)buf, result); hpi_write_ram(pIRP->cy_req.addr, (uint16_t*)buf, result);
usb_irp_enqueue(pIRP); usb_irp_enqueue(pIRP);
@@ -436,7 +438,7 @@ void ep2_func(void *pArg)
void rst_func(void *pArg) void rst_func(void *pArg)
{ {
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_RST_MSG\n"); sputs("SUSB_RST_MSG\n");
/// hpi_comm_reset(); /// hpi_comm_reset();
@@ -447,7 +449,7 @@ void rst_func(void *pArg)
void sof_func(void *pArg) void sof_func(void *pArg)
{ {
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_SOF_MSG\n"); sputs("SUSB_SOF_MSG\n");
} }
@@ -458,7 +460,7 @@ void cfg_func(void *pArg)
usb_irp_t *pIRP_rx = (usb_irp_t*)pCFG->pIRP_rx; usb_irp_t *pIRP_rx = (usb_irp_t*)pCFG->pIRP_rx;
usb_irp_t *pIRP_tx = (usb_irp_t*)pCFG->pIRP_tx; usb_irp_t *pIRP_tx = (usb_irp_t*)pCFG->pIRP_tx;
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_CFG_MSG\n"); sputs("SUSB_CFG_MSG\n");
_g_cfg = 1; _g_cfg = 1;
usb_irp_enqueue(pIRP_rx); usb_irp_enqueue(pIRP_rx);
@@ -471,7 +473,7 @@ void cfg_func(void *pArg)
void sus_func(void *pArg) void sus_func(void *pArg)
{ {
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_SUS_MSG\n"); sputs("SUSB_SUS_MSG\n");
_g_sus = 1; _g_sus = 1;
@@ -480,24 +482,24 @@ void sus_func(void *pArg)
void id_func(void *pArg) void id_func(void *pArg)
{ {
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_ID_MSG\n"); sputs("SUSB_ID_MSG\n");
} }
void vbus_func(void *pArg) void vbus_func(void *pArg)
{ {
// printf("Callback with pArg = %8.8X\n", (UINT32)pArg); // printf("Callback with pArg = %8.8X\n", (uint32_t)pArg);
sputs("SUSB_VBUS_MSG\n"); sputs("SUSB_VBUS_MSG\n");
} }
UINT32 usb_init_descr(void) uint32_t usb_init_descr(void)
{ {
UINT32 size; uint32_t size;
UINT16 buffer16[0x100]; uint16_t buffer16[0x100];
UINT16 addr; uint16_t addr;
ep_descr_t ep_descr[2] = {{sizeof(ep_descr_t), 5, 1, 2, TRANSFER_SIZE, 0}, {sizeof(ep_descr_t), 5, 0x82, 2, TRANSFER_SIZE, 0}}; ep_descr_t ep_descr[2] = {{sizeof(ep_descr_t), 5, 1, 2, TRANSFER_SIZE, 0}, {sizeof(ep_descr_t), 5, 0x82, 2, TRANSFER_SIZE, 0}};
// Set device descriptor // Set device descriptor
@@ -526,10 +528,10 @@ UINT32 usb_init_descr(void)
return 0; return 0;
} }
UINT32 usb_force_reconnect(UINT32 port) uint32_t usb_force_reconnect(uint32_t port)
{ {
UINT32 result; uint32_t result;
UINT16 addr; uint16_t addr;
if (port >= USB_MAX_NUM_PORTS) if (port >= USB_MAX_NUM_PORTS)
return -1; return -1;
@@ -555,19 +557,19 @@ UINT32 usb_force_reconnect(UINT32 port)
return result; return result;
} }
UINT32 usb_recv(usb_irp_t *pObj, UINT8 *pData, UINT32 len, UINT32 timeout) uint32_t usb_recv(usb_irp_t *pObj, uint8_t *pData, uint32_t len, uint32_t timeout)
{ {
UINT32 result; uint32_t result;
result = fifo_read(&pObj->fifo, pData, len, timeout, FIFO_BLOCK); result = fifo_read(&pObj->fifo, pData, len, timeout, FIFO_BLOCK);
return result; return result;
} }
UINT32 usb_send(usb_irp_t *pObj, UINT8 *pData, UINT32 len, UINT32 timeout) uint32_t usb_send(usb_irp_t *pObj, uint8_t *pData, uint32_t len, uint32_t timeout)
{ {
UINT32 result; uint32_t result;
UINT8 buf[USB_MAX_IMG_SIZE]; uint8_t buf[USB_MAX_IMG_SIZE];
// Fill-up FIFO // Fill-up FIFO
result = fifo_write(&pObj->fifo, pData, len, 0, FIFO_NONBLOCK); result = fifo_write(&pObj->fifo, pData, len, 0, FIFO_NONBLOCK);
@@ -577,8 +579,8 @@ UINT32 usb_send(usb_irp_t *pObj, UINT8 *pData, UINT32 len, UINT32 timeout)
// Trigger TX // Trigger TX
if (!pObj->tx_in_progress) if (!pObj->tx_in_progress)
{ {
pObj->cy_req.size = fifo_read(&pObj->fifo, (UINT8*)buf, pObj->tsize, 0, FIFO_NONBLOCK); pObj->cy_req.size = fifo_read(&pObj->fifo, (uint8_t*)buf, pObj->tsize, 0, FIFO_NONBLOCK);
hpi_write_ram(pObj->cy_req.addr, (UINT16*)buf, pObj->cy_req.size); hpi_write_ram(pObj->cy_req.addr, (uint16_t*)buf, pObj->cy_req.size);
usb_irp_enqueue(pObj); usb_irp_enqueue(pObj);
} }
@@ -595,23 +597,23 @@ UINT32 usb_send(usb_irp_t *pObj, UINT8 *pData, UINT32 len, UINT32 timeout)
int main(void) int main(void)
{ {
int i; int i;
UINT32 result, sync, cmd, len, buf_count, led_count, remain, tx_cnt, flash_offset; uint32_t result, sync, cmd, len, buf_count, led_count, remain, tx_cnt, flash_offset;
UINT8 buffer8[2048]; uint8_t buffer8[2048];
UINT16 buffer16[0x2000]; uint16_t buffer16[0x2000];
UINT16 addr; uint16_t addr;
volatile UINT32 *pUART0_stat = (UINT32*)SYS_UART0_STAT; volatile uint32_t *pUART0_stat = (uint32_t*)SYS_UART0_STAT;
UINT32 start, end; uint32_t start, end;
UINT32 *pFlash32; uint32_t *pFlash32;
UINT8 *pFlash8; uint8_t *pFlash8;
UINT32 buffer32[16], *pBuf; uint32_t buffer32[16], *pBuf;
UINT64 *pBuf64; uint64_t *pBuf64;
usb_irp_t irp_rx, irp_tx; usb_irp_t irp_rx, irp_tx;
fifo_t fifo_rx, fifo_tx; fifo_t fifo_rx, fifo_tx;
cfg_inst_t cfg_inst; cfg_inst_t cfg_inst;
flash_t flash; flash_t flash;
volatile UINT32 *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; volatile uint32_t *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
volatile UINT32 *pVGA_front = (UINT32*)SYS_VGA_FB_FRONT; volatile uint32_t *pVGA_front = (uint32_t*)SYS_VGA_FB_FRONT;
volatile UINT32 *pVGA_back = (UINT32*)SYS_VGA_FB_BACK; volatile uint32_t *pVGA_back = (uint32_t*)SYS_VGA_FB_BACK;
_g_rst = 0; _g_rst = 0;
_g_sus = 0; _g_sus = 0;
@@ -739,11 +741,11 @@ int main(void)
led_count = 0; led_count = 0;
buf_count = 0; buf_count = 0;
pBuf64 = (UINT64*)malloc(FLASH_IMAGE_SIZE); pBuf64 = (uint64_t*)malloc(FLASH_IMAGE_SIZE);
pBuf = (UINT32*)pBuf64; pBuf = (uint32_t*)pBuf64;
*pVGA_front = (UINT32)pBuf64; *pVGA_front = (uint32_t)pBuf64;
*pVGA_back = (UINT32)pBuf64; *pVGA_back = (uint32_t)pBuf64;
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
if (IS_ERROR(flash_find(&flash, SYS_FLASH_IO))) if (IS_ERROR(flash_find(&flash, SYS_FLASH_IO)))
@@ -755,8 +757,8 @@ int main(void)
// Get flash offset by value of DIP-switch // Get flash offset by value of DIP-switch
flash_offset = flash_get_offset_by_blocknum(&flash, flash.info.nblocks-FLASH_IMAGE_SIZE/flash.info.blocksize); flash_offset = flash_get_offset_by_blocknum(&flash, flash.info.nblocks-FLASH_IMAGE_SIZE/flash.info.blocksize);
printf("flash_offset : %08X\n", flash_offset); printf("flash_offset : %08X\n", flash_offset);
pFlash32 = (UINT32*)(SYS_FLASH_IO + flash_offset); pFlash32 = (uint32_t*)(SYS_FLASH_IO + flash_offset);
pFlash8 = (UINT8*)pFlash32; pFlash8 = (uint8_t*)pFlash32;
while(1) while(1)
{ {
@@ -777,7 +779,7 @@ int main(void)
default: default:
break; break;
} }
result = usb_recv(&irp_rx, (UINT8*)&sync, 4, 100); result = usb_recv(&irp_rx, (uint8_t*)&sync, 4, 100);
if (!result) if (!result)
continue; continue;
@@ -785,11 +787,11 @@ int main(void)
{ {
printf("Sync found (0x%04X)\n", sync); printf("Sync found (0x%04X)\n", sync);
result = usb_recv(&irp_rx, (UINT8*)&cmd, 4, 1000); result = usb_recv(&irp_rx, (uint8_t*)&cmd, 4, 1000);
if (!result) if (!result)
continue; continue;
result = usb_recv(&irp_rx, (UINT8*)&len, 4, 1000); result = usb_recv(&irp_rx, (uint8_t*)&len, 4, 1000);
if (!result) if (!result)
continue; continue;
@@ -841,7 +843,7 @@ int main(void)
if (remain < len) if (remain < len)
len = remain; len = remain;
result = usb_send(&irp_tx, (UINT8*)&pFlash8[tx_cnt], len, 1000); result = usb_send(&irp_tx, (uint8_t*)&pFlash8[tx_cnt], len, 1000);
if (!result) if (!result)
break; break;
tx_cnt += result; tx_cnt += result;
@@ -853,7 +855,7 @@ int main(void)
case 0x00000004: case 0x00000004:
*pVGA_ctrl &= ~SYS_VGA_BIT_MSTEN; *pVGA_ctrl &= ~SYS_VGA_BIT_MSTEN;
result = usb_recv(&irp_rx, (UINT8*)pBuf, len, 1000); result = usb_recv(&irp_rx, (uint8_t*)pBuf, len, 1000);
if (result) if (result)
{ {
printf("Read %d bytes\n", result); printf("Read %d bytes\n", result);
@@ -876,7 +878,7 @@ int main(void)
printf("done\n"); printf("done\n");
printf("Flash write..."); printf("Flash write...");
result = flash_program(&flash, flash_offset, (UINT8*)pBuf, len); result = flash_program(&flash, flash_offset, (uint8_t*)pBuf, len);
if (IS_ERROR(result)) if (IS_ERROR(result))
{ {
printf("failed (%08X)\n", result); printf("failed (%08X)\n", result);
@@ -885,7 +887,7 @@ int main(void)
printf("done\n"); printf("done\n");
printf("Flash verify..."); printf("Flash verify...");
result = flash_verify(&flash, flash_offset, (UINT8*)pBuf, len); result = flash_verify(&flash, flash_offset, (uint8_t*)pBuf, len);
if (IS_ERROR(result)) if (IS_ERROR(result))
{ {
printf("failed (%08X)\n", result); printf("failed (%08X)\n", result);
@@ -908,7 +910,7 @@ int main(void)
return 0; return 0;
} }
// pMem = (UINT8*)0x40000000; // pMem = (uint8_t*)0x40000000;
// result = fifo_write(&fifo_tx, pMem, 640, 0, FIFO_NONBLOCK); // result = fifo_write(&fifo_tx, pMem, 640, 0, FIFO_NONBLOCK);
// pMem += result; // pMem += result;
// usb_irp_enqueue(&irp_tx); // usb_irp_enqueue(&irp_tx);
src/test_irq.c
+27 -27
View File
@@ -14,13 +14,13 @@
char buffer[16384]; char buffer[16384];
char * volatile pPtr_r; char * volatile pPtr_r;
char * volatile pPtr_w; char * volatile pPtr_w;
static volatile INT32 mouse_x; static volatile int32_t mouse_x;
static volatile INT32 mouse_y; static volatile int32_t mouse_y;
static box_t box; static box_t box;
static gfx_t gfx; static gfx_t gfx;
static volatile int _g_posx, _g_posy; static volatile int _g_posx, _g_posy;
static volatile g_btn_l, g_btn_r; static volatile g_btn_l, g_btn_r;
static volatile UINT32 g_color; static volatile uint32_t g_color;
// ------------------------------------------------------------- // -------------------------------------------------------------
void handler0(void) void handler0(void)
@@ -42,10 +42,10 @@ void handler2(void)
void handler3(void) void handler3(void)
{ {
volatile UINT32 *pUART0_stat = (UINT32*)SYS_UART0_STAT; volatile uint32_t *pUART0_stat = (uint32_t*)SYS_UART0_STAT;
volatile UINT32 *pUART0_data = (UINT32*)SYS_UART0_DATA; volatile uint32_t *pUART0_data = (uint32_t*)SYS_UART0_DATA;
volatile UINT32 *pUART1_stat = (UINT32*)SYS_UART1_STAT; volatile uint32_t *pUART1_stat = (uint32_t*)SYS_UART1_STAT;
volatile UINT32 *pUART1_data = (UINT32*)SYS_UART1_DATA; volatile uint32_t *pUART1_data = (uint32_t*)SYS_UART1_DATA;
while(0x200 & *pUART0_stat) while(0x200 & *pUART0_stat)
{ {
@@ -72,7 +72,7 @@ void handler4(void)
void handler5(void) void handler5(void)
{ {
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
// Ack // Ack
*pVGA_ctrl |= SYS_VGA_BIT_BUFCHG_FLAG; *pVGA_ctrl |= SYS_VGA_BIT_BUFCHG_FLAG;
@@ -83,10 +83,10 @@ void handler6(void)
{ {
int p, i; int p, i;
ps2_if_t *pIF; ps2_if_t *pIF;
UINT8 mouse_rsp[3]; uint8_t mouse_rsp[3];
UINT32 timeout_count, key; uint32_t timeout_count, key;
INT32 dx, dy; int32_t dx, dy;
for (p=0; p < PS2_get_num_if(); p++) for (p=0; p < PS2_get_num_if(); p++)
{ {
@@ -123,7 +123,7 @@ void handler6(void)
{ {
break; break;
} }
mouse_rsp[i] = (UINT8)*pIF->pDATA; mouse_rsp[i] = (uint8_t)*pIF->pDATA;
} }
if (!timeout_count) if (!timeout_count)
{ {
@@ -148,7 +148,7 @@ void handler6(void)
{ {
if (g_btn_r == 0) if (g_btn_r == 0)
{ {
g_color = (UINT32)rand(); g_color = (uint32_t)rand();
} }
g_btn_r = 1; g_btn_r = 1;
} }
@@ -183,17 +183,17 @@ int main(void)
{ {
int i; int i;
volatile UINT32 *pUART0_stat = (UINT32*)SYS_UART0_STAT; volatile uint32_t *pUART0_stat = (uint32_t*)SYS_UART0_STAT;
volatile UINT32 *pUART1_stat = (UINT32*)SYS_UART1_STAT; volatile uint32_t *pUART1_stat = (uint32_t*)SYS_UART1_STAT;
volatile UINT32 *pUART0_baud = (UINT32*)SYS_UART0_BAUD; volatile uint32_t *pUART0_baud = (uint32_t*)SYS_UART0_BAUD;
volatile UINT32 *pUART1_baud = (UINT32*)SYS_UART1_BAUD; volatile uint32_t *pUART1_baud = (uint32_t*)SYS_UART1_BAUD;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_moffs_1 = (UINT32*)SYS_VGA_FB_BACK; uint32_t volatile *pVGA_moffs_1 = (uint32_t*)SYS_VGA_FB_BACK;
UINT32 volatile *pVGA_cgcol = (UINT32*)SYS_VGA_CGCOL; uint32_t volatile *pVGA_cgcol = (uint32_t*)SYS_VGA_CGCOL;
UINT32 volatile *pFlashPicture = (UINT32*)(SYS_FLASH_MEM + 0x00600000); uint32_t volatile *pFlashPicture = (uint32_t*)(SYS_FLASH_MEM + 0x00600000);
UINT32 framecount; uint32_t framecount;
UINT32 start, end; uint32_t start, end;
char string[65]; char string[65];
interrupt_register(0, (void*)handler0); interrupt_register(0, (void*)handler0);
@@ -300,13 +300,13 @@ int main(void)
GFX_frame(&gfx, GFX_FRAME_SYNC); GFX_frame(&gfx, GFX_FRAME_SYNC);
framecount--; framecount--;
while ((_g_posx != (UINT32)mouse_x) || (_g_posy != (UINT32)mouse_y) || g_btn_r || g_btn_l) while ((_g_posx != (uint32_t)mouse_x) || (_g_posy != (uint32_t)mouse_y) || g_btn_r || g_btn_l)
{ {
GFX_restore(&gfx, &box, _g_posx, _g_posy); GFX_restore(&gfx, &box, _g_posx, _g_posy);
_g_posx = (UINT32)mouse_x; _g_posx = (uint32_t)mouse_x;
_g_posy = (UINT32)mouse_y; _g_posy = (uint32_t)mouse_y;
if (g_btn_l && !g_btn_r) if (g_btn_l && !g_btn_r)
{ {
src/test_vga.c
+23 -23
View File
@@ -11,18 +11,18 @@
#include "mips_gfx.h" #include "mips_gfx.h"
#include "mips_ps2.h" #include "mips_ps2.h"
static volatile INT32 mouse_x; static volatile int32_t mouse_x;
static volatile INT32 mouse_y; static volatile int32_t mouse_y;
static box_t box_even, box_odd, line_h_even, line_v_even, line_h_odd, line_v_odd, cross_v, cross_h; static box_t box_even, box_odd, line_h_even, line_v_even, line_h_odd, line_v_odd, cross_v, cross_h;
static gfx_t gfx; static gfx_t gfx;
static volatile int _g_posx, _g_posy; static volatile int _g_posx, _g_posy;
static volatile g_btn_l, g_btn_r; static volatile g_btn_l, g_btn_r;
static volatile UINT32 g_color; static volatile uint32_t g_color;
// ------------------------------------------------------------- // -------------------------------------------------------------
void handler5(void) void handler5(void)
{ {
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
// Ack // Ack
*pVGA_ctrl |= SYS_VGA_BIT_BUFCHG_FLAG; *pVGA_ctrl |= SYS_VGA_BIT_BUFCHG_FLAG;
@@ -33,10 +33,10 @@ void handler6(void)
{ {
int p, i; int p, i;
ps2_if_t *pIF; ps2_if_t *pIF;
UINT8 mouse_rsp[3]; uint8_t mouse_rsp[3];
UINT32 timeout_count, key; uint32_t timeout_count, key;
INT32 dx, dy; int32_t dx, dy;
for (p=0; p < PS2_get_num_if(); p++) for (p=0; p < PS2_get_num_if(); p++)
{ {
@@ -73,7 +73,7 @@ void handler6(void)
{ {
break; break;
} }
mouse_rsp[i] = (UINT8)*pIF->pDATA; mouse_rsp[i] = (uint8_t)*pIF->pDATA;
} }
if (!timeout_count) if (!timeout_count)
{ {
@@ -121,18 +121,18 @@ int main(void)
{ {
int i; int i;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_moffs_1 = (UINT32*)SYS_VGA_FB_BACK; uint32_t volatile *pVGA_moffs_1 = (uint32_t*)SYS_VGA_FB_BACK;
UINT32 volatile *pVGA_cgcol = (UINT32*)SYS_VGA_CGCOL; uint32_t volatile *pVGA_cgcol = (uint32_t*)SYS_VGA_CGCOL;
UINT32 *pFlashPicture = (UINT32*)(SYS_FLASH_MEM + 0x00600000); uint32_t *pFlashPicture = (uint32_t*)(SYS_FLASH_MEM + 0x00600000);
UINT32 framecount; uint32_t framecount;
UINT32 start, end; uint32_t start, end;
UINT32 *pPic; uint32_t *pPic;
UINT32 rmb_posx, rmb_posy, rmb_clicked; uint32_t rmb_posx, rmb_posy, rmb_clicked;
pPic = (UINT32*)malloc(800*600*sizeof(UINT32)); pPic = (uint32_t*)malloc(800*600*sizeof(uint32_t));
memcpy(pPic, pFlashPicture, 800*600*sizeof(UINT32)); memcpy(pPic, pFlashPicture, 800*600*sizeof(uint32_t));
interrupt_register(5, (void*)handler5); interrupt_register(5, (void*)handler5);
interrupt_register(6, (void*)handler6); interrupt_register(6, (void*)handler6);
@@ -181,11 +181,11 @@ int main(void)
GFX_frame(&gfx, GFX_FRAME_SYNC); GFX_frame(&gfx, GFX_FRAME_SYNC);
framecount--; framecount--;
while ((_g_posx != (UINT32)mouse_x) || (_g_posy != (UINT32)mouse_y) || g_btn_r || g_btn_l) while ((_g_posx != (uint32_t)mouse_x) || (_g_posy != (uint32_t)mouse_y) || g_btn_r || g_btn_l)
{ {
_g_posx = (UINT32)mouse_x; _g_posx = (uint32_t)mouse_x;
_g_posy = (UINT32)mouse_y; _g_posy = (uint32_t)mouse_y;
GFX_restore(&gfx, NULL, _g_posx, _g_posy); GFX_restore(&gfx, NULL, _g_posx, _g_posy);
@@ -210,7 +210,7 @@ int main(void)
if (g_btn_r) if (g_btn_r)
{ {
if (!rmb_clicked) if (!rmb_clicked)
g_color = (UINT32)rand(); g_color = (uint32_t)rand();
rmb_clicked = 1; rmb_clicked = 1;
rmb_posx = _g_posx; rmb_posx = _g_posx;
src/testbench.c
+152 -152
View File
@@ -25,26 +25,26 @@ extern int paranoia(int argc, char **argv);
gpio_if_t gpio_if; gpio_if_t gpio_if;
UINT32* pf(void) uint32_t* pf(void)
{ {
static UINT32 p; static uint32_t p;
return &p; return &p;
} }
// ------------------------------------------------------------- // -------------------------------------------------------------
void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage, UINT32 image_nx, UINT32 image_ny, UINT32 image_scale_x, UINT32 image_scale_y) void LoadPic(uint64_t *pScreen, uint32_t screen_nx, uint32_t screen_ny, uint32_t *pImage, uint32_t image_nx, uint32_t image_ny, uint32_t image_scale_x, uint32_t image_scale_y)
{ {
UINT32 off_x, off_y; uint32_t off_x, off_y;
UINT32 i, j, black; uint32_t i, j, black;
UINT32 *pScr, *pImg; uint32_t *pScr, *pImg;
off_x = (screen_nx-(image_scale_x*image_nx))/2; off_x = (screen_nx-(image_scale_x*image_nx))/2;
off_y = (screen_ny-(image_scale_y*image_ny))/2; off_y = (screen_ny-(image_scale_y*image_ny))/2;
black = 0; black = 0;
pScr = (UINT32*)pScreen; pScr = (uint32_t*)pScreen;
for (i=0; i < screen_nx*screen_ny; i += 8) for (i=0; i < screen_nx*screen_ny; i += 8)
{ {
__gfx_block_set_8(pScr, 0); __gfx_block_set_8(pScr, 0);
@@ -54,7 +54,7 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
if (!pImage) if (!pImage)
return; return;
pScr = ((UINT32*)pScreen) + screen_nx*off_y + off_x; pScr = ((uint32_t*)pScreen) + screen_nx*off_y + off_x;
pImg = pImage; pImg = pImage;
for (i=0; i < image_ny*image_nx; i += 8) for (i=0; i < image_ny*image_nx; i += 8)
@@ -65,19 +65,19 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
} }
/* /*
UINT32 off_x, off_y; uint32_t off_x, off_y;
UINT32 i; uint32_t i;
UINT32 *pScr; uint32_t *pScr;
off_x = (screen_nx-(image_scale_x*image_nx))/2; off_x = (screen_nx-(image_scale_x*image_nx))/2;
off_y = (screen_ny-(image_scale_y*image_ny))/2; off_y = (screen_ny-(image_scale_y*image_ny))/2;
memset(pScreen, 0, screen_nx*screen_ny*sizeof(UINT32)); memset(pScreen, 0, screen_nx*screen_ny*sizeof(uint32_t));
pScr = ((UINT32*)pScreen) + screen_nx*off_y + off_x; pScr = ((uint32_t*)pScreen) + screen_nx*off_y + off_x;
for (i=0; i < image_ny; i++) for (i=0; i < image_ny; i++)
{ {
memcpy(pScr, &pImage[i*image_nx], image_nx*sizeof(UINT32)); memcpy(pScr, &pImage[i*image_nx], image_nx*sizeof(uint32_t));
pScr += screen_nx; pScr += screen_nx;
} }
*/ */
@@ -85,10 +85,10 @@ void LoadPic(UINT64 *pScreen, UINT32 screen_nx, UINT32 screen_ny, UINT32 *pImage
int IsEndianBig(void) int IsEndianBig(void)
{ {
UINT8 *pBuf; uint8_t *pBuf;
UINT32 word; uint32_t word;
word = 0x12345678; word = 0x12345678;
pBuf = (UINT8*)&word; pBuf = (uint8_t*)&word;
if (((*pBuf+0) == 0x12) && (*(pBuf+1) == 0x34) && (*(pBuf+2) == 0x56) && (*(pBuf+3) == 0x78)) if (((*pBuf+0) == 0x12) && (*(pBuf+1) == 0x34) && (*(pBuf+2) == 0x56) && (*(pBuf+3) == 0x78))
{ {
return 1; return 1;
@@ -102,8 +102,8 @@ int IsEndianBig(void)
void handler3(void) void handler3(void)
{ {
volatile UINT32 *pUART_stat = (UINT32*)SYS_UART_STAT; volatile uint32_t *pUART_stat = (uint32_t*)SYS_UART_STAT;
volatile UINT32 *pUART_data = (UINT32*)SYS_UART_DATA; volatile uint32_t *pUART_data = (uint32_t*)SYS_UART_DATA;
if((0x10 & *pUART_stat)) if((0x10 & *pUART_stat))
{ {
@@ -119,9 +119,9 @@ int posx, posy;
void handler7(void) void handler7(void)
{ {
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
time_t curr_date; time_t curr_date;
struct tm *pDate; struct tm *pDate;
@@ -133,12 +133,12 @@ void handler7(void)
GFX_restore(&gfx, &box, posx, posy); GFX_restore(&gfx, &box, posx, posy);
GFX_show(&gfx); GFX_show(&gfx);
posx = (UINT32)rand()%800; posx = (uint32_t)rand()%800;
posy = (UINT32)rand()%600; posy = (uint32_t)rand()%600;
GFX_frame(&gfx, GFX_FRAME_NOSYNC); GFX_frame(&gfx, GFX_FRAME_NOSYNC);
GFX_box_draw(&gfx, &box, posx, posy, (UINT32)rand()); GFX_box_draw(&gfx, &box, posx, posy, (uint32_t)rand());
GFX_show(&gfx); GFX_show(&gfx);
*pTim0_cmp = (UINT32)(rand() & 0x000FFFFF); *pTim0_cmp = (uint32_t)(rand() & 0x000FFFFF);
*pTim_ctrl |= 1; *pTim_ctrl |= 1;
} }
@@ -215,10 +215,10 @@ void PrintCPUinfo(void)
} }
UINT32 uncached_cachemiss_bug(void) uint32_t uncached_cachemiss_bug(void)
{ {
UINT32 result; uint32_t result;
UINT32 pMem[2]; uint32_t pMem[2];
pMem[0] = 0x12345678; pMem[0] = 0x12345678;
pMem[1] = 0xFFFFFFFF; pMem[1] = 0xFFFFFFFF;
@@ -246,10 +246,10 @@ UINT32 uncached_cachemiss_bug(void)
return result; return result;
} }
UINT32 non_aligned_load() uint32_t non_aligned_load()
{ {
UINT32 result; uint32_t result;
UINT32 pMem[3]; uint32_t pMem[3];
__asm__ __asm__
( (
@@ -492,11 +492,11 @@ int Test12_MulDiv()
int Test13_COP0_Load_Store(void) int Test13_COP0_Load_Store(void)
{ {
int i,size; int i,size;
UINT32 *pSrc32, *pDst32; uint32_t *pSrc32, *pDst32;
size = 0x2000; size = 0x2000;
pSrc32 = (UINT32*)0xBFC00000; pSrc32 = (uint32_t*)0xBFC00000;
pDst32 = (UINT32*)calloc(size,sizeof(UINT32)); pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t));
for (i=0; i < size/4; i++) for (i=0; i < size/4; i++)
{ {
CP0_TR_read_ptr(&pSrc32[i]); CP0_TR_read_ptr(&pSrc32[i]);
@@ -517,11 +517,11 @@ int Test13_COP0_Load_Store(void)
int Test14_DCACHE_invalidate(void) int Test14_DCACHE_invalidate(void)
{ {
int i,size; int i,size;
UINT32 *pSrc32, *pDst32; uint32_t *pSrc32, *pDst32;
size = 0x2000; size = 0x2000;
pSrc32 = (UINT32*)0xBFC00000; pSrc32 = (uint32_t*)0xBFC00000;
pDst32 = (UINT32*)calloc(size,sizeof(UINT32)); pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t));
for (i=0; i < size/4; i++) for (i=0; i < size/4; i++)
{ {
pDst32[i] = pSrc32[i]; pDst32[i] = pSrc32[i];
@@ -539,7 +539,7 @@ int Test14_DCACHE_invalidate(void)
if (i) if (i)
return TEST14_ERROR; return TEST14_ERROR;
pDst32 = (UINT32*)calloc(size,sizeof(UINT32)); pDst32 = (uint32_t*)calloc(size,sizeof(uint32_t));
for (i=0; i < size/4; i++) for (i=0; i < size/4; i++)
{ {
pDst32[i] = pSrc32[i]; pDst32[i] = pSrc32[i];
@@ -566,9 +566,9 @@ int Test15_pi_calc()
int i, j, k; int i, j, k;
int carry = 0; int carry = 0;
int arr[PI_MAXARR+1]; int arr[PI_MAXARR+1];
UINT32 int_part, result; uint32_t int_part, result;
UINT16 pi_res[200] = {0}; uint16_t pi_res[200] = {0};
UINT16 pi_ref[200] = uint16_t pi_ref[200] =
{ {
3141,5926,5358,9793,2384,6264,3383,2795, 288,4197,1693,9937,5105,8209,7494,4592,3078,1640,6286,2089,9862,8034,8253,4211, 3141,5926,5358,9793,2384,6264,3383,2795, 288,4197,1693,9937,5105,8209,7494,4592,3078,1640,6286,2089,9862,8034,8253,4211,
7067,9821,4808,6513,2823, 664,7093,8446, 955, 582,2317,2535,9408,1284,8111,7450,2841, 270,1938,5211, 555,9644,6229,4895, 7067,9821,4808,6513,2823, 664,7093,8446, 955, 582,2317,2535,9408,1284,8111,7450,2841, 270,1938,5211, 555,9644,6229,4895,
@@ -597,12 +597,12 @@ int Test15_pi_calc()
} }
result = carry + sum/PI_SCALE; result = carry + sum/PI_SCALE;
int_part = PI_SCALE * (result / PI_SCALE); int_part = PI_SCALE * (result / PI_SCALE);
pi_res[k] = (UINT16)(result - int_part); pi_res[k] = (uint16_t)(result - int_part);
carry = sum % PI_SCALE; carry = sum % PI_SCALE;
k++; k++;
} }
for (k=0; k < sizeof(pi_ref)/sizeof(UINT16); k++) for (k=0; k < sizeof(pi_ref)/sizeof(uint16_t); k++)
{ {
printf("%d", pi_res[k]); printf("%d", pi_res[k]);
} }
@@ -621,27 +621,27 @@ int Test15_pi_calc()
int Test16_MemTest(void) int Test16_MemTest(void)
{ {
int result, i, j, cnt, size; int result, i, j, cnt, size;
UINT8 *ram8 = NULL; uint8_t *ram8 = NULL;
UINT16 *ram16 = NULL; uint16_t *ram16 = NULL;
UINT32 *ram32 = NULL; uint32_t *ram32 = NULL;
UINT32 volatile *pFlashIO = (UINT32*)SYS_FLASH_IO; uint32_t volatile *pFlashIO = (uint32_t*)SYS_FLASH_IO;
UINT32 volatile *pFlashMem = (UINT32*)SYS_FLASH_MEM; uint32_t volatile *pFlashMem = (uint32_t*)SYS_FLASH_MEM;
UINT32 volatile *pROM = (UINT32*)0xBFC00000; uint32_t volatile *pROM = (uint32_t*)0xBFC00000;
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_moffs_1 = (UINT32*)SYS_VGA_FB_BACK; uint32_t volatile *pVGA_moffs_1 = (uint32_t*)SYS_VGA_FB_BACK;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
UINT32 *pSrc32, *pDst32; uint32_t *pSrc32, *pDst32;
UINT32 start, end; uint32_t start, end;
UINT32 color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080}; uint32_t color_cycle[12] = {0x000000FF, 0x00808080, 0x0000FFFF, 0x00808080, 0x0000FF00, 0x00808080, 0x00FFFF00, 0x00808080, 0x00FF0000, 0x00808080, 0x00FF00FF, 0x00808080};
// ---------------------------------------------------------- // ----------------------------------------------------------
// Memtest BEGIN // Memtest BEGIN
@@ -651,18 +651,18 @@ int Test16_MemTest(void)
start = clock(); start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=0; i < SMALL_TEST_SIZE/4; i++) for (i=0; i < SMALL_TEST_SIZE/4; i++)
pSSRAM[i] = (UINT32)i; pSSRAM[i] = (uint32_t)i;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start))); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
PrintBuffer8((UINT8*)pSSRAM, 16, 256); PrintBuffer8((uint8_t*)pSSRAM, 16, 256);
printf("Verify (32-Bit access)..."); printf("Verify (32-Bit access)...");
start = clock(); start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--) for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--)
if (pSSRAM[i] != (UINT32)i) if (pSSRAM[i] != (uint32_t)i)
break; break;
end = clock(); end = clock();
@@ -673,20 +673,20 @@ int Test16_MemTest(void)
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start))); printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
*/ */
// ---------------------------------------------------------- // ----------------------------------------------------------
pSrc32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32)); pSrc32 = (uint32_t*)calloc(TEST_SIZE/4,sizeof(uint32_t));
pDst32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32)); pDst32 = (uint32_t*)calloc(TEST_SIZE/4,sizeof(uint32_t));
// Memtest BEGIN // Memtest BEGIN
printf("Dump first 16 bytes of flash blocks\n"); printf("Dump first 16 bytes of flash blocks\n");
for (i=0; i < FLASH_SIZE; i += 0x40000) for (i=0; i < FLASH_SIZE; i += 0x40000)
memdump((UINT8*)(pFlashIO+i/4), 0, 16, 16); memdump((uint8_t*)(pFlashIO+i/4), 0, 16, 16);
printf("\n"); printf("\n");
printf("SDRAM Memory Test\n"); printf("SDRAM Memory Test\n");
printf("Test size %d kByte\n\n", TEST_SIZE/1024); printf("Test size %d kByte\n\n", TEST_SIZE/1024);
ram8 = (UINT8*)pDst32; ram8 = (uint8_t*)pDst32;
printf("Zeroize SDRAM (memset)..."); printf("Zeroize SDRAM (memset)...");
start = clock(); start = clock();
memset(ram8, 0, TEST_SIZE); memset(ram8, 0, TEST_SIZE);
@@ -696,34 +696,34 @@ int Test16_MemTest(void)
printf("Zeroize SDRAM (8-Bit access)..."); printf("Zeroize SDRAM (8-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE; i++) for (i=0; i < TEST_SIZE; i++)
ram8[i] = (UINT8)0; ram8[i] = (uint8_t)0;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
ram16 = (UINT16*)pDst32; ram16 = (uint16_t*)pDst32;
printf("Zeroize SDRAM (16-Bit access)..."); printf("Zeroize SDRAM (16-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE/2; i++) for (i=0; i < TEST_SIZE/2; i++)
ram16[i] = (UINT16)0; ram16[i] = (uint16_t)0;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
ram32 = (UINT32*)pDst32; ram32 = (uint32_t*)pDst32;
printf("Zeroize SDRAM (32-Bit access)..."); printf("Zeroize SDRAM (32-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE/4; i++) for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = (UINT32)0; ram32[i] = (uint32_t)0;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
ram8 = (UINT8*)pDst32; ram8 = (uint8_t*)pDst32;
printf("Write SDRAM (8-Bit access)..."); printf("Write SDRAM (8-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE; i++) for (i=0; i < TEST_SIZE; i++)
ram8[i] = (UINT8)i; ram8[i] = (uint8_t)i;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
@@ -731,7 +731,7 @@ int Test16_MemTest(void)
printf("Verify SDRAM (8-Bit access)..."); printf("Verify SDRAM (8-Bit access)...");
start = clock(); start = clock();
for (i=TEST_SIZE-1; i >= 0; i--) for (i=TEST_SIZE-1; i >= 0; i--)
if (ram8[i] != (UINT8)i) if (ram8[i] != (uint8_t)i)
break; break;
end = clock(); end = clock();
@@ -744,11 +744,11 @@ int Test16_MemTest(void)
else else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
ram16 = (UINT16*)pDst32; ram16 = (uint16_t*)pDst32;
printf("Write SDRAM (16-Bit access)..."); printf("Write SDRAM (16-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE/2; i++) for (i=0; i < TEST_SIZE/2; i++)
ram16[i] = (UINT16)i; ram16[i] = (uint16_t)i;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
@@ -756,7 +756,7 @@ int Test16_MemTest(void)
printf("Verify SDRAM (16-Bit access)..."); printf("Verify SDRAM (16-Bit access)...");
start = clock(); start = clock();
for (i=TEST_SIZE/2-1; i >= 0; i--) for (i=TEST_SIZE/2-1; i >= 0; i--)
if (ram16[i] != (UINT16)i) if (ram16[i] != (uint16_t)i)
break; break;
end = clock(); end = clock();
@@ -770,12 +770,12 @@ int Test16_MemTest(void)
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
ram32 = (UINT32*)pDst32; ram32 = (uint32_t*)pDst32;
printf("Write SDRAM (32-Bit access)..."); printf("Write SDRAM (32-Bit access)...");
start = clock(); start = clock();
for (i=0; i < TEST_SIZE/4; i++) for (i=0; i < TEST_SIZE/4; i++)
{ {
ram32[i] = (UINT32)i; ram32[i] = (uint32_t)i;
} }
end = clock(); end = clock();
@@ -785,7 +785,7 @@ int Test16_MemTest(void)
start = clock(); start = clock();
for (i=TEST_SIZE/4-1; i >= 0; i--) for (i=TEST_SIZE/4-1; i >= 0; i--)
{ {
if (ram32[i] != (UINT32)i) if (ram32[i] != (uint32_t)i)
break; break;
} }
@@ -802,11 +802,11 @@ int Test16_MemTest(void)
printf("\n"); printf("\n");
printf("Small data test (size = %d kByte)\n", SMALL_TEST_SIZE/1024); printf("Small data test (size = %d kByte)\n", SMALL_TEST_SIZE/1024);
printf("Write SDRAM (32-Bit access)..."); printf("Write SDRAM (32-Bit access)...");
ram32 = (UINT32*)pDst32; ram32 = (uint32_t*)pDst32;
start = clock(); start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=0; i < SMALL_TEST_SIZE/4; i++) for (i=0; i < SMALL_TEST_SIZE/4; i++)
ram32[i] = (UINT32)i; ram32[i] = (uint32_t)i;
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
@@ -817,7 +817,7 @@ int Test16_MemTest(void)
start = clock(); start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++) for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--) for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--)
if (ram32[i] != (UINT32)i) if (ram32[i] != (uint32_t)i)
break; break;
end = clock(); end = clock();
@@ -856,7 +856,7 @@ int Test16_MemTest(void)
printf("Memcpy() Flash(IO) => SDRAM \n"); printf("Memcpy() Flash(IO) => SDRAM \n");
printf("Copying %d kBytes...", FLASH_SIZE/(1024)); printf("Copying %d kBytes...", FLASH_SIZE/(1024));
start = clock(); start = clock();
memcpy(pDst32, (UINT32*)pFlashIO, FLASH_SIZE); memcpy(pDst32, (uint32_t*)pFlashIO, FLASH_SIZE);
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
printf("\n"); printf("\n");
@@ -864,14 +864,14 @@ int Test16_MemTest(void)
printf("Memcpy() Flash(MEM) => SDRAM \n"); printf("Memcpy() Flash(MEM) => SDRAM \n");
printf("Copying %d kBytes...", FLASH_SIZE/(1024)); printf("Copying %d kBytes...", FLASH_SIZE/(1024));
start = clock(); start = clock();
memcpy(pDst32, (UINT32*)pFlashMem, FLASH_SIZE); memcpy(pDst32, (uint32_t*)pFlashMem, FLASH_SIZE);
end = clock(); end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC)); printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1024*1024*(double)(end-start)/CLOCKS_PER_SEC));
printf("\n"); printf("\n");
#if 1 #if 1
*pVGA_moffs_0 = (UINT32)pSrc32; *pVGA_moffs_0 = (uint32_t)pSrc32;
*pVGA_moffs_1 = (UINT32)pSrc32; *pVGA_moffs_1 = (uint32_t)pSrc32;
*pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_FIN_INTEN; *pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_FIN_INTEN;
*pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_EMPTY_INTEN; *pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_EMPTY_INTEN;
@@ -879,12 +879,12 @@ int Test16_MemTest(void)
{ {
*pVGA_ctrl &= ~(SYS_VGA_BIT_BLIT_OP_CONSTCOL | SYS_VGA_BIT_MSTEN); *pVGA_ctrl &= ~(SYS_VGA_BIT_BLIT_OP_CONSTCOL | SYS_VGA_BIT_MSTEN);
fprintf(stderr, "Blitter copy %d bytes (scan disabled)...", TEST_SIZE/4); fprintf(stderr, "Blitter copy %d bytes (scan disabled)...", TEST_SIZE/4);
*pVGA_src0 = (UINT32)pSrc32; *pVGA_src0 = (uint32_t)pSrc32;
*pVGA_dst = (UINT32)pDst32; *pVGA_dst = (uint32_t)pDst32;
*pVGA_dimx_src0 = (UINT32)0; *pVGA_dimx_src0 = (uint32_t)0;
*pVGA_dimx_dst = (UINT32)0; *pVGA_dimx_dst = (uint32_t)0;
*pVGA_nx = (UINT32)TEST_SIZE/4; *pVGA_nx = (uint32_t)TEST_SIZE/4;
*pVGA_ny = (UINT32)1; *pVGA_ny = (uint32_t)1;
start = clock(); start = clock();
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
@@ -898,12 +898,12 @@ int Test16_MemTest(void)
*pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL; *pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL;
fprintf(stderr, "Blitter memset %d bytes (scan disabled)...", TEST_SIZE/4); fprintf(stderr, "Blitter memset %d bytes (scan disabled)...", TEST_SIZE/4);
*pVGA_src0 = (UINT32)pSrc32; *pVGA_src0 = (uint32_t)pSrc32;
*pVGA_dst = (UINT32)pDst32; *pVGA_dst = (uint32_t)pDst32;
*pVGA_dimx_src0 = (UINT32)0; *pVGA_dimx_src0 = (uint32_t)0;
*pVGA_dimx_dst = (UINT32)0; *pVGA_dimx_dst = (uint32_t)0;
*pVGA_nx = (UINT32)TEST_SIZE/4; *pVGA_nx = (uint32_t)TEST_SIZE/4;
*pVGA_ny = (UINT32)1; *pVGA_ny = (uint32_t)1;
start = clock(); start = clock();
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
@@ -920,12 +920,12 @@ int Test16_MemTest(void)
*pVGA_ctrl |= SYS_VGA_BIT_MSTEN; *pVGA_ctrl |= SYS_VGA_BIT_MSTEN;
*pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL; *pVGA_ctrl &= ~SYS_VGA_BIT_BLIT_OP_CONSTCOL;
sleep(500); sleep(500);
*pVGA_src0 = (UINT32)pSrc32; *pVGA_src0 = (uint32_t)pSrc32;
*pVGA_dst = (UINT32)pDst32; *pVGA_dst = (uint32_t)pDst32;
*pVGA_dimx_src0 = (UINT32)0; *pVGA_dimx_src0 = (uint32_t)0;
*pVGA_dimx_dst = (UINT32)0; *pVGA_dimx_dst = (uint32_t)0;
*pVGA_nx = (UINT32)TEST_SIZE/4; *pVGA_nx = (uint32_t)TEST_SIZE/4;
*pVGA_ny = (UINT32)1; *pVGA_ny = (uint32_t)1;
start = clock(); start = clock();
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
@@ -939,12 +939,12 @@ int Test16_MemTest(void)
*pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL; *pVGA_ctrl |= SYS_VGA_BIT_BLIT_OP_CONSTCOL;
fprintf(stderr, "Blitter memset %d bytes (scan enabled)...", TEST_SIZE/4); fprintf(stderr, "Blitter memset %d bytes (scan enabled)...", TEST_SIZE/4);
*pVGA_src0 = (UINT32)pSrc32; *pVGA_src0 = (uint32_t)pSrc32;
*pVGA_dst = (UINT32)pDst32; *pVGA_dst = (uint32_t)pDst32;
*pVGA_dimx_src0 = (UINT32)0; *pVGA_dimx_src0 = (uint32_t)0;
*pVGA_dimx_dst = (UINT32)0; *pVGA_dimx_dst = (uint32_t)0;
*pVGA_nx = (UINT32)TEST_SIZE/4; *pVGA_nx = (uint32_t)TEST_SIZE/4;
*pVGA_ny = (UINT32)1; *pVGA_ny = (uint32_t)1;
start = clock(); start = clock();
for (i=0; i < 10; i++) for (i=0; i < 10; i++)
@@ -966,7 +966,7 @@ int Test16_MemTest(void)
#endif #endif
size = 0x2000; size = 0x2000;
memcpy(pDst32, (UINT32*)pROM, size); memcpy(pDst32, (uint32_t*)pROM, size);
printf("Verify boot ROM..."); printf("Verify boot ROM...");
for (i=size/4-1; i >= 0; i--) for (i=size/4-1; i >= 0; i--)
if (pDst32[i] != pROM[i]) if (pDst32[i] != pROM[i])
@@ -997,16 +997,16 @@ int Test16_MemTest(void)
if (i != FLASH_SIZE/4) if (i != FLASH_SIZE/4)
{ {
printf("failed\n"); printf("failed\n");
memdump((UINT8*)&pFlashIO[i], 0, 16, 256); memdump((uint8_t*)&pFlashIO[i], 0, 16, 256);
memdump((UINT8*)&pFlashMem[i], 0, 16, 256); memdump((uint8_t*)&pFlashMem[i], 0, 16, 256);
} }
else else
{ {
printf("passed\n"); printf("passed\n");
} }
// memdump((UINT8*)pSrc32, 0, 16, size); // memdump((uint8_t*)pSrc32, 0, 16, size);
// memdump((UINT8*)0x40000000, 0, 16, 1024); // memdump((uint8_t*)0x40000000, 0, 16, 1024);
// Memtest END // Memtest END
// ---------------------------------------------------------- // ----------------------------------------------------------
@@ -1020,42 +1020,42 @@ int Test16_MemTest(void)
int main (void) int main (void)
{ {
int result, i, j, cnt, size; int result, i, j, cnt, size;
UINT32 volatile *pUART_baud = (UINT32*)SYS_UART_BAUD; uint32_t volatile *pUART_baud = (uint32_t*)SYS_UART_BAUD;
UINT32 volatile *pUART_stat = (UINT32*)SYS_UART_STAT; uint32_t volatile *pUART_stat = (uint32_t*)SYS_UART_STAT;
UINT32 volatile *pGPIO = (UINT32*)SYS_GPIO_0_DATA; uint32_t volatile *pGPIO = (uint32_t*)SYS_GPIO_0_DATA;
UINT32 volatile *pReg_usec = (UINT32*)SYS_TIMER_USEC; uint32_t volatile *pReg_usec = (uint32_t*)SYS_TIMER_USEC;
UINT32 volatile *pReg_sec = (UINT32*)SYS_TIMER_SEC; uint32_t volatile *pReg_sec = (uint32_t*)SYS_TIMER_SEC;
UINT32 volatile *pSSRAM = (UINT32*)SYS_SSRAM_IO; uint32_t volatile *pSSRAM = (uint32_t*)SYS_SSRAM_IO;
UINT32 volatile *pTim_ctrl = (UINT32*)SYS_ITIM_CTRL; uint32_t volatile *pTim_ctrl = (uint32_t*)SYS_ITIM_CTRL;
UINT32 volatile *pTim_stat = (UINT32*)SYS_ITIM_STAT; uint32_t volatile *pTim_stat = (uint32_t*)SYS_ITIM_STAT;
UINT32 volatile *pTim0_cnt = (UINT32*)SYS_ITIM0_CNT; uint32_t volatile *pTim0_cnt = (uint32_t*)SYS_ITIM0_CNT;
UINT32 volatile *pTim0_cmp = (UINT32*)SYS_ITIM0_CMP; uint32_t volatile *pTim0_cmp = (uint32_t*)SYS_ITIM0_CMP;
UINT32 volatile *pTim1_cnt = (UINT32*)SYS_ITIM1_CNT; uint32_t volatile *pTim1_cnt = (uint32_t*)SYS_ITIM1_CNT;
UINT32 volatile *pTim1_cmp = (UINT32*)SYS_ITIM1_CMP; uint32_t volatile *pTim1_cmp = (uint32_t*)SYS_ITIM1_CMP;
UINT32 volatile *pVGA_cgcol = (UINT32*)SYS_VGA_CGCOL; uint32_t volatile *pVGA_cgcol = (uint32_t*)SYS_VGA_CGCOL;
UINT32 *pFlashPicture = (UINT32*)(SYS_FLASH_MEM + 0x00600000); uint32_t *pFlashPicture = (uint32_t*)(SYS_FLASH_MEM + 0x00600000);
UINT32 volatile *pVGA_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_ADDR; uint32_t volatile *pVGA_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_ADDR;
UINT32 volatile *pVGA_dst = (UINT32*)SYS_VGA_BLIT_DST_ADDR; uint32_t volatile *pVGA_dst = (uint32_t*)SYS_VGA_BLIT_DST_ADDR;
UINT32 volatile *pVGA_dimx_src0 = (UINT32*)SYS_VGA_BLIT_SRC0_DIMX; uint32_t volatile *pVGA_dimx_src0 = (uint32_t*)SYS_VGA_BLIT_SRC0_DIMX;
UINT32 volatile *pVGA_dimx_dst = (UINT32*)SYS_VGA_BLIT_DST_DIMX; uint32_t volatile *pVGA_dimx_dst = (uint32_t*)SYS_VGA_BLIT_DST_DIMX;
UINT32 volatile *pVGA_nx = (UINT32*)SYS_VGA_BLIT_NX; uint32_t volatile *pVGA_nx = (uint32_t*)SYS_VGA_BLIT_NX;
UINT32 volatile *pVGA_ny = (UINT32*)SYS_VGA_BLIT_NY; uint32_t volatile *pVGA_ny = (uint32_t*)SYS_VGA_BLIT_NY;
UINT32 volatile *pVGA_ctrl = (UINT32*)SYS_VGA_CTRL; uint32_t volatile *pVGA_ctrl = (uint32_t*)SYS_VGA_CTRL;
UINT32 volatile *pVGA_moffs_0 = (UINT32*)SYS_VGA_FB_FRONT; uint32_t volatile *pVGA_moffs_0 = (uint32_t*)SYS_VGA_FB_FRONT;
UINT32 volatile *pVGA_const_color = (UINT32*)SYS_VGA_BLIT_COLOR; uint32_t volatile *pVGA_const_color = (uint32_t*)SYS_VGA_BLIT_COLOR;
UINT32 screen_res_x, screen_res_y, screen_fps; uint32_t screen_res_x, screen_res_y, screen_fps;
UINT64 *pBuf64_0, *pBuf64_1; uint64_t *pBuf64_0, *pBuf64_1;
time_t curr_date; time_t curr_date;
struct tm *pDate, date; struct tm *pDate, date;
UINT32 start, end; uint32_t start, end;
char sel[80]; char sel[80];
struct timeval time_sec; struct timeval time_sec;
UINT32 *pPic; uint32_t *pPic;
pPic = (UINT32*)malloc(800*600*sizeof(UINT32)); pPic = (uint32_t*)malloc(800*600*sizeof(uint32_t));
memcpy(pPic, pFlashPicture, 800*600*sizeof(UINT32)); memcpy(pPic, pFlashPicture, 800*600*sizeof(uint32_t));
g_cnt = 1; g_cnt = 1;
Screen_clr(); Screen_clr();
@@ -1141,9 +1141,9 @@ int main (void)
Test16_MemTest(); Test16_MemTest();
printf("pf = %08X\n", (UINT32)pf()); printf("pf = %08X\n", (uint32_t)pf());
*pf() = 0x1234; *pf() = 0x1234;
printf("*pf = %08X\n", (UINT32)*pf()); printf("*pf = %08X\n", (uint32_t)*pf());
box_create(&box, 32, 32); box_create(&box, 32, 32);
GFX_init(&gfx); GFX_init(&gfx);
@@ -1151,7 +1151,7 @@ int main (void)
start = clock(); start = clock();
for (i=0; i < 10000; i++) for (i=0; i < 10000; i++)
{ {
GFX_box_draw_direct(&gfx, &box, (UINT32)rand()%800, (UINT32)rand()%600, (UINT32)rand()); GFX_box_draw_direct(&gfx, &box, (uint32_t)rand()%800, (uint32_t)rand()%600, (uint32_t)rand());
} }
end = clock(); end = clock();
src/ucb.c
+3 -3
View File
@@ -1,9 +1,9 @@
#include "libsys.h" #include "libsys.h"
#include "gpio.h" #include "gpio.h"
int uncached_cachemiss_bug(UINT32* pMem) int uncached_cachemiss_bug(uint32_t* pMem)
{ {
UINT32 result; uint32_t result;
pMem[0] = 0x12345678; pMem[0] = 0x12345678;
pMem[1] = 0xFFFFFFFF; pMem[1] = 0xFFFFFFFF;
@@ -34,7 +34,7 @@ int uncached_cachemiss_bug(UINT32* pMem)
int main() int main()
{ {
UINT32 volatile *pLed = (UINT32*)SYS_GPIO_0_BASE; uint32_t volatile *pLed = (uint32_t*)SYS_GPIO_0_BASE;
int buf[256], res; int buf[256], res;
res = uncached_cachemiss_bug(buf); res = uncached_cachemiss_bug(buf);