/*
* Public Functions
*
*/
void init(void)
{
/* We want to be in VBLANK-IN (retrace) */
vdp2_tvmd_display_clear();
// Set Color mode to mode 0 (1KWord Color RAM), 2 banks
MEMORY_WRITE(16, VDP2(RAMCTL), 0x1300);
// Enable color cal on NBG0 and NB2 only
MEMORY_WRITE(16, VDP2(CCCTL), 0);
MEMORY_WRITE(16, VDP2(CCCTL), 0x5 /* (1 << 2) | (1 << 0)*/);
MEMORY_WRITE(16, VDP2(CCRNA), 0x0);
MEMORY_WRITE(16, VDP2(CCRNB), 0x1F);
/* DMA Indirect list, aligned on 64 bytes due to more than 24bytes size (6*4*3=72) */
uint32_t dma_tbl[] __attribute__((aligned(64))) = {
(uint32_t)sizeof(PLANE0_CD), (uint32_t)_nbg0_cell_data, (uint32_t)PLANE0_CD,
(uint32_t)sizeof(PLANE0_CP), (uint32_t)_nbg0_color_palette, (uint32_t)PLANE0_CP,
(uint32_t)sizeof(PLANE2_CD), (uint32_t)_nbg2_cell_data, (uint32_t)PLANE2_CD,
(uint32_t)sizeof(PLANE2_CP), (uint32_t)_nbg2_color_palette, (uint32_t)PLANE2_CP
};
scu_dma_listcpy(dma_tbl, 4*3);
while(scu_dma_get_status(SCU_DMA_ALL_CH) == SCU_DMA_STATUS_WAIT);
/* set all other stuff */
init_scrollscreen_nbg0();
init_scrollscreen_nbg2();
set_VRAM_access();
g_cc_NBG0 = 0x0;
g_cc_NBG2 = 0x1F;
}
void
vdp2_tvmd_display_set(void)
{
uint16_t tvmd;
tvmd = MEMORY_READ(16, VDP2(TVMD));
tvmd |= 0x8000;
MEMORY_WRITE(16, VDP2(TVMD), tvmd);
}
void
vdp2_tvmd_display_clear(void)
{
uint16_t tvmd;
tvmd = MEMORY_READ(16, VDP2(TVMD));
tvmd &= 0x7FFF;
/* Change the DISP bit during VBLANK */
vdp2_tvmd_vblank_in_wait();
MEMORY_WRITE(16, VDP2(TVMD), tvmd);
}
void
vdp2_scrn_rp_mode_set(enum scrn_rp_mode_type mode)
{
vdp2_regs.rpmd &= 0xFFFE;
vdp2_regs.rpmd |= mode;
/* Write to memory. */
MEMORY_WRITE(16, VDP2(RPMD), vdp2_regs.rpmd);
}
void
vdp2_scrn_mosaic_clear(void)
{
vdp2_state.buffered_regs.mzctl &= 0xFFE0;
/* Write to memory */
MEMORY_WRITE(16, VDP2(MZCTL), vdp2_state.buffered_regs.mzctl);
}
int s_open(IncomingRequest *inc_request) {
FsResponse response;
FsOpenC data_c = inc_request->request.data.open;
int lock_result;
int server_handler = data_c.server_handler;
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.open.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
char *file_name = (char *) calloc(data_c.name_len, sizeof(char));
strncpy(file_name, data_c.name, data_c.name_len);
VDP3("Incoming OPEN request: %s, len = %zu (flags: %d)\n", file_name, data_c.name_len, data_c.flags);
if (inc_request->request.data.open.flags == O_RDONLY)
lock_result = session_lock_file(inc_request->request.data.open.server_handler, file_name, FLOCK_SH);
else
lock_result = session_lock_file(inc_request->request.data.open.server_handler, file_name, FLOCK_EX);
if(lock_result < 0) {
/* Nie udalo sie dostac blokady na plik - trzeba powiadomic o tym klienta. */
VDP0("Lock failed, request turned down.\n");
response.data.open.status = -1;
response.answer = EF_FILE_BLOCKED;
} else {
VDP0("Lock accepted, request accepted.\n");
VDP2("Attempting to open %s file in %d mode...\n", file_name, data_c.flags);
int fh = open(file_name, data_c.flags);
if(fh == -1) {
VDP1("File %s cannot be opened.\n", file_name);
session_unlock_file(inc_request->request.data.open.server_handler, lock_result);
response.data.open.status = -1;
response.answer = EF_NOT_FOUND;
response.data.open.fd = -1;
} else {
VDP1("File %s opened successfully. \n", file_name);
status = session_set(inc_request->request.data.open.server_handler, lock_result, fh);
response.data.open.status = lock_result;
response.answer = IF_OK;
response.data.open.fd = lock_result;
}
}
free(file_name);
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
void
vdp2_tvmd_display_clear(void)
{
_state_vdp2()->regs.tvmd &= 0x7FFF;
/* Change the DISP bit during VBLANK */
vdp2_tvmd_vblank_in_wait();
MEMORY_WRITE(16, VDP2(TVMD), _state_vdp2()->regs.tvmd);
}
void
vdp2_scrn_display_clear(uint8_t scrn, bool no_trans)
{
uint16_t trans_scrn;
/* Enable and disable scroll screens. */
vdp2_regs.bgon &= ~(1 << scrn);
if (no_trans) {
trans_scrn = scrn + 8;
vdp2_regs.bgon &= ~(1 << trans_scrn);
}
/* Write to register. */
MEMORY_WRITE(16, VDP2(BGON), vdp2_regs.bgon);
}
void
vdp2_scrn_scroll_y_set(uint8_t scrn, fix16_t scroll)
{
#ifdef DEBUG
/* Check if the background passed is valid */
assert((scrn == SCRN_NBG0) ||
(scrn == SCRN_RBG1) ||
(scrn == SCRN_NBG1) ||
(scrn == SCRN_NBG2) ||
(scrn == SCRN_NBG3) ||
(scrn == SCRN_RBG1));
#endif /* DEBUG */
/* All screen scroll values must be identified as positive
* values */
uint16_t in;
uint16_t dn;
switch (scrn) {
case SCRN_RBG1:
case SCRN_NBG0:
_set_fixed_point_scroll(&vdp2_state.nbg0.scroll.y, scroll, &in,
&dn);
/* Write to memory */
MEMORY_WRITE(16, VDP2(SCYIN0), in);
MEMORY_WRITE(16, VDP2(SCYDN0), dn);
break;
case SCRN_NBG1:
_set_fixed_point_scroll(&vdp2_state.nbg1.scroll.y, scroll, &in,
&dn);
/* Write to memory */
MEMORY_WRITE(16, VDP2(SCYIN1), in);
MEMORY_WRITE(16, VDP2(SCYDN1), dn);
break;
case SCRN_NBG2:
_set_integer_scroll(&vdp2_state.nbg3.scroll.y, scroll, &in);
/* Write to memory */
MEMORY_WRITE(16, VDP2(SCYN2), in);
break;
case SCRN_NBG3:
_set_integer_scroll(&vdp2_state.nbg3.scroll.y, scroll, &in);
/* Write to memory */
MEMORY_WRITE(16, VDP2(SCYN3), in);
break;
default:
return;
}
}
int s_close (IncomingRequest *inc_request)
{
FsResponse response;
FsCloseC data_c = inc_request->request.data.close;
int server_handler = data_c.server_handler;
int fd = data_c.fd;
VDP0 ("Closing operation\n");
if (session_check_if_exist(server_handler) == -1)
{
response.answer= EC_SESSION_TIMED_OUT;
response.data.close.status = -1;
VDP1 ("Session timed out with: %d\n", server_handler);
status = sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
return -1;
}
int file = session_get (server_handler, fd);
if (file == -1)
{
response.data.close.status = -1;
VDP0 ("Could not get file descriptor in close\n");
}
else
{
response.data.close.status = close(file);
session_unlock_file(server_handler, fd);
response.answer = IF_OK;
VDP2 ("Closing file with fd: %d with status %d\n", fd, response.data.close.status);
}
return sendto(sockd, &response, sizeof(FsResponse), 0,(struct sockaddr*) &(inc_request->client_addr), inc_request->client_addr_len);
}
void read_digital_pad(void)
{
if (g_digital.connected == 1)
{
joyUp = g_digital.pressed.button.up;
joyDown = g_digital.pressed.button.down;
joyRight = g_digital.pressed.button.right;
joyLeft = g_digital.pressed.button.left;
joyA = g_digital.released.button.a;
joyB = g_digital.released.button.b;
joyL = g_digital.released.button.l;
joyR = g_digital.released.button.r;
joyX = g_digital.released.button.x;
joyY = g_digital.released.button.y;
if (joyDown)
{
if(g_cc_NBG2 < 0x1F) g_cc_NBG2++;
}
else if (joyUp)
{
if(g_cc_NBG2 > 0x0) g_cc_NBG2--;
}
else if (joyRight)
{
if(g_cc_NBG0 > 0x0) g_cc_NBG0--;
}
else if (joyLeft)
{
if(g_cc_NBG0 < 0x1F) g_cc_NBG0++;
}
else if (joyA)
{
MEMORY_WRITE(16, VDP2(CCCTL), 0x0);
MEMORY_WRITE(16, VDP2(CCCTL), (1 << 15) | (1 << 14) | (1 << 12) | 0x5);
}
else if (joyB)
{
MEMORY_WRITE(16, VDP2(CCCTL), 0x0);
MEMORY_WRITE(16, VDP2(CCCTL), 0x5);
}
else if (joyL)
{
MEMORY_WRITE(16, VDP2(CCCTL), 0x0);
MEMORY_WRITE(16, VDP2(CCCTL), (1 << 10) | 0x5);
g_ecc_NBG0 = (g_ecc_NBG0 + 1) & 0x3;
MEMORY_WRITE(16, VDP2(SFCCMD), g_ecc_NBG0);
}
else if (joyR)
{
MEMORY_WRITE(16, VDP2(CCCTL), 0x0);
MEMORY_WRITE(16, VDP2(CCCTL), 0x5);
}
else if (joyX)
{
uint16_t reg = MEMORY_READ(16, VDP2(CCCTL));
MEMORY_WRITE(16, VDP2(CCCTL), reg | (1 << 9));
}
else if (joyY)
{
uint16_t reg = MEMORY_READ(16, VDP2(CCCTL));
MEMORY_WRITE(16, VDP2(CCCTL), reg & (0xFDFF));
}
// exit
if(g_digital.pressed.button.start) abort();
MEMORY_WRITE(16, VDP2(CCRNA), g_cc_NBG0 & 0x1F);
MEMORY_WRITE(16, VDP2(CCRNB), g_cc_NBG2 & 0x1F);
}
}
