github.com/mist-devel.mist-firmware
1
0
Fork 0
mirror of https://github.com/mist-devel/mist-firmware.git synced 2026-01-11 23:43:04 +00:00
Code Releases Activity
mist-devel.mist-firmware/ikbd.c
Gerald Schnabel 02bcff4b43 Fix several typos
2023-03-12 20:13:49 +01:00

685 lines
19 KiB
C
Raw Permalink Blame History

/*
http://removers.free.fr/wikipendium/wakka.php?wiki=IntelligentKeyboardBible
https://www.kernel.org/doc/Documentation/input/atarikbd.txt
ikbd ToDo:
Feature Example using/needing it impl. tested
---------------------------------------------------------------------
mouse y at bottom Bolo X X
mouse button key events Goldrunner/A_008 X X
joystick interrogation mode Xevious/A_004 X X
Absolute mouse mode Addicataball/A_050 X X
disable mouse ? X
disable joystick ? X
Joysticks also generate Goldrunner X -X
mouse button events!
Pause/Resume PACMANIA_STE/Gembench X
mouse keycode mode Goldrunner X X
Games that have ikbd problems:
PowerMonger/PP_106 fixed
Stardust fixed
M1 tank platoon/A_385 fixed
*/
#include <stdio.h>
#include <string.h>
#include "user_io.h"
#include "spi.h"
#include "ikbd.h"
#include "debug.h"
#include "hardware.h"
#include "utils.h"
#define IKBD_AUTO_MS 20
// atari ikbd stuff
#define IKBD_STATE_JOYSTICK_EVENT_REPORTING 0x01
#define IKBD_STATE_MOUSE_Y_BOTTOM 0x02
#define IKBD_STATE_MOUSE_BUTTON_AS_KEY 0x04 // mouse buttons act like keys
#define IKBD_STATE_MOUSE_DISABLED 0x08
#define IKBD_STATE_MOUSE_ABSOLUTE 0x10
#define IKBD_STATE_MOUSE_ABSOLUTE_IN_PROGRESS 0x20
#define IKBD_STATE_WAIT4RESET 0x40
#define IKBD_STATE_PAUSED 0x80
#define IKBD_STATE_MOUSE_KEYCODE 0x100
#define IKBD_DEFAULT IKBD_STATE_JOYSTICK_EVENT_REPORTING
/* ------------------- transmit queue ------------------- */
#define QUEUE_LEN 16 // power of 2!
static unsigned short tx_queue[QUEUE_LEN];
static unsigned char wptr = 0, rptr = 0;
static unsigned long ikbd_timer = 0;
/* -------- main structure to keep track of ikbd state -------- */
static struct {
unsigned short state;
unsigned long auto_timer; // auto report timer (50hz/20ms)
// ----- joystick state -------
struct {
unsigned char state; // current state
unsigned char prev; // last reported state
} joy[2];
// ----- mouse state -------
struct {
// current state
unsigned char but, but_prev;
short x, y;
struct {
// absolute mouse state
unsigned char buttons;
struct { unsigned short x, y; } max;
struct { unsigned char x, y; } scale;
struct { unsigned short x, y; } pos;
} abs;
} mouse;
// ----- clock state ------
unsigned char date[7];
unsigned int tx_cnt; // tx byte counter for debugging
// ----- buffer tp hold incoming commands ------
struct {
char size;
union {
struct {
unsigned char code; // cmd code
// command specific structures
union {
unsigned char mouse_button_action;
unsigned char reset;
struct { unsigned short max_x, max_y; } __attribute__ ((packed)) abs_mouse_pos;
struct { unsigned char dist_x, dist_y; } __attribute__ ((packed)) mouse_keycode;
struct { unsigned char x, y; } __attribute__ ((packed)) mouse_threshold;
struct { unsigned char x, y; } __attribute__ ((packed)) mouse_scale;
struct { unsigned char f; unsigned short x, y; } __attribute__ ((packed)) load_mouse_pos;
unsigned char date[6];
};
} __attribute__ ((packed)) command;
unsigned char byte[0];
};
} buffer;
} ikbd;
// read a 16 bit word in big endian
unsigned short be16(unsigned short in) {
return ((in & 0xff)<<8) + ((in & 0xff00)>>8);
}
static void enqueue(unsigned short b) {
if(((wptr + 1)&(QUEUE_LEN-1)) == rptr)
return;
tx_queue[wptr] = b;
wptr = (wptr+1)&(QUEUE_LEN-1);
}
// convert internal joystick format into atari ikbd format
static unsigned char joystick_map2ikbd(unsigned char in) {
unsigned char out = 0;
if(in & JOY_UP) out |= 0x01;
if(in & JOY_DOWN) out |= 0x02;
if(in & JOY_LEFT) out |= 0x04;
if(in & JOY_RIGHT) out |= 0x08;
if(in & JOY_BTN1) out |= 0x80;
return out;
}
void ikbd_handler_mouse_button_action(void) {
unsigned char action = ikbd.buffer.command.mouse_button_action;
ikbd_debugf("mouse button action = %d", action);
// bit 2: Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
if(action & 0x04) ikbd.state |= IKBD_STATE_MOUSE_BUTTON_AS_KEY;
else ikbd.state &= ~IKBD_STATE_MOUSE_BUTTON_AS_KEY;
}
void ikbd_handler_set_relative_mouse_pos(void) {
ikbd_debugf("Set relative mouse positioning");
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
ikbd.state &= ~IKBD_STATE_MOUSE_KEYCODE;
ikbd.state &= ~IKBD_STATE_MOUSE_ABSOLUTE;
ikbd.state &= ~IKBD_STATE_PAUSED;
}
void ikbd_handler_set_abs_mouse_pos(void) {
ikbd.mouse.abs.max.x = be16(ikbd.buffer.command.abs_mouse_pos.max_x);
ikbd.mouse.abs.max.y = be16(ikbd.buffer.command.abs_mouse_pos.max_y);
ikbd_debugf("Set absolute mouse positioning, max = %u/%u",
ikbd.mouse.abs.max.x, ikbd.mouse.abs.max.y);
ikbd.state &= ~IKBD_STATE_MOUSE_DISABLED;
ikbd.state &= ~IKBD_STATE_MOUSE_KEYCODE;
ikbd.state |= IKBD_STATE_MOUSE_ABSOLUTE;
ikbd.mouse.abs.buttons = 2 | 8;
}
void ikbd_handler_set_mouse_keycode_mode(void) {
ikbd_debugf("Set mouse keycode mode dist %u/%u",
ikbd.buffer.command.mouse_keycode.dist_x,
ikbd.buffer.command.mouse_keycode.dist_y);
ikbd.state |= IKBD_STATE_MOUSE_KEYCODE;
}
void ikbd_handler_set_mouse_threshold(void) {
ikbd_debugf("Set mouse threshold %u/%u",
ikbd.buffer.command.mouse_threshold.x,
ikbd.buffer.command.mouse_threshold.y);
}
void ikbd_handler_set_mouse_scale(void) {
ikbd_debugf("Set mouse scale %u/%u",
ikbd.buffer.command.mouse_scale.x,
ikbd.buffer.command.mouse_scale.y);
ikbd.mouse.abs.scale.x = ikbd.buffer.command.mouse_scale.x;
ikbd.mouse.abs.scale.y = ikbd.buffer.command.mouse_scale.y;
}
void ikbd_handler_interrogate_mouse_pos(void) {
// ikbd_debugf("Interrogate Mouse Position");
if(ikbd.state & IKBD_STATE_MOUSE_ABSOLUTE) {
enqueue(0x8000 + 3); // 3ms delay, hatari uses 18000 cycles (~2.25ms)
enqueue(0xf7);
enqueue(ikbd.mouse.abs.buttons);
enqueue(ikbd.mouse.abs.pos.x >> 8);
enqueue(ikbd.mouse.abs.pos.x & 0xff);
enqueue(ikbd.mouse.abs.pos.y >> 8);
enqueue(ikbd.mouse.abs.pos.y & 0xff);
ikbd.mouse.abs.buttons = 0;
}
}
void ikbd_handler_load_mouse_pos(void) {
ikbd.mouse.abs.pos.x = be16(ikbd.buffer.command.load_mouse_pos.x);
ikbd.mouse.abs.pos.y = be16(ikbd.buffer.command.load_mouse_pos.y);
ikbd_debugf("Load mouse position %u/%u", ikbd.mouse.abs.pos.x, ikbd.mouse.abs.pos.y);
}
void ikbd_handler_set_y_bottom(void) {
ikbd_debugf("Set Y at bottom");
ikbd.state |= IKBD_STATE_MOUSE_Y_BOTTOM;
}
void ikbd_handler_set_y_top(void) {
ikbd_debugf("Set Y at top");
ikbd.state &= ~IKBD_STATE_MOUSE_Y_BOTTOM;
}
void ikbd_handler_resume(void) {
ikbd.state &= ~IKBD_STATE_PAUSED;
}
void ikbd_handler_disable_mouse(void) {
ikbd_debugf("Disable mouse");
ikbd.state |= IKBD_STATE_MOUSE_DISABLED;
}
void ikbd_handler_pause(void) {
ikbd_debugf("Pause");
ikbd.state |= IKBD_STATE_PAUSED;
}
void ikbd_handler_set_joystick_event_reporting(void) {
ikbd_debugf("Set Joystick event reporting");
ikbd.state |= IKBD_STATE_JOYSTICK_EVENT_REPORTING;
ikbd.state &= ~IKBD_STATE_PAUSED;
}
void ikbd_handler_set_joystick_interrogation_mode(void) {
ikbd_debugf("Set Joystick interrogation mode");
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
ikbd.state &= ~IKBD_STATE_PAUSED;
}
void ikbd_handler_interrogate_joystick(void) {
// send reply
enqueue(0xfd);
enqueue(ikbd.joy[0].state | ((ikbd.mouse.but & (1<<0))?0x80:0x00));
enqueue(ikbd.joy[1].state | ((ikbd.mouse.but & (1<<1))?0x80:0x00));
}
void ikbd_handler_disable_joysticks(void) {
ikbd_debugf("Disable joysticks");
ikbd.state &= ~IKBD_STATE_JOYSTICK_EVENT_REPORTING;
}
void ikbd_handler_time_set(void) {
unsigned char c;
for(c=0;c<6;c++)
ikbd.date[c] = bcd2bin(ikbd.buffer.command.date[c]);
// release SPI since it will be used by usb when
// reading the time from the rtc
DisableIO();
// try to set time on rtc if present
SetRTC(ikbd.date);
spi_uio_cmd_cont(UIO_IKBD_IN);
ikbd_debugf("Time of day clock set: %u:%02u:%02u %u.%u.%u",
ikbd.date[3], ikbd.date[4], ikbd.date[5],
ikbd.date[2], ikbd.date[1], 1900 + ikbd.date[0]);
}
void ikbd_handler_interrogate_time(void) {
unsigned char i;
// release SPI since it will be used by usb when
// reading the time from the rtc
DisableIO();
// try to fetch time from rtc if present
GetRTC(ikbd.date);
spi_uio_cmd_cont(UIO_IKBD_IN);
ikbd_debugf("Interrogate time of day %u:%02u:%02u %u.%u.%u",
ikbd.date[3], ikbd.date[4], ikbd.date[5],
ikbd.date[2], ikbd.date[1], 1900 + ikbd.date[0]);
enqueue(0x8000 + 64); // wait 64ms
enqueue(0xfc);
for(i=0;i<6;i++) enqueue(bin2bcd(ikbd.date[i]));
}
void ikbd_handler_reset(void) {
ikbd_debugf("Reset %x", ikbd.buffer.command.reset);
if(ikbd.buffer.command.reset == 1) {
ikbd.state = IKBD_DEFAULT;
enqueue(0x8000 + 300); // wait 300ms
enqueue(0xf0);
}
}
// ---- list of supported ikbd commands ----
struct {
unsigned char code;
unsigned char length;
void (*handler)(void);
} ikbd_command_handler[] = {
{ 0x07, 2, ikbd_handler_mouse_button_action },
{ 0x08, 1, ikbd_handler_set_relative_mouse_pos },
{ 0x09, 5, ikbd_handler_set_abs_mouse_pos },
{ 0x0a, 3, ikbd_handler_set_mouse_keycode_mode },
{ 0x0b, 3, ikbd_handler_set_mouse_threshold },
{ 0x0c, 3, ikbd_handler_set_mouse_scale },
{ 0x0d, 1, ikbd_handler_interrogate_mouse_pos },
{ 0x0e, 6, ikbd_handler_load_mouse_pos },
{ 0x0f, 1, ikbd_handler_set_y_bottom },
{ 0x10, 1, ikbd_handler_set_y_top },
{ 0x11, 1, ikbd_handler_resume },
{ 0x12, 1, ikbd_handler_disable_mouse },
{ 0x13, 1, ikbd_handler_pause },
{ 0x14, 1, ikbd_handler_set_joystick_event_reporting },
{ 0x15, 1, ikbd_handler_set_joystick_interrogation_mode },
{ 0x16, 1, ikbd_handler_interrogate_joystick },
{ 0x1a, 1, ikbd_handler_disable_joysticks },
{ 0x1c, 1, ikbd_handler_interrogate_time },
{ 0x1b, 7, ikbd_handler_time_set },
{ 0x80, 2, ikbd_handler_reset },
{ 0, 0, NULL } // end of list
};
void ikbd_init() {
// reset ikbd state
memset(&ikbd, 0, sizeof(ikbd));
ikbd.state = IKBD_DEFAULT | IKBD_STATE_WAIT4RESET;
ikbd.mouse.abs.max.x = ikbd.mouse.abs.max.y = 65535;
ikbd.mouse.abs.scale.x = ikbd.mouse.abs.scale.y = 1;
ikbd_debugf("Init");
// init ikbd date to some default
ikbd.date[0] = 113;
ikbd.date[1] = 7;
ikbd.date[2] = 20;
ikbd.date[3] = 20;
ikbd.date[4] = 58;
// handle auto events
ikbd.auto_timer = GetTimer(0);
}
void ikbd_reset(void) {
ikbd.tx_cnt = 0;
ikbd.state |= IKBD_STATE_WAIT4RESET;
}
// process inout from atari core into ikbd
void ikbd_handle_input(unsigned char cmd) {
// store byte in buffer
ikbd.buffer.byte[ikbd.buffer.size++] = cmd;
// check if there's a known command in the buffer
char c;
for(c=0;ikbd_command_handler[c].length &&
(ikbd_command_handler[c].code != ikbd.buffer.command.code);c++);
// not a valid command? -> flush buffer
if(!ikbd_command_handler[c].length) {
ikbd_debugf("Unhandled command: %02x", ikbd.buffer.command.code);
ikbd.buffer.size = 0;
} else {
// valid command and enough bytes?
if(ikbd_command_handler[c].length == ikbd.buffer.size) {
ikbd_command_handler[c].handler();
ikbd.buffer.size = 0;
}
}
}
void ikbd_poll(void) {
#ifdef IKBD_DEBUG
static unsigned long xtimer = 0;
static int last_cnt = 0;
if(CheckTimer(xtimer)) {
xtimer = GetTimer(2000);
if(ikbd.tx_cnt != last_cnt) {
ikbd_debugf("sent bytes: %d", ikbd.tx_cnt);
last_cnt = ikbd.tx_cnt;
}
}
#endif
// do auto events every 20ms
if(CheckTimer(ikbd.auto_timer)) {
ikbd.auto_timer = GetTimer(IKBD_AUTO_MS);
if(!(ikbd.state & IKBD_STATE_WAIT4RESET) &&
!(ikbd.state & IKBD_STATE_PAUSED)) {
/* --------- joystick ---------- */
if(ikbd.state & IKBD_STATE_JOYSTICK_EVENT_REPORTING) {
char i;
for(i=0;i<2;i++) {
unsigned char state = ikbd.joy[i].state;
// left mouse button 1 is also joystick 0 fire button
// right mouse button 0 is also joystick 1 fire button
if(ikbd.mouse.but & (2>>i)) state |= 0x80;
if(state != ikbd.joy[i].prev) {
// iprintf("JOY%d: %x\n", i, state);
enqueue(0xfe + i);
enqueue(state);
ikbd.joy[i].prev = state;
}
}
}
/* ----------- keyboard emu mouse ---------- */
if( !(ikbd.state & IKBD_STATE_MOUSE_DISABLED) &&
(ikbd.state & IKBD_STATE_MOUSE_KEYCODE)) {
if (ikbd.mouse.x < -ikbd.buffer.command.mouse_keycode.dist_x) {
ikbd_keyboard(0x4b);
ikbd_keyboard(0x4b);
ikbd_keyboard(0x4b);
// ikbd_keyboard(0x4b); ikbd_keyboard(0x4b | 0x80); // Left
ikbd.mouse.x = 0;
}
if (ikbd.mouse.x > ikbd.buffer.command.mouse_keycode.dist_x) {
ikbd_keyboard(0x4d);
ikbd_keyboard(0x4d);
ikbd_keyboard(0x4d);
// ikbd_keyboard(0x4d); ikbd_keyboard(0x4d | 0x80);// Right
ikbd.mouse.x = 0;
}
if (ikbd.mouse.y < -ikbd.buffer.command.mouse_keycode.dist_y) {
ikbd_keyboard(0x48);
ikbd_keyboard(0x48);
ikbd_keyboard(0x48);
// ikbd_keyboard(0x48); ikbd_keyboard(0x48 | 0x80); // Up
ikbd.mouse.y = 0;
}
if (ikbd.mouse.y > ikbd.buffer.command.mouse_keycode.dist_y) {
ikbd_keyboard(0x50); // Down
ikbd_keyboard(0x50); // Down
ikbd_keyboard(0x50); // Down
// ikbd_keyboard(0x50); ikbd_keyboard(0x50 | 0x80); // Down
ikbd.mouse.y = 0;
}
unsigned char b = ikbd.mouse.but;
if(b != ikbd.mouse.but_prev) {
// handle left mouse button
if((b ^ ikbd.mouse.but_prev) & 2) ikbd_keyboard(0x74 | ((b&2)?0x00:0x80));
// handle right mouse button
if((b ^ ikbd.mouse.but_prev) & 1) ikbd_keyboard(0x75 | ((b&1)?0x00:0x80));
}
ikbd.mouse.but_prev = b;
}
/* ----------- relative mouse ---------- */
if( !(ikbd.state & IKBD_STATE_MOUSE_DISABLED) &&
!(ikbd.state & IKBD_STATE_MOUSE_ABSOLUTE) &&
!(ikbd.state & IKBD_STATE_MOUSE_KEYCODE)) {
unsigned char b = ikbd.mouse.but;
// include joystick buttons into mouse state
if(ikbd.joy[0].state & 0x80) b |= 2;
if(ikbd.joy[1].state & 0x80) b |= 1;
if(ikbd.mouse.x || ikbd.mouse.y || (b != ikbd.mouse.but_prev)) {
do {
char x, y;
if(ikbd.mouse.x < -128) x = -128;
else if(ikbd.mouse.x > 127) x = 127;
else x = ikbd.mouse.x;
if(ikbd.mouse.y < -128) y = -128;
else if(ikbd.mouse.y > 127) y = 127;
else y = ikbd.mouse.y;
// iprintf("RMOUSE: %x %x %x\n", b, x&0xff, y&0xff);
enqueue(0xf8|b);
enqueue(x & 0xff);
enqueue(y & 0xff);
ikbd.mouse.x -= x;
ikbd.mouse.y -= y;
} while(ikbd.mouse.x || ikbd.mouse.y);
// check if mouse buttons are supposed to be treated like keys
if(ikbd.state & IKBD_STATE_MOUSE_BUTTON_AS_KEY) {
// check if mouse button state has changed
if(b != ikbd.mouse.but_prev) {
// Mouse buttons act like keys (LEFT=0x74 & RIGHT=0x75)
// handle left mouse button
if((b ^ ikbd.mouse.but_prev) & 2) ikbd_keyboard(0x74 | ((b&2)?0x00:0x80));
// handle right mouse button
if((b ^ ikbd.mouse.but_prev) & 1) ikbd_keyboard(0x75 | ((b&1)?0x00:0x80));
}
}
ikbd.mouse.but_prev = b;
}
}
}
}
static unsigned long mtimer = 0;
if(CheckTimer(mtimer)) {
mtimer = GetTimer(10);
// check for incoming ikbd data
spi_uio_cmd_cont(UIO_IKBD_IN);
while(spi_in())
ikbd_handle_input(spi_in());
DisableIO();
}
// everything below must not happen faster than 1kHz
static unsigned long rtimer = 0;
if(!CheckTimer(rtimer))
return;
// next event 1 ms later
rtimer = GetTimer(1);
// timer active?
if(ikbd_timer) {
if(!CheckTimer(ikbd_timer))
return;
ikbd_timer = 0;
}
if(rptr == wptr) return;
if(tx_queue[rptr] & 0x8000) {
// request to start timer?
if(tx_queue[rptr] & 0x8000)
ikbd_timer = GetTimer(tx_queue[rptr] & 0x3fff);
rptr = (rptr+1)&(QUEUE_LEN-1);
return;
}
// transmit data from queue
spi_uio_cmd_cont(UIO_IKBD_OUT);
spi8(tx_queue[rptr]);
DisableIO();
ikbd.tx_cnt++;
rptr = (rptr+1)&(QUEUE_LEN-1);
}
// called from external parts to report joystick states
void ikbd_joystick(unsigned char joystick, unsigned char map) {
ikbd.joy[joystick].state = joystick_map2ikbd(map);
}
void ikbd_keyboard(unsigned char code) {
#ifdef IKBD_DEBUG
ikbd_debugf("send keycode %x%s", code&0x7f, (code&0x80)?" BREAK":"");
#endif
enqueue(code);
}
void ikbd_mouse(unsigned char b, char x, char y) {
// honour reversal of y axis
if(ikbd.state & IKBD_STATE_MOUSE_Y_BOTTOM)
y = -y;
// update relative mouse state
ikbd.mouse.but = ((b&1)?2:0)|((b&2)?1:0);
ikbd.mouse.x += x;
ikbd.mouse.y += y;
// save button state for absolute mouse reports
if((ikbd.state & IKBD_STATE_MOUSE_ABSOLUTE) &&
!(ikbd.state & IKBD_STATE_MOUSE_KEYCODE)) {
// include joystick buttons into mouse state
if(ikbd.joy[0].state & 0x80) b |= 2;
if(ikbd.joy[1].state & 0x80) b |= 1;
if(b & 2) ikbd.mouse.abs.buttons |= 1;
else ikbd.mouse.abs.buttons |= 2;
if(b & 1) ikbd.mouse.abs.buttons |= 4;
else ikbd.mouse.abs.buttons |= 8;
if(ikbd.mouse.abs.scale.x > 1) x *= ikbd.mouse.abs.scale.x;
if(ikbd.mouse.abs.scale.y > 1) y *= ikbd.mouse.abs.scale.y;
// ikbd_debugf("abs inc %d %d -> ", x, y);
if(x < 0) {
x = -x;
if(ikbd.mouse.abs.pos.x > x) ikbd.mouse.abs.pos.x -= x;
else ikbd.mouse.abs.pos.x = 0;
} else if(x > 0) {
if(ikbd.mouse.abs.pos.x < ikbd.mouse.abs.max.x - x)
ikbd.mouse.abs.pos.x += x;
else
ikbd.mouse.abs.pos.x = ikbd.mouse.abs.max.x;
}
if(y < 0) {
y = -y;
if(ikbd.mouse.abs.pos.y > y) ikbd.mouse.abs.pos.y -= y;
else ikbd.mouse.abs.pos.y = 0;
} else if(y > 0) {
if(ikbd.mouse.abs.pos.y < ikbd.mouse.abs.max.y - y)
ikbd.mouse.abs.pos.y += y;
else
ikbd.mouse.abs.pos.y = ikbd.mouse.abs.max.y;
}
}
}
// advance the ikbd time by one second
void ikbd_update_time(void) {
static const char mdays[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
short year = 1900 + ikbd.date[0];
char is_leap = (!(year % 4) && (year % 100)) || !(year % 400);
// advance seconds
ikbd.date[5]++;
if(ikbd.date[5] == 60) {
ikbd.date[5] = 0;
// advance minutes
ikbd.date[4]++;
if(ikbd.date[4] == 60) {
ikbd.date[4] = 0;
// advance hours
ikbd.date[3]++;
if(ikbd.date[3] == 24) {
ikbd.date[3] = 0;
// advance days
ikbd.date[2]++;
if((ikbd.date[2] == mdays[ikbd.date[1]-1]+1) ||
(is_leap && (ikbd.date[1] == 2) && (ikbd.date[2] == 29))) {
ikbd.date[2] = 1;
// advance month
ikbd.date[1]++;
if(ikbd.date[1] == 13) {
ikbd.date[1] = 0;
// advance year
ikbd.date[0]++;
}
}
}
}
}
}
View Git Blame Copy Permalink