Fcalva/gint
1
0
Fork 0
mirror of https://git.planet-casio.com/Lephenixnoir/gint.git synced 2025-04-04 09:37:10 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request 'dev' (#2) from Lephenixnoir/gint:dev into dev

Browse source 
Reviewed-on: https://git.planet-casio.com/Chen-Zhanming/gint/pulls/2
This commit is contained in:
Chen-Zhanming 2025-03-24 12:18:20 +01:00
commit 4cc3e9ddf2
43 changed files with 1836 additions and 173 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
CMakeLists.txt
View file

@ -253,6 +253,12 @@ set(SOURCES
src/usb/write4.S src/usb/write4.S
# Video driver interface # Video driver interface
src/video/video.c src/video/video.c
# Touch-screen driver
src/touch/i2c.c
src/touch/i2c_inth.c
src/touch/adconv.c
src/touch/touch.c
src/touch/driver.c
) )
set(ASSETS_FX src/font5x7.png src/gdb/icons-i1msb.png) set(ASSETS_FX src/font5x7.png src/gdb/icons-i1msb.png)

4
fx9860g.ld.c
View file

@ -70,11 +70,11 @@ SECTIONS
_gint_exch_start = . ; _gint_exch_start = . ;
KEEP(*(.gint.exch)) KEEP(*(.gint.exch))
_gint_exch_size = ABSOLUTE(. - _gint_exch_start); _gint_exch_end = . ;
_gint_tlbh_start = . ; _gint_tlbh_start = . ;
KEEP(*(.gint.tlbh)) KEEP(*(.gint.tlbh))
_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start); _gint_tlbh_end = . ;
*(.text .text.*) *(.text .text.*)
*(C P) *(C P)

4
fxcg50.ld.c
View file

@ -59,11 +59,11 @@ SECTIONS
_gint_exch_start = . ; _gint_exch_start = . ;
KEEP(*(.gint.exch)) KEEP(*(.gint.exch))
_gint_exch_size = ABSOLUTE(. - _gint_exch_start); _gint_exch_end = . ;
_gint_tlbh_start = . ; _gint_tlbh_start = . ;
KEEP(*(.gint.tlbh)) KEEP(*(.gint.tlbh))
_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start); _gint_tlbh_end = . ;
*(.text .text.*) *(.text .text.*)
} > rom } > rom

4
fxcp_hh2.ld.c
View file

@ -68,12 +68,12 @@ SECTIONS
. = ALIGN(0x10); . = ALIGN(0x10);
_gint_exch_start = . ; _gint_exch_start = . ;
*(.gint.exch) *(.gint.exch)
_gint_exch_size = ABSOLUTE(. - _gint_exch_start); _gint_exch_end = . ;
. = ALIGN(0x10); . = ALIGN(0x10);
_gint_tlbh_start = . ; _gint_tlbh_start = . ;
*(.gint.tlbh) *(.gint.tlbh)
_gint_tlbh_size = ABSOLUTE(. - _gint_tlbh_start); _gint_tlbh_end = . ;
*(.text .text.*) *(.text .text.*)
} > ram AT> bin } > ram AT> bin

7
include/gint/clock.h
View file

@ -35,6 +35,7 @@ typedef struct
int Bphi_div; int Bphi_div;
int Iphi_div; int Iphi_div;
int Pphi_div; int Pphi_div;
int Sphi_div;
union { union {
int CKIO_f; int CKIO_f;
@ -44,6 +45,7 @@ typedef struct
int Bphi_f; int Bphi_f;
int Iphi_f; int Iphi_f;
int Pphi_f; int Pphi_f;
int Sphi_f;
} clock_frequency_t; } clock_frequency_t;
@ -155,6 +157,11 @@ void cpg_get_overclock_setting(struct cpg_overclock_setting *s);
/* Applies the specified overclock setting. */ /* Applies the specified overclock setting. */
void cpg_set_overclock_setting(struct cpg_overclock_setting const *s); void cpg_set_overclock_setting(struct cpg_overclock_setting const *s);
/* Sets whether or node CPG parameters are retained when world switching, i.e.
mostly whether overclock setting will remain while in the OS world and when
leaving the add-in. */
void cpg_set_overclock_permanent(bool permanent);
//--- //---
// Sleep functions // Sleep functions
//--- //---

1
include/gint/defs/call.h
View file

@ -12,6 +12,7 @@
#define GINT_DEFS_CALL #define GINT_DEFS_CALL
#include <stdbool.h> #include <stdbool.h>
#include <gint/defs/attributes.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

2
include/gint/drivers/keydev.h
View file

@ -184,6 +184,8 @@ typedef struct {
/* Candidate key for repeats (or 0 if no key is candidate yet) */ /* Candidate key for repeats (or 0 if no key is candidate yet) */
int16_t rep_key; int16_t rep_key;
/* Matrix code for rep_key, if rep_key is not 0. */
uint8_t rep_row, rep_col;
/* Number of repeats already sent */ /* Number of repeats already sent */
int16_t rep_count; int16_t rep_count;
/* Time since key was first pressed (us) */ /* Time since key was first pressed (us) */

4
include/gint/drivers/r61523.h
View file

@ -16,6 +16,10 @@ extern "C" {
/* r61523_display(): Update the entire display (320x528) */ /* r61523_display(): Update the entire display (320x528) */
void r61523_display(uint16_t *vram); void r61523_display(uint16_t *vram);
/* r61523_display_rect(): Update a rectangle (both bounds included). */
void r61523_display_rect(
uint16_t *vram, int xmin, int xmax, int ymin, int ymax);
/* r61523_win_set(): Set the display window */ /* r61523_win_set(): Set the display window */
void r61523_win_set(int x1, int x2, int y1, int y2); void r61523_win_set(int x1, int x2, int y1, int y2);

10
include/gint/drivers/states.h
View file

@ -109,6 +109,16 @@ typedef struct {
} usb_state_t; } usb_state_t;
/* Touch-screen modules */
typedef struct {
uint16_t PRCR;
uint16_t PJCR;
uint8_t ICCR;
uint8_t ICIC;
uint8_t ICCL;
uint8_t ICCH;
} touch_state_t;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

1
include/gint/gdb.h
View file

@ -10,6 +10,7 @@ extern "C" {
#endif #endif
#include <stdint.h> #include <stdint.h>
#include <stdbool.h>
/* gdb_cpu_state_t: State of the CPU when breaking /* gdb_cpu_state_t: State of the CPU when breaking
This struct keep the same register indices as those declared by GDB to allow This struct keep the same register indices as those declared by GDB to allow

2
include/gint/hardware.h
View file

@ -111,6 +111,8 @@ void hw_detect(void);
#define HWCALC_FX9860G_SLIM 7 #define HWCALC_FX9860G_SLIM 7
/* fx-CP 400 */ /* fx-CP 400 */
#define HWCALC_FXCP400 8 #define HWCALC_FXCP400 8
/* fx-CG 100, successor to the CG-50 in the Prizm family. Also Graph Math+ */
#define HWCALC_FXCG100 9
/* /*
** Keyboard ** Keyboard

5
include/gint/intc.h
View file

@ -52,6 +52,11 @@ enum {
INTC_SPU_DSP1, INTC_SPU_DSP1,
/* USB communication */ /* USB communication */
INTC_USB, INTC_USB,
/* I2C */
INTC_I2C_AL,
INTC_I2C_TACK,
INTC_I2C_WAIT,
INTC_I2C_DTE,
}; };
//--- //---

37
include/gint/keyboard.h
View file

@ -114,27 +114,46 @@ extern "C" {
* 0xffff is "just before" 0x0000, not "long after". */ * 0xffff is "just before" 0x0000, not "long after". */
typedef struct typedef struct
{ {
uint time :16; /* Time of event, unique over short periods */ /* Time of event, unique over short periods */
u16 time;
uint :2; /* Reserved for future use */ uint :2; /* Reserved for future use */
uint mod :1; /* Whether modifiers are used */ uint mod :1; /* Whether modifiers are used */
uint shift :1; /* If mod=1, whether SHIFT was pressed */ uint shift :1; /* If mod=1, whether SHIFT was pressed */
uint alpha :1; /* If mod=1, whether ALPHA was pressed */ uint alpha :1; /* If mod=1, whether ALPHA was pressed */
uint type :3; /* Type of key event */ uint type :3; /* Type of key event */
uint key :8; /* Hit key */
/* Key that was pressed or released. */
u8 key;
// The following attributes will be union'd with touch info on the CP.
union {
struct {
/* Matrix code: physical location of the key being it. */
u8 row;
u8 col;
};
struct {
/* X/Y touch-screen coordinate */
u16 x;
u16 y;
};
};
} GPACKED(4) key_event_t; } GPACKED(4) key_event_t;
/* Keyboard event types, as in the [type] field of key_event_t */ /* Keyboard event types, as in the [type] field of key_event_t */
enum enum
{ {
KEYEV_NONE = 0, /* No event available (poll() only) */ KEYEV_NONE = 0, /* No event available (poll() only) */
KEYEV_DOWN = 1, /* Key was pressed */ KEYEV_DOWN = 1, /* Key was pressed */
KEYEV_UP = 2, /* Key was released */ KEYEV_UP = 2, /* Key was released */
KEYEV_HOLD = 3, /* A key that was pressed has been held down */ KEYEV_HOLD = 3, /* A key that was pressed has been held down */
KEYEV_OSMENU = 4, /* We went to the main menu and back */ KEYEV_OSMENU = 4, /* We went to the main menu and back */
KEYEV_TOUCH_PRESSED = 5, /* Touch was detected */
KEYEV_TOUCH_DRAG = 6, /* A touch that was detected has been held down */
KEYEV_TOUCH_RELEASE = 7, /* Touch was released */
}; };
/* Keyboard frequency analysis is a runtime setting since gint 2.4. This macro /* Keyboard frequency analysis is a runtime setting since gint 2.4. This macro

19
include/gint/keycodes.h
View file

@ -9,7 +9,6 @@
extern "C" { extern "C" {
#endif #endif
/* Raw matrix codes */
enum { enum {
KEY_F1 = 0x91, KEY_F1 = 0x91,
KEY_F2 = 0x92, KEY_F2 = 0x92,
@ -87,7 +86,23 @@ enum {
KEY_EQUALS = 0xa5, KEY_EQUALS = 0xa5,
KEY_CLEAR = KEY_EXIT, KEY_CLEAR = KEY_EXIT,
/* Key aliases (handle with care =D) */ /* Key codes for the CG-100 */
KEY_ON = 0xa6,
KEY_HOME = KEY_MENU,
KEY_PREVTAB = 0xa7,
KEY_NEXTTAB = 0xa8,
KEY_PAGEUP = 0xa9,
KEY_PAGEDOWN = 0xaa,
KEY_SETTINGS = 0xab,
KEY_BACK = KEY_EXIT,
KEY_OK = 0xac,
KEY_CATALOG = 0xad,
KEY_TOOLS = KEY_OPTN,
KEY_FORMAT = KEY_FD,
KEY_SQRT = 0xae,
KEY_EXPFUN = 0xaf,
/* Key aliases (deprecated--no more will be added) */
KEY_X2 = KEY_SQUARE, KEY_X2 = KEY_SQUARE,
KEY_CARET = KEY_POWER, KEY_CARET = KEY_POWER,
KEY_SWITCH = KEY_FD, KEY_SWITCH = KEY_FD,

74
include/gint/mpu/i2c.h Normal file
View file

@ -0,0 +1,74 @@
#ifndef GINT_MPU_I2C_H
#define GINT_MPU_I2C_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/defs/attributes.h>
#include <gint/defs/types.h>
//---
// SH7305 I2C Bus Interface. Refer to:
// "Renesas SH7724 User's Manual: Hardware"
// Section 32: "I2C Bus Interface (I2C)"
//---
/* sh7305_i2c_t - I2C peripheral definition */
typedef struct {
// read/write register
uint8_t ICDR;
pad(3);
// control register
byte_union(ICCR,
uint8_t ICE :1;
uint8_t RACK :1;
uint8_t :1;
uint8_t TRS :1;
uint8_t :1;
uint8_t BBSY :1;
uint8_t :1;
uint8_t SCP :1;
);
pad(3);
// status register
byte_union(ICSR,
uint8_t SCLM :1;
uint8_t SDAM :1;
uint8_t :1;
uint8_t BUSY :1;
uint8_t AL :1;
uint8_t TACK :1;
uint8_t WAIT :1;
uint8_t DTE :1;
);
pad(3);
// interrupt control register
byte_union(ICIC,
uint8_t :1;
uint8_t :1;
uint8_t :1;
uint8_t :1;
uint8_t ALE :1;
uint8_t TACKE :1;
uint8_t WAITE :1;
uint8_t DTEE :1;
);
pad(3);
// clock control registers
uint8_t ICCL;
pad(3);
uint8_t ICCH;
} GPACKED(1) sh7305_i2c_t;
#define SH7305_I2C (*((volatile sh7305_i2c_t *)0xa4470000))
#ifdef __cplusplus
}
#endif
#endif /* GINT_MPU_I2C_H */

2
include/gint/mpu/intc.h
View file

@ -192,7 +192,7 @@ typedef volatile struct
uint16_t _MSIOF0:4; /* SH7724: Sync SCIF channel 0 */ uint16_t _MSIOF0:4; /* SH7724: Sync SCIF channel 0 */
uint16_t _MSIOF1:4; /* SH7724: Sync SCIF channel 1 */ uint16_t _MSIOF1:4; /* SH7724: Sync SCIF channel 1 */
uint16_t _1 :4; /* Unknown (TODO) */ uint16_t _1 :4; /* Unknown (TODO) */
uint16_t _2 :4; /* Unknown (TODO) */ uint16_t I2C:4; /* I2C */
); );
pad(2); pad(2);

34
include/gint/mpu/keysc.h Normal file
View file

@ -0,0 +1,34 @@
//---
// gint:mpu:keysc - Key Scan Controller
//---
#ifndef GINT_MPU_KEYSC
#define GINT_MPU_KEYSC
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/defs/attributes.h>
#include <gint/defs/types.h>
typedef volatile struct {
uint16_t KIUDATA[6];
uint16_t KIUCNTREG;
uint16_t KIAUTOFIXREG;
uint16_t KIUMODEREG;
uint16_t KIUSTATEREG;
uint16_t KIUINTREG;
uint16_t KIUWSETREG;
uint16_t KIUINTERVALREG;
uint16_t KOUTPINSET;
uint16_t KINPINSET;
} GPACKED(4) sh7305_keysc_t;
#define SH7305_KEYSC (*(sh7305_keysc_t *)0xa44b0000)
#ifdef __cplusplus
}
#endif
#endif /* GINT_MPU_KEYSC */

45
include/gint/touch.h Normal file
View file

@ -0,0 +1,45 @@
//---
// gint:touch - touch-screen driver API
//---
#ifndef GINT_TOUCH_H
#define GINT_TOUCH_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/config.h>
#if GINT_HW_CP
/* touch_calib - tounch-screen calibration information */
typedef struct {
int x_base;
int x_div;
int y_base;
int y_div;
int dual_debounce_frame;
int dual_sensi_entry;
int dual_sensi_leave;
} touch_calibration_t;
/* touch_calib_get() - get calibration information */
extern int touch_calib_get(touch_calibration_t *calib);
/* touch_calib_set() - set calibration information */
extern int touch_calib_set(touch_calibration_t *calib);
// low-level API
#include <gint/keyboard.h>
/* touch_next_event() - get the next touchscreen event */
extern key_event_t touch_next_event(void);
#endif /* GINT_HW_CP */
#ifdef __cplusplus
}
#endif
#endif /* GINT_TOUCH_H */

3
src/cpg/cpg.c
View file

@ -84,10 +84,12 @@ static void sh7305_probe(void)
int divb = CPG.FRQCR.BFC; int divb = CPG.FRQCR.BFC;
int divi = CPG.FRQCR.IFC; int divi = CPG.FRQCR.IFC;
int divp = CPG.FRQCR.P1FC; int divp = CPG.FRQCR.P1FC;
int divs = CPG.FRQCR.SFC;
freq.Bphi_div = 1 << (divb + 1); freq.Bphi_div = 1 << (divb + 1);
freq.Iphi_div = 1 << (divi + 1); freq.Iphi_div = 1 << (divi + 1);
freq.Pphi_div = 1 << (divp + 1); freq.Pphi_div = 1 << (divp + 1);
freq.Sphi_div = 1 << (divs + 1);
/* Deduce the input frequency of divider 1 */ /* Deduce the input frequency of divider 1 */
int base = 32768; int base = 32768;
@ -99,6 +101,7 @@ static void sh7305_probe(void)
freq.Bphi_f = base >> (divb + 1); freq.Bphi_f = base >> (divb + 1);
freq.Iphi_f = base >> (divi + 1); freq.Iphi_f = base >> (divi + 1);
freq.Pphi_f = base >> (divp + 1); freq.Pphi_f = base >> (divp + 1);
freq.Sphi_f = base >> (divs + 1);
} }
#undef CPG #undef CPG

78
src/cpg/overclock.c
View file

@ -12,6 +12,7 @@
#include <gint/clock.h> #include <gint/clock.h>
#include <gint/gint.h> #include <gint/gint.h>
#include <gint/hardware.h> #include <gint/hardware.h>
#include <gint/drivers.h>
#include <gint/mpu/cpg.h> #include <gint/mpu/cpg.h>
#include <gint/mpu/bsc.h> #include <gint/mpu/bsc.h>
#include <gint/mpu/wdt.h> #include <gint/mpu/wdt.h>
@ -20,8 +21,8 @@
// Low-level clock speed access // Low-level clock speed access
//--- //---
#define SH7305_SDMR3_CL2 ((volatile uint8_t *)0xFEC15040) #define SH7305_SDMR3_CL2 ((volatile uint16_t *)0xFEC15040)
#define SH7305_SDMR3_CL3 ((volatile uint8_t *)0xFEC15060) #define SH7305_SDMR3_CL3 ((volatile uint16_t *)0xFEC15060)
//--- //---
// Predefined clock speeds // Predefined clock speeds
@ -142,6 +143,17 @@ void cpg_set_overclock_setting(struct cpg_overclock_setting const *s)
cpu_atomic_end(); cpu_atomic_end();
} }
void cpg_set_overclock_permanent(bool permanent)
{
extern gint_driver_t drv_cpg;
int i = &drv_cpg - gint_drivers;
if(permanent)
gint_driver_flags[i] |= GINT_DRV_SHARED;
else
gint_driver_flags[i] &= ~GINT_DRV_SHARED;
}
#if GINT_HW_FX #if GINT_HW_FX
static struct cpg_overclock_setting const settings_fx9860g_sh3[5] = { static struct cpg_overclock_setting const settings_fx9860g_sh3[5] = {
@ -433,6 +445,66 @@ static struct cpg_overclock_setting const settings_fxcg50[5] = {
.CS5aWCR = 0x000203C1 }, .CS5aWCR = 0x000203C1 },
}; };
// TODO: These structures are big and many settings overlap. Make it smaller.
// This is fxcg50[0,1,2,3,3].
static struct cpg_overclock_setting const settings_fxcg100[5] = {
/* CLOCK_SPEED_F1 */
{ .FLLFRQ = 0x00004000 + 900,
.FRQCR = 0x0F011112,
.CS0BCR = 0x36DA0400,
.CS2BCR = 0x36DA3400,
.CS3BCR = 0x36DB4400,
.CS5aBCR = 0x17DF0400,
.CS0WCR = 0x000003C0,
.CS2WCR = 0x000003C0,
.CS3WCR = 0x000024D1,
.CS5aWCR = 0x000203C1 },
/* CLOCK_SPEED_F2 */
{ .FLLFRQ = 0x00004000 + 900,
.FRQCR = (SH4_PLL_16x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_8,
.CS0BCR = 0x24920400,
.CS2BCR = 0x24923400,
.CS3BCR = 0x24924400,
.CS5aBCR = 0x17DF0400,
.CS0WCR = 0x00000340,
.CS2WCR = 0x000003C0,
.CS3WCR = 0x000024D1,
.CS5aWCR = 0x000203C1 },
/* CLOCK_SPEED_F3 */
{ .FLLFRQ = 0x00004000 + 900,
.FRQCR = (SH4_PLL_26x<<24)+(SH4_DIV_4<<20)+(SH4_DIV_8<<12)+(SH4_DIV_8<<8)+SH4_DIV_8,
.CS0BCR = 0x24920400,
.CS2BCR = 0x24923400,
.CS3BCR = 0x24924400,
.CS5aBCR = 0x17DF0400,
.CS0WCR = 0x00000240,
.CS2WCR = 0x000003C0,
.CS3WCR = 0x000024D1,
.CS5aWCR = 0x000203C1 },
/* CLOCK_SPEED_F4 */
{ .FLLFRQ = 0x00004000 + 900,
.FRQCR = (SH4_PLL_32x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
.CS0BCR = 0x24920400,
.CS2BCR = 0x24923400,
.CS3BCR = 0x24924400,
.CS5aBCR = 0x17DF0400,
.CS0WCR = 0x000002C0,
.CS2WCR = 0x000003C0,
.CS3WCR = 0x000024D1,
.CS5aWCR = 0x000203C1 },
/* CLOCK_SPEED_F5 is made identical to CLOCK_SPEED_F4 because clearly the
Graph Math+ cannot handle the higher bus speed. */
{ .FLLFRQ = 0x00004000 + 900,
.FRQCR = (SH4_PLL_32x<<24)+(SH4_DIV_2<<20)+(SH4_DIV_4<<12)+(SH4_DIV_8<<8)+SH4_DIV_16,
.CS0BCR = 0x24920400,
.CS2BCR = 0x24923400,
.CS3BCR = 0x24924400,
.CS5aBCR = 0x17DF0400,
.CS0WCR = 0x000002C0,
.CS2WCR = 0x000003C0,
.CS3WCR = 0x000024D1,
.CS5aWCR = 0x000203C1 },
};
#endif #endif
static struct cpg_overclock_setting const *get_settings(void) static struct cpg_overclock_setting const *get_settings(void)
@ -451,6 +523,8 @@ static struct cpg_overclock_setting const *get_settings(void)
return settings_prizm; return settings_prizm;
if(gint[HWCALC] == HWCALC_FXCG50) if(gint[HWCALC] == HWCALC_FXCG50)
return settings_fxcg50; return settings_fxcg50;
if(gint[HWCALC] == HWCALC_FXCG100)
return settings_fxcg100;
#endif #endif
return NULL; return NULL;

5
src/intc/intc.c
View file

@ -71,6 +71,11 @@ static struct info {
{ IPRC, 0x000f, IMR4, 0x08, _ }, { IPRC, 0x000f, IMR4, 0x08, _ },
/* USB */ /* USB */
{ IPRF, 0x00f0, IMR9, 0x02, _ /* Driver not SH3-compatible yet */ }, { IPRF, 0x00f0, IMR9, 0x02, _ /* Driver not SH3-compatible yet */ },
/* I2C */
{ IPRH, 0x000f, IMR7, 0x10, _ },
{ IPRH, 0x000f, IMR7, 0x20, _ },
{ IPRH, 0x000f, IMR7, 0x40, _ },
{ IPRH, 0x000f, IMR7, 0x80, _ },
}; };
/* Compact SH3 VBR-space scheme /* Compact SH3 VBR-space scheme

8
src/kernel/exch.c
View file

@ -80,6 +80,7 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
if(code == 0x1060) name = "Memory init failed"; if(code == 0x1060) name = "Memory init failed";
if(code == 0x1080) name = "Stack overflow"; if(code == 0x1080) name = "Stack overflow";
if(code == 0x10a0) name = "UBC in bank 1 code"; if(code == 0x10a0) name = "UBC in bank 1 code";
// if(code == 0x10c0) name = "Missing syscall"; // not on FX
if(name[0]) dtext(1, 9, name); if(name[0]) dtext(1, 9, name);
else dprint(1, 9, "%03x", code); else dprint(1, 9, "%03x", code);
@ -121,6 +122,8 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
if(code == 0x1060) name = "Memory initialization failed (heap)"; if(code == 0x1060) name = "Memory initialization failed (heap)";
if(code == 0x1080) name = "Stack overflow during world switch"; if(code == 0x1080) name = "Stack overflow during world switch";
if(code == 0x10a0) name = "UBC break in register bank 1 code"; if(code == 0x10a0) name = "UBC break in register bank 1 code";
if(code == 0x10c0) name = "Missing syscall for this OS version";
if(code == 0x10e0) name = "I2C (touch-screen) error";
dprint(6, 25, "%03x %s", code, name); dprint(6, 25, "%03x %s", code, name);
@ -171,6 +174,11 @@ GNORETURN static void gint_default_panic(GUNUSED uint32_t code)
dprint(6, 160, "Opcodes: %04x %04x [%04x] %04x", dprint(6, 160, "Opcodes: %04x %04x [%04x] %04x",
opcodes[-2], opcodes[-1], opcodes[0], opcodes[1]); opcodes[-2], opcodes[-1], opcodes[0], opcodes[1]);
} }
/* I2C exception error */
if (code == 0x10e0)
{
//todo
}
#endif #endif
_WEAK_dupdate(); _WEAK_dupdate();

29
src/kernel/hardware.c
View file

@ -11,6 +11,7 @@
#include <gint/config.h> #include <gint/config.h>
#include <string.h> #include <string.h>
#include "kernel.h"
/* Holds information about the current platform */ /* Holds information about the current platform */
GBSS uint32_t gint[HW_KEYS]; GBSS uint32_t gint[HW_KEYS];
@ -90,10 +91,10 @@ void hw_detect(void)
gint[HWFS] = HWFS_CASIOWIN; gint[HWFS] = HWFS_CASIOWIN;
} }
/* Detect RAM by checking if 8804'0000 is the same as 8800'0000. */ /* Detect RAM by checking if a804'0000 is the same as a800'0000. */
volatile uint8_t *R4 = (void *)0x88040000; volatile uint8_t *R4 = (void *)0xa8040000;
volatile uint8_t *R0 = (void *)0x88000000; volatile uint8_t *R0 = (void *)0xa8000000;
/* Make backups */ /* Make backups */
uint8_t b0 = *R0; uint8_t b0 = *R0;
@ -126,10 +127,28 @@ void hw_detect(void)
gint[HWCPUVR] = PVR; gint[HWCPUVR] = PVR;
gint[HWCPUPR] = PRR; gint[HWCPUPR] = PRR;
/* Tell Prizms apart from fx-CG 50 by checking the stack address*/
uint32_t stack; uint32_t stack;
__asm__("mov r15, %0" : "=r"(stack)); __asm__("mov r15, %0" : "=r"(stack));
gint[HWCALC] = (stack < 0x8c000000) ? HWCALC_PRIZM : HWCALC_FXCG50; char const *version = (void *)0x80020020;
char const *osdate = (void *)0x80b5ffe0;
/* Tell Prizms apart from fx-CG 50 by checking the stack address*/
if(stack < 0x8c000000) {
gint[HWCALC] = HWCALC_PRIZM;
}
/* Tell Math+/fx-CG 100 apart from CG-50 by checking OS version + date.
CG-50 OS versions use OS 3. Math+, for some reason, rewinds back to OS 1
and got updated to OS 2 in late 2024. We decide that we are on a CG-50 OS
if the version is 3 and the date is 201x-2024. */
else {
/* All known CG-50 versions have date at this address due to the footer
location. WARNING: not a future-proof address! */
char d0 = osdate[0], d1 = osdate[1], d2 = osdate[2], d3 = osdate[3];
bool cg50 = version[1] == '3' && d0 == '2' && d1 == '0' &&
(d2 == '1' || (d2 == '2' && d3 <= '4'));
gint[HWCALC] = cg50 ? HWCALC_FXCG50 : HWCALC_FXCG100;
}
gint[HWFS] = HWFS_FUGUE; gint[HWFS] = HWFS_FUGUE;
/* Tell the fx-CG emulator apart using the product ID */ /* Tell the fx-CG emulator apart using the product ID */

77
src/kernel/kernel.c
View file

@ -33,13 +33,29 @@ uint8_t *gint_driver_flags = NULL;
/* Top of the stack */ /* Top of the stack */
void *gint_stack_top = NULL; void *gint_stack_top = NULL;
u32 *gint_load_info = NULL;
//--- //---
// Initialization and unloading // Initialization and unloading
//--- //---
/* kinit(): Install and start gint */ /* kinit(): Install and start gint */
void kinit(void) void kinit(u32 *load_info)
{ {
gint_load_info = load_info;
/* Figure out which CASIOWIN API to use based on the OS type. */
#if GINT_OS_CG
char *version = (void *)0x80020020;
if(!memcmp(version, "01.00", 5))
gint_set_CASIOWIN_API(1);
else if(gint[HWCALC] == HWCALC_FXCG100 && !memcmp(version, "02.00", 5))
gint_set_CASIOWIN_API(2);
else
gint_set_CASIOWIN_API(0);
#endif
#if GINT_HW_FX #if GINT_HW_FX
/* On fx-9860G, VBR is loaded at the end of the user RAM. On SH4, the /* On fx-9860G, VBR is loaded at the end of the user RAM. On SH4, the
end of the user RAM hosts the stack, for which we leave 12 kB end of the user RAM hosts the stack, for which we leave 12 kB
@ -76,9 +92,15 @@ void kinit(void)
#endif #endif
/* Event handler entry points */ /* Event handler entry points */
extern uint32_t gint_exch_start;
extern uint32_t gint_exch_end;
extern uint32_t gint_tlbh_start;
extern uint32_t gint_tlbh_end;
void *inth_entry = isSH3() ? gint_inth_7705 : gint_inth_7305; void *inth_entry = isSH3() ? gint_inth_7705 : gint_inth_7305;
uint32_t exch_size = (uint32_t)&gint_exch_size; uint32_t exch_size = \
uint32_t tlbh_size = (uint32_t)&gint_tlbh_size; (uint32_t)&gint_exch_end - (uint32_t)&gint_exch_start;
uint32_t tlbh_size = \
(uint32_t)&gint_tlbh_end - (uint32_t)&gint_tlbh_start;
/* Load the event handler entry points into memory */ /* Load the event handler entry points into memory */
memcpy((void *)VBR + 0x100, gint_exch, exch_size); memcpy((void *)VBR + 0x100, gint_exch, exch_size);
@ -102,16 +124,45 @@ void kinit(void)
/* Create an arena in the OS stack as well, for VRAM and more data */ /* Create an arena in the OS stack as well, for VRAM and more data */
#if GINT_HW_CG && !defined(GINT_NO_OS_STACK) #if GINT_HW_CG && !defined(GINT_NO_OS_STACK)
static kmalloc_arena_t os_stack = { 0 }; if(gint[HWCALC] != HWCALC_FXCG100) {
os_stack.name = "_ostk"; static kmalloc_arena_t os_stack = { 0 };
os_stack.is_default = true; os_stack.name = "_ostk";
if(gint[HWCALC] == HWCALC_PRIZM || gint[HWCALC] == HWCALC_FXCG_MANAGER) os_stack.is_default = true;
os_stack.start = (void *)0x880f0000; if(gint[HWCALC] == HWCALC_PRIZM || gint[HWCALC] == HWCALC_FXCG_MANAGER)
else os_stack.start = (void *)0x880f0000;
os_stack.start = (void *)0x8c0f0000; else
os_stack.end = os_stack.start + (350 * 1024); os_stack.start = (void *)0x8c0f0000;
kmalloc_init_arena(&os_stack, true); os_stack.end = os_stack.start + (350 * 1024);
kmalloc_add_arena(&os_stack); kmalloc_init_arena(&os_stack, true);
kmalloc_add_arena(&os_stack);
}
#endif
/* Create arenas in locations provided by loader */
#if GINT_OS_CG
u32 load_arena_start = 0;
char const *names[4] = { "_ld1", "_ld2", "_ld3", "_ld4" };
int count = 0;
for(int i = 0; load_info && load_info[i] && count < 4; i += 2)
{
if(load_info[i] == 0x00000010)
load_arena_start = load_info[i+1];
else if(load_info[i] == 0x00000011 && load_arena_start)
{
u32 load_arena_end = load_info[i+1];
kmalloc_arena_t *arena = kmalloc(sizeof *arena, NULL);
if(arena)
{
arena->name = names[count];
arena->is_default = true;
arena->start = (void *)load_arena_start;
arena->end = (void *)load_arena_end;
kmalloc_init_arena(arena, true);
kmalloc_add_arena(arena);
}
load_arena_start = 0;
}
}
#endif #endif
/* Allocate world buffers for the OS and for gint */ /* Allocate world buffers for the OS and for gint */

7
src/kernel/kernel.h
View file

@ -5,6 +5,8 @@
#ifndef GINT_CORE_KERNEL #ifndef GINT_CORE_KERNEL
#define GINT_CORE_KERNEL #define GINT_CORE_KERNEL
#include <gint/defs/types.h>
/* gint_load_onchip_sections(): Initialize on-chip memory sections */ /* gint_load_onchip_sections(): Initialize on-chip memory sections */
void gint_load_onchip_sections(void); void gint_load_onchip_sections(void);
@ -13,9 +15,12 @@ void gint_load_onchip_sections(void);
void gint_copy_vram(void); void gint_copy_vram(void);
/* kinit(): Install and start gint */ /* kinit(): Install and start gint */
void kinit(void); void kinit(u32 *load_info);
/* kquit(): Quit gint and give back control to the system */ /* kquit(): Quit gint and give back control to the system */
void kquit(void); void kquit(void);
/* Select the CASIOWIN API for syscalls. */
void gint_set_CASIOWIN_API(int API);
#endif /* GINT_CORE_KERNEL */ #endif /* GINT_CORE_KERNEL */

14
src/kernel/osmenu.c
View file

@ -13,7 +13,6 @@ int __Timer_Deinstall(int id);
int __PutKeyCode(int row, int column, int keycode); int __PutKeyCode(int row, int column, int keycode);
int __GetKeyWait(int *col,int *row,int type,int time,int menu,uint16_t *key); int __GetKeyWait(int *col,int *row,int type,int time,int menu,uint16_t *key);
void __ClearKeyBuffer(void); /* ? */ void __ClearKeyBuffer(void); /* ? */
void __ConfigureStatusArea(int mode);
void __SetQuitHandler(void (*callback)(void)); void __SetQuitHandler(void (*callback)(void));
#if !GINT_OS_CP #if !GINT_OS_CP
@ -96,15 +95,17 @@ static os_menu_function_t *find_os_menu_function(void)
void gint_osmenu_native(void) void gint_osmenu_native(void)
{ {
#if GINT_OS_CG
if(gint[HWCALC] == HWCALC_FXCG100)
return;
#endif
// TODO: OS menu on fx-CP // TODO: OS menu on fx-CP
#if !GINT_OS_CP #if !GINT_OS_CP
__ClearKeyBuffer(); __ClearKeyBuffer();
gint_copy_vram(); gint_copy_vram();
#if GINT_OS_CG #if GINT_OS_CG
/* Unfortunately ineffective (main menu probably reenables it)
__ConfigureStatusArea(3); */
/* Try to use the internal function directly if we could figure out its /* Try to use the internal function directly if we could figure out its
address by dynamically disassembling */ address by dynamically disassembling */
os_menu_function_t *fun = find_os_menu_function(); os_menu_function_t *fun = find_os_menu_function();
@ -122,11 +123,6 @@ void gint_osmenu_native(void)
} }
#endif #endif
/* Mysteriously crashes when coming back; might be useful another time
instead of GetKeyWait()
int C=0x04, R=0x09;
__SpecialMatrixCodeProcessing(&C, &R); */
__osmenu_id = __Timer_Install(0, __osmenu_handler, 0 /* ms */); __osmenu_id = __Timer_Install(0, __osmenu_handler, 0 /* ms */);
if(__osmenu_id <= 0) return; if(__osmenu_id <= 0) return;
__Timer_Start(__osmenu_id); __Timer_Start(__osmenu_id);

21
src/kernel/start.c
View file

@ -42,8 +42,9 @@ int8_t gint_restart = 0;
/* gint_setrestart(): Set whether to restart the add-in after exiting */ /* gint_setrestart(): Set whether to restart the add-in after exiting */
void gint_setrestart(int restart) void gint_setrestart(int restart)
{ {
/* There is now return-to-menu so no restart on CP */ /* No restart on the machines for which there is no return-to-menu, i.e. on
gint_restart = restart && !GINT_OS_CP; fx-CP and on the fx-CG 100. */
gint_restart = restart && !GINT_OS_CP && gint[HWCALC] != HWCALC_FXCG100;
} }
/* Return value of main() */ /* Return value of main() */
@ -108,7 +109,7 @@ void gint_load_onchip_sections(void)
} }
} }
static int start2(int isappli, int optnum) static int start2(int load_type, u32 *load_info)
{ {
/* We are currently in a dynamic userspace mapping of an add-in run /* We are currently in a dynamic userspace mapping of an add-in run
from the storage memory. We are running in privileged mode with one from the storage memory. We are running in privileged mode with one
@ -173,8 +174,11 @@ static int start2(int isappli, int optnum)
} }
#endif #endif
/* Install gint, switch VBR and initialize drivers */ /* Install gint, switch VBR and initialize drivers. If loading information
kinit(); was provided, pass it on. */
if(load_type == 0x4d504d30 /* 'MPM0' */ && !((u32)load_info & 3)) {}
else load_info = NULL;
kinit(load_info);
/* We are now running on our own in kernel mode. Since we have taken /* We are now running on our own in kernel mode. Since we have taken
control of interrupts, pretty much any interaction with the system control of interrupts, pretty much any interaction with the system
@ -189,9 +193,6 @@ static int start2(int isappli, int optnum)
what it wants in exit() after main() finishes executing */ what it wants in exit() after main() finishes executing */
if(!setjmp(gint_exitbuf)) { if(!setjmp(gint_exitbuf)) {
callarray(&bctors, &ectors); callarray(&bctors, &ectors);
// TODO: record isappli and optnum in globals
(void)isappli;
(void)optnum;
exit(main()); exit(main());
} }
else { else {
@ -210,11 +211,11 @@ static int start2(int isappli, int optnum)
} }
GSECTION(".text.entry") GSECTION(".text.entry")
int start(int isappli, int optnum) int start(int load_type, u32 *load_info)
{ {
int rc; int rc;
while(1) { while(1) {
rc = start2(isappli, optnum); rc = start2(load_type, load_info);
if(!gint_restart) break; if(!gint_restart) break;
gint_osmenu_native(); gint_osmenu_native();
} }

178
src/kernel/syscalls.S
View file

@ -144,82 +144,128 @@ syscall_table:
#endif /* GINT_OS_FX */ #endif /* GINT_OS_FX */
#if GINT_OS_CG #if GINT_OS_CG
#define CASIOWIN_API_VERSIONS 3
.global _gint_set_CASIOWIN_API
.global _gint_get_CASIOWIN_API
/* Dynamic allocation */ /* System for dynamically selecting between the syscall and fixed version of
each function based on the OS version.
@r0: Internal function ID (from table below) */
_CASIOWIN_call:
mov #CASIOWIN_API_VERSIONS, r1
mulu.w r0, r1
mov.l 3f, r0
mov.l @r0, r2
sts macl, r1
add r2, r1
shll2 r1
___malloc: /* API version 0 is the normal syscall table */
syscall(0x1f44) tst r2, r2
___free: mova .CASIOWIN_TABLE, r0
syscall(0x1f42) bt.s .syscall
___realloc: mov.l @(r0, r1), r0
syscall(0x1f46)
/* BFile driver */ /* Other API versions are the direct calls */
tst r0, r0
bt .missingCall
_BFile_Remove: jmp @r0
syscall(0x1db4) nop
_BFile_Rename:
syscall(0x1db3)
_BFile_Create:
syscall(0x1dae)
_BFile_Open:
mov #0, r6
syscall(0x1da3)
_BFile_Close:
syscall(0x1da4)
_BFile_Size:
syscall(0x1da6)
_BFile_Seek:
syscall(0x1da9)
_BFile_GetPos:
syscall(0x1dab)
_BFile_Write:
syscall(0x1daf)
_BFile_Read:
syscall(0x1dac)
_BFile_FindFirst:
syscall(0x1db6)
_BFile_FindNext:
syscall(0x1db8)
_BFile_FindClose:
syscall(0x1dba)
/* Return to menu */ .missingCall:
mov.l .gint_panic, r0
mov.w 2f, r4
jmp @r0
nop
___Timer_Install: .syscall:
syscall(0x8d9) mov.l 1f, r1
___Timer_Start: jmp @r1
syscall(0x8db) nop
___Timer_Stop:
syscall(0x8dc)
___Timer_Deinstall:
syscall(0x8da)
___PutKeyCode:
syscall(0x12c6)
___GetKeyWait:
syscall(0x12bf)
___ClearKeyBuffer:
syscall(0x12c7)
___GetVRAMAddress:
syscall(0x1e6)
___ConfigureStatusArea:
syscall(0x2b7)
___SetQuitHandler:
syscall(0x1e6e)
.global ___SpecialMatrixCodeProcessing 2: .word 0x10c0
___SpecialMatrixCodeProcessing: .balign 4
syscall(0x1e60) 1: .long 0x80020070
.gint_panic:
.long _gint_panic
/* Reset */ _gint_set_CASIOWIN_API:
mov.l 3f, r0
rts
mov.l r4, @r0
___PowerOff: _gint_get_CASIOWIN_API:
syscall(0x1839) mov.l 3f, r0
___Reset: rts
syscall(0x1187) mov.l @r0, r0
syscall_table: .balign 4
.long 0x80020070 3: .long .CASIOWIN_API
.CASIOWIN_TABLE:
.long 0x1f44, 0x8025e0fc, 0x80366708 /* malloc */
.long 0x1f42, 0x8025dec8, 0x803664d4 /* free */
.long 0x1f46, 0x8025ec3c, 0x803672c8 /* realloc */
.long 0x1db4, 0x802404d2, 0x80334212 /* BFile_Remove */
.long 0x1db3, 0x80240482, 0x803341c2 /* BFile_Rename */
.long 0x1dae, 0x802401b0, 0x80333ef0 /* BFile_Create */
.long 0x1da3, 0x8023fb90, 0x803338d0 /* BFile_Open */
.long 0x1da4, 0x8023fd0e, 0x80333a4e /* BFile_Close */
.long 0x1da6, 0x8023fdc4, 0x80333b04 /* BFile_Size */
.long 0x1da9, 0x8023ff2c, 0x80333c6c /* BFile_Seek */
.long 0x1dab, 0x8024003c, 0x80333d7c /* BFile_GetPos */
.long 0x1daf, 0x8024025e, 0x80333f9e /* BFile_Write */
.long 0x1dac, 0x80240082, 0x80333dc2 /* BFile_Read */
.long 0x1db6, 0x80240888, 0x803345c8 /* BFile_FindFirst */
.long 0x1db8, 0x80240b06, 0x80334846 /* BFile_FindNext */
.long 0x1dba, 0x80240c10, 0x80334950 /* BFile_FindClose */
.long 0x08d9, 0x800b130c, 0x8010de28 /* Timer_Install */
.long 0x08db, 0x800b1456, 0x8010df72 /* Timer_Start */
.long 0x08dc, 0x800b14b2, 0x8010dfce /* Timer_Stop */
.long 0x08da, 0x800b13d4, 0x8010def0 /* Timer_Deinstall */
.long 0x12c6, 0, 0 /* PutKeyCode */
.long 0x12bf, 0x8017be56, 0x802382fe /* GetKeyWait */
.long 0x12c7, 0, 0 /* ClearKeyBuffer */
.long 0x01e6, 0x8004579a, 0x8007569e /* GetVRAMAddress */
.long 0x1e6e, 0, 0 /* SetQuitHandler */
.long 0x1839, 0, 0 /* PowerOff */
.long 0x1187, 0, 0 /* Reset */
#define casiowin_call(id) bra _CASIOWIN_call; mov id, r0
___malloc: casiowin_call(#0)
___free: casiowin_call(#1)
___realloc: casiowin_call(#2)
_BFile_Remove: casiowin_call(#3)
_BFile_Rename: casiowin_call(#4)
_BFile_Create: casiowin_call(#5)
_BFile_Open: mov #0, r6; casiowin_call(#6)
_BFile_Close: casiowin_call(#7)
_BFile_Size: casiowin_call(#8)
_BFile_Seek: casiowin_call(#9)
_BFile_GetPos: casiowin_call(#10)
_BFile_Write: casiowin_call(#11)
_BFile_Read: casiowin_call(#12)
_BFile_FindFirst: casiowin_call(#13)
_BFile_FindNext: casiowin_call(#14)
_BFile_FindClose: casiowin_call(#15)
___Timer_Install: casiowin_call(#16)
___Timer_Start: casiowin_call(#17)
___Timer_Stop: casiowin_call(#18)
___Timer_Deinstall: casiowin_call(#19)
___PutKeyCode: casiowin_call(#20)
___GetKeyWait: casiowin_call(#21)
___ClearKeyBuffer: casiowin_call(#22)
___GetVRAMAddress: casiowin_call(#23)
___ConfigureStatusArea: casiowin_call(#24)
___SetQuitHandler: casiowin_call(#25)
___PowerOff: casiowin_call(#26)
___Reset: casiowin_call(#27)
.data
.CASIOWIN_API:
.long 0
#endif /* GINT_OS_CG */ #endif /* GINT_OS_CG */

4
src/kernel/vbr.h
View file

@ -11,8 +11,4 @@ void gint_tlbh(void);
void gint_inth_7705(void); void gint_inth_7705(void);
void gint_inth_7305(void); void gint_inth_7305(void);
/* Size of exception and TLB handlers */
extern char gint_exch_size;
extern char gint_tlbh_size;
#endif /* GINT_CORE_VBR */ #endif /* GINT_CORE_VBR */

72
src/keysc/keydev.c
View file

@ -8,6 +8,7 @@
#include <gint/drivers/keydev.h> #include <gint/drivers/keydev.h>
#include <gint/defs/types.h> #include <gint/defs/types.h>
#include <gint/defs/util.h> #include <gint/defs/util.h>
#include <gint/hardware.h>
#include <string.h> #include <string.h>
#include <stdarg.h> #include <stdarg.h>
@ -45,14 +46,49 @@ static void keycode_to_keymatrix(int keycode, int *row, int *col)
*col = 0; *col = 0;
} }
#else #else
static GINLINE int keymatrix_to_keycode(int row, int col) static uint8_t const CG100_keymap[] = {
KEY_ON, KEY_HOME, KEY_PREVTAB, KEY_UP, KEY_NEXTTAB, KEY_PAGEUP,
KEY_SETTINGS, KEY_BACK, KEY_LEFT, KEY_OK, KEY_RIGHT, KEY_PAGEDOWN,
KEY_SHIFT, KEY_ALPHA, KEY_VARS, KEY_DOWN, KEY_CATALOG, KEY_TOOLS,
KEY_XOT, KEY_FRAC, KEY_SQRT, KEY_POWER, KEY_SQUARE, KEY_EXPFUN,
KEY_COMMA, KEY_SIN, KEY_COS, KEY_TAN, KEY_LEFTP, KEY_RIGHTP,
};
static int keymatrix_to_keycode(int row, int col)
{ {
if(gint[HWCALC] == HWCALC_FXCG100) {
if(row >= 7 && row <= 9)
return CG100_keymap[6 * (9-row) + (6-col)];
if(row == 1 && col == 3)
return KEY_FORMAT;
}
return (row << 4) + (7 - col); return (row << 4) + (7 - col);
} }
static GINLINE void keycode_to_keymatrix(int keycode, int *row, int *col) static void keycode_to_keymatrix(int keycode, int *row, int *col)
{ {
if(gint[HWCALC] == HWCALC_FXCG100) {
if(keycode == KEY_FORMAT) {
*row = 1;
*col = 3;
return;
}
for(int i = 0; i < (int)sizeof(CG100_keymap); i++) {
if(CG100_keymap[i] == keycode) {
*row = 9 - i / 6;
*col = 6 - (i % 6);
return;
}
}
}
*row = keycode >> 4; *row = keycode >> 4;
*col = 7 - (keycode & 7); *col = 7 - (keycode & 7);
if(gint[HWCALC] == HWCALC_FXCG100 &&
(*row > 4 || (*row == 1 && *col == 3))) {
// key that doesn't exist
*row = 0;
*col = 1;
}
} }
#endif #endif
@ -125,6 +161,8 @@ void keydev_process_state(keydev_t *d, uint8_t scan[12])
for(int mask = 0x80, col = 7; mask; mask >>= 1, col--) for(int mask = 0x80, col = 7; mask; mask >>= 1, col--)
{ {
ev.row = row;
ev.col = col;
ev.key = keymatrix_to_keycode(row, col); ev.key = keymatrix_to_keycode(row, col);
/* Update state only if the push succeeds */ /* Update state only if the push succeeds */
if((diff & mask) && keydev_queue_push(d, ev)) if((diff & mask) && keydev_queue_push(d, ev))
@ -173,6 +211,8 @@ key_event_t keydev_repeat_event(keydev_t *d)
ev.type = KEYEV_HOLD; ev.type = KEYEV_HOLD;
ev.key = d->rep_key; ev.key = d->rep_key;
ev.row = d->rep_row;
ev.col = d->rep_col;
return ev; return ev;
} }
@ -188,11 +228,11 @@ void keydev_tick(keydev_t *d, uint us)
/* Disable repeat if the repeating key was released */ /* Disable repeat if the repeating key was released */
if(d->rep_key != 0) if(d->rep_key != 0)
{ {
int row, col; if(!(d->state_now[d->rep_row] & (1 << d->rep_col)))
keycode_to_keymatrix(d->rep_key, &row, &col);
if(!(d->state_now[row] & (1 << col)))
{ {
d->rep_key = 0; d->rep_key = 0;
d->rep_row = 0;
d->rep_col = 0;
d->rep_count = -1; d->rep_count = -1;
d->rep_time = -1; d->rep_time = -1;
d->rep_delay = -1; d->rep_delay = -1;
@ -231,19 +271,27 @@ key_event_t keydev_unqueue_event(keydev_t *d)
if(!queue_poll(d, &ev)) if(!queue_poll(d, &ev))
return ev; return ev;
/* Compatibility combinations can transform the .key attribute */
#if GINT_HW_CG
if(gint[HWCALC] == HWCALC_FXCG100) {
if(keydev_keydown(d, KEY_CATALOG) && ev.row == 6)
ev.key = KEY_F1 + (6 - ev.col);
}
#endif
/* Update the event state accordingly */ /* Update the event state accordingly */
int row, col; int mask = 1 << ev.col;
keycode_to_keymatrix(ev.key, &row, &col);
int mask = 1 << col;
if(ev.type == KEYEV_DOWN) if(ev.type == KEYEV_DOWN)
{ {
d->state_queue[row] |= mask; d->state_queue[ev.row] |= mask;
d->state_flips[row] ^= mask; d->state_flips[ev.row] ^= mask;
/* Mark this key as the currently repeating one */ /* Mark this key as the currently repeating one */
if(d->rep_key == 0 && can_repeat(d, ev.key)) if(d->rep_key == 0 && can_repeat(d, ev.key))
{ {
d->rep_key = ev.key; d->rep_key = ev.key;
d->rep_row = ev.row;
d->rep_col = ev.col;
d->rep_count = -1; d->rep_count = -1;
d->rep_time = 0; d->rep_time = 0;
d->rep_delay = 0; d->rep_delay = 0;
@ -251,8 +299,8 @@ key_event_t keydev_unqueue_event(keydev_t *d)
} }
else if(ev.type == KEYEV_UP) else if(ev.type == KEYEV_UP)
{ {
d->state_queue[row] &= ~mask; d->state_queue[ev.row] &= ~mask;
d->state_flips[row] ^= mask; d->state_flips[ev.row] ^= mask;
} }
return ev; return ev;

82
src/r61523/r61523.c
View file

@ -17,12 +17,18 @@
#define REG_VRANGE 0x2b #define REG_VRANGE 0x2b
#define REG_DATA 0x2c #define REG_DATA 0x2c
#define REG_DEVICE_CODE_READ 0xbf #define REG_DEVICE_CODE_READ 0xbf
#define REG_DEVICE_CODE_VARIANT 0xda
/* Interface with the controller */ /* Interface with the controller */
static volatile uint16_t *DISPLAY = (void *)0xb4000000; static volatile uint16_t *DISPLAY = (void *)0xb4000000;
/* Bit 4 of Port R controls the RS bit of the display driver */ /* Bit 4 of Port R controls the RS bit of the display driver */
static volatile uint8_t *PRDR = (void *)0xa405013c; static volatile uint8_t *PRDR = (void *)0xa405013c;
/* Screen variant information
* This number is 0x00 for the old R61523 that everyone knows, and 0x16 or
* 0x52 for the newer ones found in recent FXCP400 devices. */
static uint16_t r61523_variant = 0;
/* Select a register */ /* Select a register */
GINLINE static void select(uint16_t reg) GINLINE static void select(uint16_t reg)
{ {
@ -56,16 +62,38 @@ static void read_Nu16(uint16_t *array, int N)
// Generic functions // Generic functions
//--- //---
void r61523_identify(uint32_t *manufacturerCode, uint16_t *deviceCode) /* r61523_identify() - identify screen hardware information
{ *
select(REG_DEVICE_CODE_READ); * notes
* Since recent versions of the FXCP400, new screens are used that break
* the current driver. These screens are particular since they have the
* same manufacturer / device code, but they use an undocumented register
* (0xda) to determine the variant.
*
* The register 0xda should be read twice. Casio ignores the first reading
* and only keep track of the second. So, let's do the same here. */
void r61523_identify(
uint32_t *manufacturerCode,
uint16_t *deviceCode,
uint16_t *variant
) {
uint16_t packets[5]; uint16_t packets[5];
read_Nu16(packets, 5);
if(manufacturerCode) if (manufacturerCode != NULL || deviceCode != NULL)
*manufacturerCode = (packets[1] << 16) | packets[2]; {
if(deviceCode) select(REG_DEVICE_CODE_READ);
*deviceCode = (packets[3] << 16) | packets[4]; read_Nu16(packets, 5);
if(manufacturerCode)
*manufacturerCode = (packets[1] << 16) | packets[2];
if(deviceCode)
*deviceCode = (packets[3] << 16) | packets[4];
}
if (variant)
{
select(REG_DEVICE_CODE_VARIANT);
*variant = read();
*variant = read();
}
} }
//--- //---
@ -74,10 +102,13 @@ void r61523_identify(uint32_t *manufacturerCode, uint16_t *deviceCode)
void r61523_win_set(int x1, int x2, int y1, int y2) void r61523_win_set(int x1, int x2, int y1, int y2)
{ {
/* R61523 has a 360x640 area; the CP-400 uses the top-right corner for its if (r61523_variant != 0x16 || r61523_variant != 0x52)
320x528 display, so skip over the first 40 columns */ {
x1 += 40; /* R61523 has a 360x640 area; the CP-400 uses the top-right corner
x2 += 40; * for its 320x528 display, so skip over the first 40 columns */
x1 += 40;
x2 += 40;
}
uint16_t volatile *DISPLAY = (void *)0xb4000000; uint16_t volatile *DISPLAY = (void *)0xb4000000;
@ -109,7 +140,6 @@ void r61523_win_set(int x1, int x2, int y1, int y2)
void r61523_display(uint16_t *vram) void r61523_display(uint16_t *vram)
{ {
r61523_win_set(0, 319, 0, 527); r61523_win_set(0, 319, 0, 527);
select(44); select(44);
int row_offset = 0; int row_offset = 0;
@ -125,6 +155,23 @@ void r61523_display(uint16_t *vram)
} }
} }
void r61523_display_rect(
uint16_t *vram, int xmin, int xmax, int ymin, int ymax)
{
// dma_transfer_wait(0);
r61523_win_set(xmin, xmax, ymin, ymax);
select(44);
vram += 320 * ymin + xmin;
uint16_t volatile *DISPLAY = (void *)0xb4000000;
for(int y = 0; y < ymax - ymin + 1; y++) {
for(int x = 0; x < xmax - xmin + 1; x++)
*DISPLAY = vram[x];
vram += 320;
}
}
static bool r61523_update(int x, int y, image_t const *fb, int flags) static bool r61523_update(int x, int y, image_t const *fb, int flags)
{ {
if(fb->format != IMAGE_RGB565) if(fb->format != IMAGE_RGB565)
@ -152,10 +199,17 @@ static bool r61523_update(int x, int y, image_t const *fb, int flags)
// Driver metadata // Driver metadata
//--- //---
/* constructor() - determine which variant of screen we have */
static void constructor(void)
{
r61523_identify(NULL, NULL, &r61523_variant);
}
/* As far as I can tell there's no way to read the current window from the /* As far as I can tell there's no way to read the current window from the
controller so this driver is completely stateless for now. */ controller so this driver is completely stateless for now. */
gint_driver_t drv_r61523 = { gint_driver_t drv_r61523 = {
.name = "R61523", .name = "R61523",
.constructor = constructor,
}; };
GINT_DECLARE_DRIVER(26, drv_r61523); GINT_DECLARE_DRIVER(26, drv_r61523);

13
src/render-cg/dvram.c
View file

@ -97,16 +97,15 @@ bool dvram_init(void)
{ {
int const MARGIN = 32; int const MARGIN = 32;
char const *arena = NULL;
if(kmalloc_get_arena("_ostk"))
arena = "_ostk";
/* Leave MARGIN bytes on each side of the region; this enables some /* Leave MARGIN bytes on each side of the region; this enables some
important optimizations in the image renderer. We also add another important optimizations in the image renderer. We also add another
32 bytes so we can manually 32-align the region */ 32 bytes so we can manually 32-align the region */
uint32_t region = (uint32_t)kmalloc(DWIDTH*DHEIGHT*2 + MARGIN*2 + 32, uint32_t region =
#if !defined(GINT_NO_OS_STACK) (uint32_t)kmalloc(DWIDTH*DHEIGHT*2 + MARGIN*2 + 32, arena);
"_ostk"
#else
NULL
#endif
);
if(region == 0) if(region == 0)
return false; return false;

34
src/render-cg/gint_dline.c
View file

@ -4,7 +4,7 @@
#if GINT_RENDER_RGB #if GINT_RENDER_RGB
/* gint_dhline(): Optimized horizontal line */ /* gint_dhline(): Optimized horizontal line */
void gint_dhline(int x1, int x2, int y, uint16_t color) void gint_dhline(int x1, int x2, int y, int color)
{ {
if(y < dwindow.top || y >= dwindow.bottom) return; if(y < dwindow.top || y >= dwindow.bottom) return;
if(x1 > x2) swap(x1, x2); if(x1 > x2) swap(x1, x2);
@ -15,9 +15,19 @@ void gint_dhline(int x1, int x2, int y, uint16_t color)
int offset = DWIDTH * y; int offset = DWIDTH * y;
/* Use longwords to do the copy, but first paint the endpoints to heed /* Use longwords to do the copy, but first paint the endpoints to heed
for odd x1 and x2. Checking the parity may be a waste of time. */ for odd x1 and x2. Checking the parity may be a waste of time for
gint_vram[offset + x1] = color; "real" color, but must be checked when C_INVERT in involved to
gint_vram[offset + x2] = color; avoid "cancelling" invert effect with potential overdraw of the
next operation. */
if (color != C_INVERT) {
gint_vram[offset + x1] = color;
gint_vram[offset + x2] = color;
} else {
if (x1 & 1)
gint_vram[offset + x1] ^= 0xffff;
if (x2 & 1)
gint_vram[offset + x2] ^= 0xffff;
}
/* Now round to longword boundaries and copy everything in-between with /* Now round to longword boundaries and copy everything in-between with
longwords */ longwords */
@ -26,13 +36,17 @@ void gint_dhline(int x1, int x2, int y, uint16_t color)
uint32_t *start = (void *)(gint_vram + offset + x1); uint32_t *start = (void *)(gint_vram + offset + x1);
uint32_t *end = (void *)(gint_vram + offset + x2); uint32_t *end = (void *)(gint_vram + offset + x2);
uint32_t op = (color << 16) | color;
while(end > start) *--end = op; if (color != C_INVERT) {
uint32_t op = (color << 16) | color;
while(end > start) *--end = op;
} else {
while(end > start) *--end ^= 0xffffffff;
}
} }
/* gint_dvline(): Optimized vertical line */ /* gint_dvline(): Optimized vertical line */
void gint_dvline(int y1, int y2, int x, uint16_t color) void gint_dvline(int y1, int y2, int x, int color)
{ {
if(x < dwindow.left || x >= dwindow.right) return; if(x < dwindow.left || x >= dwindow.right) return;
if(y1 > y2) swap(y1, y2); if(y1 > y2) swap(y1, y2);
@ -42,7 +56,11 @@ void gint_dvline(int y1, int y2, int x, uint16_t color)
uint16_t *v = gint_vram + DWIDTH * y1 + x; uint16_t *v = gint_vram + DWIDTH * y1 + x;
int height = y2 - y1 + 1; int height = y2 - y1 + 1;
while(height-- > 0) *v = color, v += DWIDTH; if (color != C_INVERT) {
while(height-- > 0) *v = color, v += DWIDTH;
} else {
while(height-- > 0) *v ^= 0xffff, v += DWIDTH;
}
} }
#endif #endif

4
src/render/render.h
View file

@ -11,12 +11,12 @@
/* gint_dhline(): Optimized horizontal line /* gint_dhline(): Optimized horizontal line
@x1 @x2 @y Coordinates of endpoints of line (both included) @x1 @x2 @y Coordinates of endpoints of line (both included)
@color Any color suitable for dline() */ @color Any color suitable for dline() */
void gint_dhline(int x1, int x2, int y, color_t color); void gint_dhline(int x1, int x2, int y, int color);
/* gint_dvline(): Optimized vertical line /* gint_dvline(): Optimized vertical line
@y1 @y2 @x Coordinates of endpoints of line (both included) @y1 @y2 @x Coordinates of endpoints of line (both included)
@color Any color suitable for dline() */ @color Any color suitable for dline() */
void gint_dvline(int y1, int y2, int x, color_t color); void gint_dvline(int y1, int y2, int x, int color);
//--- //---
// Font rendering (topti) // Font rendering (topti)

146
src/touch/adconv.c Normal file
View file

@ -0,0 +1,146 @@
//---
// gint:touch:adconv - 0x84 register data conversion
//---
#include <stdlib.h>
#include <gint/defs/util.h>
#include <gint/cpu.h>
#include <gint/config.h>
#if GINT_HW_CP
#include "./adconv.h"
#include "./i2c.h"
#include "./driver.h"
//---
// Internals
//---
/* __touch_drv_info - global driver information */
extern struct _touch_drv_info __touch_drv_info;
/* _adconv_check_dual() - check if it is dual or single */
static int _adconv_check_dual(
struct _touch_adconv *adconv,
struct _touch_adraw *adraw
) {
extern struct _touch_drv_info __touch_drv_info;
bool is_dual;
int x2;
int y2;
int z2;
int val;
cpu_atomic_start();
x2 = ((int)((uint)(adraw->x2) >> 6)) + ((adraw->x2 & 1) * -0x400);
y2 = ((int)((uint)(adraw->y2) >> 6)) + ((adraw->y2 & 1) * -0x400);
z2 = ((int)((uint)(adraw->z2) >> 4)) + ((adraw->z2 & 1) * -0x1000);
adconv->x2 = x2;
adconv->y2 = y2;
adconv->z2 = z2;
val = __touch_drv_info.calibration.dual_sensi_entry;
if (__touch_drv_info.adinfo.prev_is_dual)
val = __touch_drv_info.calibration.dual_sensi_leave;
is_dual = ((abs(z2) >= val) || (max(abs(x2),abs(y2)) >= val));
__touch_drv_info.adinfo.prev_is_dual = is_dual;
cpu_atomic_end();
return is_dual;
}
//---
// Public
//---
/* touch_adconv_get_raw() - read 0x84 register using I2C */
int touch_adconv_get_raw(struct _touch_adraw *adraw)
{
volatile uint8_t *IO_PRDR = (void*)0xa405013c;
if (((*IO_PRDR) & 0x20) != 0)
{
adraw->x1 = 0;
adraw->y1 = 0;
adraw->z1 = 0;
adraw->x2 = 0;
adraw->y2 = 0;
adraw->z2 = 0;
adraw->gh = 0;
cpu_atomic_start();
__touch_drv_info.adinfo.prev_is_dual = false;
cpu_atomic_end();
return 0;
}
i2c_reg_read(0x84, adraw, 16);
return 1;
}
/* touch_adconv_convert() - perform the raw conversion */
int touch_adconv_get_conv(
struct _touch_adconv *adconv,
struct _touch_adraw *adraw,
int type
) {
if (type == 0)
return 0;
adconv->x1 = adraw->x1 >> 4;
adconv->y1 = adraw->y1 >> 4;
adconv->z1 = adraw->z1 >> 4;
adconv->gh = adraw->gh >> 4;
adconv->dm = adraw->dm >> 6;
if (_adconv_check_dual(adconv, adraw) == 0)
return 1;
return 2;
}
/* touch_adconv_get_dots() - generate dots information */
int touch_adconv_get_dots(
struct _touch_addots *dots,
struct _touch_adconv *adconv,
int type
) {
int x_div;
int x_base;
int y_div;
int y_base;
cpu_atomic_start();
x_div = __touch_drv_info.calibration.x_div;
x_base = __touch_drv_info.calibration.x_base;
y_div = __touch_drv_info.calibration.y_div;
y_base = __touch_drv_info.calibration.y_base;
switch (type)
{
case 0:
dots->type = TS_DOTS_TYPE_OFF;
dots->x1 = 0;
dots->y1 = 0;
dots->z1 = 0;
dots->x2 = 0;
dots->y2 = 0;
dots->z2 = 0;
break;
case 1:
dots->type = TS_DOTS_TYPE_SINGLE;
dots->x1 = ((adconv->x1 - x_base) * 0x100) / x_div;
dots->y1 = ((adconv->y1 - y_base) * 0x100) / y_div;
dots->z1 = adconv->z1;
dots->x2 = 0;
dots->y2 = 0;
dots->z2 = 0;
break;
case 2:
dots->type = TS_DOTS_TYPE_DUAL;
dots->x1 = ((adconv->x1 - x_base) * 0x100) / x_div;
dots->y1 = ((adconv->y1 - y_base) * 0x100) / y_div;
dots->z1 = adconv->z1;
dots->x2 = ((adconv->x2 - x_base) * 0x100) / x_div;
dots->y2 = ((adconv->y2 - y_base) * 0x100) / y_div;
dots->z2 = adconv->z2;
break;
}
cpu_atomic_end();
return type;
}
#endif /* GINT_HW_CP */

90
src/touch/adconv.h Normal file
View file

@ -0,0 +1,90 @@
#ifndef GINT_TOUCH_ADCONV_H
#define GINT_TOUCH_ADCONV_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/defs/types.h>
#include <gint/config.h>
#if GINT_HW_CP
//---
// Internals
//---
/* _touch_adraw - raw 0x84 register information */
struct _touch_adraw
{
uint16_t x1;
uint16_t y1;
uint16_t z1;
uint16_t gh;
uint16_t x2;
uint16_t y2;
uint16_t z2;
uint16_t dm;
};
/* _touch_adconv - post-conversion raw 0x84 register information */
struct _touch_adconv
{
int x1;
int y1;
int x2;
int y2;
int z1;
int z2;
uint16_t gh;
uint16_t dm;
};
/* _touch_addots_type - type of dots */
enum _touch_addots_type
{
TS_DOTS_TYPE_OFF = 0,
TS_DOTS_TYPE_SINGLE = 1,
TS_DOTS_TYPE_DUAL = 2,
};
/* _touch_addots - touchscreen dots information */
struct _touch_addots
{
enum _touch_addots_type type;
int x1;
int y1;
int z1;
int x2;
int y2;
int z2;
};
//---
// Public
//---
/* touch_adconv_get_raw() - read 0x84 register using I2C */
extern int touch_adconv_get_raw(struct _touch_adraw *adraw);
/* touch_adconv_get_conv() - perform the raw conversion */
extern int touch_adconv_get_conv(
struct _touch_adconv *adconv,
struct _touch_adraw *adraw,
int type
);
/* touch_adconv_get_dots() - generate dots information */
extern int touch_adconv_get_dots(
struct _touch_addots *dots,
struct _touch_adconv *adconv,
int type
);
#endif /* GINT_HW_CP */
#ifdef __cplusplus
}
#endif
#endif /* GINT_TOUCH_ADCONV_H */

112
src/touch/driver.c Normal file
View file

@ -0,0 +1,112 @@
//---
// gint:touch:driver - touch-screen driver declaration
//---
#include <string.h>
#include <gint/drivers.h>
#include <gint/drivers/states.h>
#include <gint/config.h>
#if GINT_HW_CP
#include "./driver.h"
#include "./i2c.h"
//---
// Internals
//---
/* __touch_drv_info - internal driver information */
extern struct _touch_drv_info __touch_drv_info;
/* _touch_configure() - configure touch-screen */
static void _touch_configure(void)
{
volatile uint16_t *IO_PRCR = (void*)0xa405011c;
i2c_configure();
*(IO_PRCR) = (*(IO_PRCR) & 0xf3ff) | 0xc00;
memset(&__touch_drv_info, 0x00, sizeof(struct _touch_drv_info));
__touch_drv_info.prev_evt.type = KEYEV_NONE;
__touch_drv_info.prev_evt.x = 0xffff;
__touch_drv_info.prev_evt.y = 0xffff;
__touch_drv_info.calibration.x_base = 0x20b;
__touch_drv_info.calibration.x_div = 0x9b6;
__touch_drv_info.calibration.y_base = 0x0f4;
__touch_drv_info.calibration.y_div = 0x66f;
__touch_drv_info.calibration.dual_debounce_frame = 0;
__touch_drv_info.calibration.dual_sensi_entry = 0x18;
__touch_drv_info.calibration.dual_sensi_leave = 0x24;
}
/* _touch_hsave() - save hardware state */
static void _touch_hsave(touch_state_t *state)
{
volatile uint16_t *IO_PRCR = (void*)0xa405011c;
i2c_hsave(state);
state->PRCR = *(IO_PRCR);
}
/* _touch_hrestore() - restore hardware state */
static void _touch_hrestore(touch_state_t *state)
{
volatile uint16_t *IO_PRCR = (void*)0xa405011c;
*(IO_PRCR) = state->PRCR;
i2c_hrestore(state);
}
/* _touch_hpowered() - check if the module is powered */
static bool _touch_hpowered(void)
{
return i2c_hpowered();
}
/* _touch_hpoweron() - power on the module */
static void _touch_hpoweron(void)
{
i2c_hpoweron();
}
/* _touch_hpoweroff() - power off the module */
static void _touch_hpoweroff(void)
{
i2c_hpoweroff();
}
/* _touch_unbind() - unbind from gint to casio */
static void _touch_unbind(void)
{
i2c_unbind();
}
/* _touch_funbind() - funbind from casio to gint */
static void _touch_funbind(void)
{
i2c_funbind();
}
//---
// Public
//---
/* __touch_drv_info - internal driver information */
struct _touch_drv_info __touch_drv_info;
/* drv_touch - touch-screen driver declaration */
gint_driver_t drv_touch = {
.name = "TOUCH",
.configure = _touch_configure,
.hsave = (void *)_touch_hsave,
.hrestore = (void *)_touch_hrestore,
.hpowered = _touch_hpowered,
.hpoweron = _touch_hpoweron,
.hpoweroff = _touch_hpoweroff,
.unbind = _touch_unbind,
.funbind = _touch_funbind,
.state_size = sizeof(touch_state_t),
};
GINT_DECLARE_DRIVER(24, drv_touch);
#endif /* GINT_HW_CP */

30
src/touch/driver.h Normal file
View file

@ -0,0 +1,30 @@
#ifndef GINT_TOUCH_DRIVER_H
#define GINT_TOUCH_DRIVER_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/keyboard.h>
#include <gint/touch.h>
#include <gint/config.h>
#if GINT_HW_CP
/* _touch_drv_info() - internal driver information */
struct _touch_drv_info
{
touch_calibration_t calibration;
key_event_t prev_evt;
struct {
bool prev_is_dual;
} adinfo;
};
#endif /* GINT_HW_CP */
#ifdef __cplusplus
}
#endif
#endif /* GINT_TOUCH_DRIVER_H */

254
src/touch/i2c.c Normal file
View file

@ -0,0 +1,254 @@
//---
// gint:touch:i2c - I2C driver
//---
#include <string.h>
#include <gint/defs/attributes.h>
#include <gint/defs/types.h>
#include <gint/defs/call.h>
#include <gint/cpu.h>
#include <gint/intc.h>
#include <gint/config.h>
#if GINT_HW_CP
#include "./i2c.h"
//---
// Internals
//---
/* __i2c_request - internal I2C request information */
volatile struct i2c_request_info __i2c_request;
/* i2c_hw_enable() - enable the I2C peripheral and configure the clock
*
* notes
* Clock configuration are the same used by Casio. Investigation must be
* made to ensure overclock/underclock validity */
static void _i2c_hw_enable(void)
{
SH7305_I2C.ICCR.ICE = 1;
while(true) {
if (SH7305_I2C.ICSR.BUSY == 0)
break;
}
SH7305_I2C.ICCL = 0x29;
SH7305_I2C.ICCH = 0x22;
}
/* i2c_hw_start_operation() - start I2C operation
*
* notes
* Enable only data transmit and arbitration lost interrupt then perform
* a start condition (0x94) */
static void _i2c_hw_start_operation(void)
{
SH7305_I2C.ICIC.ALE = 1;
SH7305_I2C.ICIC.TACKE = 1;
SH7305_I2C.ICIC.WAITE = 0;
SH7305_I2C.ICIC.DTEE = 1;
SH7305_I2C.ICCR.byte = 0x94;
}
/* i2c_request_await() - await async operation */
static int _i2c_request_await(void)
{
int status;
while (true)
{
cpu_atomic_start();
status = (__i2c_request.status == I2C_REQ_STATUS_FINISHED);
cpu_atomic_end();
if (status)
break;
__asm__ volatile ("sleep");
}
return 0;
}
//---
// Public
//---
/* i2c_reg_select() - select a register */
int i2c_reg_select(int reg)
{
cpu_atomic_start();
_i2c_hw_enable();
__i2c_request.mode = I2C_REQ_MODE_REG_SELECT;
__i2c_request.target_register = reg;
__i2c_request.buffer = NULL;
__i2c_request.buffer_size = 0;
__i2c_request.buffer_size_remaning = 0;
__i2c_request.buffer_cursor = 0;
__i2c_request.status = I2C_REQ_STATUS_START;
__i2c_request.state = I2C_REQ_STATE_START;
cpu_atomic_end();
_i2c_hw_start_operation();
return _i2c_request_await();
}
/* i2c_reg_read() - register read operation */
int i2c_reg_read(int reg, void *buffer, size_t size)
{
if (buffer == NULL)
return -1;
if (size == 0)
return -2;
cpu_atomic_start();
_i2c_hw_enable();
__i2c_request.mode = I2C_REQ_MODE_REG_READ;
__i2c_request.target_register = reg;
__i2c_request.buffer = buffer;
__i2c_request.buffer_size = size;
__i2c_request.buffer_size_remaning = size;
__i2c_request.buffer_cursor = 0;
__i2c_request.status = I2C_REQ_STATUS_START;
__i2c_request.state = I2C_REQ_STATE_START;
cpu_atomic_end();
_i2c_hw_start_operation();
return _i2c_request_await();
}
/* i2c_read_stream() - "stream" read operation (skip reg selection) */
int i2c_read_stream(void *buffer, size_t size)
{
if (buffer == NULL)
return -1;
if (size == 0)
return -2;
cpu_atomic_start();
_i2c_hw_enable();
__i2c_request.mode = I2C_REQ_MODE_READ_STREAM;
__i2c_request.target_register = 0x00;
__i2c_request.buffer = buffer;
__i2c_request.buffer_size = size;
__i2c_request.buffer_size_remaning = size;
__i2c_request.buffer_cursor = 0;
__i2c_request.status = I2C_REQ_STATUS_START;
__i2c_request.state = I2C_REQ_STATE_START;
cpu_atomic_end();
_i2c_hw_start_operation();
return _i2c_request_await();
}
//---
// Driver and state management
//---
#include <gint/mpu/power.h>
#include <gint/mpu/pfc.h>
#include <gint/mpu/intc.h>
/* i2c_hpowered() - check if the module is powered */
bool i2c_hpowered(void)
{
return (SH7305_POWER.MSTPCR2.I2C == 0);
}
/* i2c_hpoweron() - power on the module */
void i2c_hpoweron(void)
{
SH7305_POWER.MSTPCR2.I2C = 0;
SH7305_I2C.ICCR.ICE = 0;
SH7305_I2C.ICDR = 0;
SH7305_I2C.ICCL = 0x00;
SH7305_I2C.ICCH = 0x00;
}
/* i2c_hpoweroff() - power on the module */
void i2c_hpoweroff(void)
{
SH7305_POWER.MSTPCR2.I2C = 1;
}
/* i2c_hsave() - save hardware information */
void i2c_hsave(touch_state_t *state)
{
state->PJCR = SH7305_PFC.PJCR.word;
state->ICCR = SH7305_I2C.ICCR.byte;
state->ICIC = SH7305_I2C.ICIC.byte;
state->ICCL = SH7305_I2C.ICCL;
state->ICCH = SH7305_I2C.ICCH;
}
/* i2c_hrestore() - restore hardware information */
void i2c_hrestore(touch_state_t *state)
{
SH7305_I2C.ICCH = state->ICCH;
SH7305_I2C.ICCL = state->ICCL;
SH7305_I2C.ICIC.byte = state->ICIC;
SH7305_I2C.ICCR.byte = state->ICCR;
SH7305_PFC.PJCR.word = state->PJCR;
}
/* i2c_configure() - configure and install interrupt handlers */
void i2c_configure(void)
{
extern void i2c_inth_tack(void);
extern void i2c_inth_wait(void);
extern void i2c_inth_trans(void);
extern void i2c_inth_al(void);
// install I2C handler
intc_handler_function(0xe00, GINT_CALL(i2c_inth_al));
intc_handler_function(0xe20, GINT_CALL(i2c_inth_tack));
intc_handler_function(0xe40, GINT_CALL(i2c_inth_wait));
intc_handler_function(0xe60, GINT_CALL(i2c_inth_trans));
// configure I2C PIN
SH7305_PFC.PJCR.P5MD = 0b00;
SH7305_PFC.PJCR.P4MD = 0b00;
// configure I2C module
SH7305_I2C.ICCR.ICE = 0;
SH7305_I2C.ICDR = 0;
SH7305_I2C.ICCL = 0x00;
SH7305_I2C.ICCH = 0x00;
SH7305_I2C.ICSR.byte = 0x00;
SH7305_I2C.ICIC.byte = 0x00;
// init high-level driver information
memset((void*)&__i2c_request, 0x00, sizeof(struct i2c_request_info));
__i2c_request.status = I2C_REQ_STATUS_FINISHED;
// Enable interrupt
intc_priority(INTC_I2C_AL, 1);
intc_priority(INTC_I2C_TACK, 1);
intc_priority(INTC_I2C_WAIT, 1);
intc_priority(INTC_I2C_DTE, 1);
}
/* i2c_unbind() - unbind from gint to casio */
void i2c_unbind(void)
{
_i2c_request_await();
}
/* i2c_funbind() - funbind from casio to gint */
void i2c_funbind(void)
{
if (i2c_hpowered() == false)
return;
// fixme : avoid force terminate
// We cannot easily know the state of Casio's driver since they use
// an state machine to work, and finding the current state require a
// lot of hardcoded OS-specific offsets information. So, for now,
// force terminate the transaction and disable the module to avoid
// any error
SH7305_I2C.ICCR.ICE = 0;
SH7305_I2C.ICDR = 0;
}
#endif /* GINT_HW_CP */

109
src/touch/i2c.h Normal file
View file

@ -0,0 +1,109 @@
#ifndef GINT_TOUCH_I2C_H
#define GINT_TOUCH_I2C_H 1
#ifdef __cplusplus
extern "C" {
#endif
#include <gint/defs/attributes.h>
#include <gint/defs/types.h>
#include <gint/config.h>
#if GINT_HW_CP
//---
// User API
//---
/* i2c_reg_select() - select a register */
extern int i2c_reg_select(int reg);
/* i2c_reg_read() - register read operation */
extern int i2c_reg_read(int reg, void *buffer, size_t size);
/* i2c_read_stream() - "stream" read operation (skip reg selection) */
extern int i2c_read_stream(void *buffer, size_t size);
//---
// Internals
//---
/* i2c_request_mode - enumerate request mode */
enum i2c_request_mode {
I2C_REQ_MODE_REG_READ = 0,
I2C_REQ_MODE_REG_WRITE = 1,
I2C_REQ_MODE_REG_SELECT = 2,
I2C_REQ_MODE_READ_STREAM = 3,
};
/* i2c_request_status - request status */
enum i2c_request_status {
I2C_REQ_STATUS_START = 0,
I2C_REQ_STATUS_FINISHED = 1,
};
enum i2c_request_state {
I2C_REQ_STATE_START = 0,
I2C_REQ_STATE_REG_SELECT = 10,
I2C_REQ_STATE_REG_SELECT_WAIT = 11,
I2C_REQ_STATE_SWITCH_TO_RECEIVE = 20,
I2C_REQ_STATE_SWITCH_TO_RECEIVE_WAIT = 21,
I2C_REQ_STATE_READ = 30,
I2C_REQ_STATE_READ_LAST = 31,
I2C_REQ_STATE_ZOMBIE = 667,
I2C_REQ_STATE_DEAD = 2617,
};
/* struct i2c_request_info - internal I2C request information */
struct i2c_request_info {
enum i2c_request_mode mode;
int target_register;
uint8_t *buffer;
size_t buffer_size;
size_t buffer_size_remaning;
size_t buffer_cursor;
enum i2c_request_status status;
int state;
};
/* __i2c_request - internal current I2C request */
extern volatile struct i2c_request_info __i2c_request;
//---
// Hardware information
//---
#include <gint/drivers/states.h>
#include <gint/mpu/i2c.h>
/* i2c_configure() - driver/hardware configuration */
extern void i2c_configure(void);
/* i2c_hsave() - save hardware information */
extern void i2c_hsave(touch_state_t *states);
/* i2c_hrestore() - restore hardware information */
extern void i2c_hrestore(touch_state_t *states);
/* i2c_hpowered() - check if the module is powered */
extern bool i2c_hpowered(void);
/* i2c_hpoweron() - power on the module */
extern void i2c_hpoweron(void);
/* i2c_hpoweroff() - power off the module */
extern void i2c_hpoweroff(void);
/* i2c_funbind() - funbind from casio to gint */
extern void i2c_funbind(void);
/* i2c_unbind() - unbind from gint to casio */
extern void i2c_unbind(void);
#endif /* GINT_HW_CP */
#ifdef __cplusplus
}
#endif
#endif /* GINT_TOUCH_I2C_H */

171
src/touch/i2c_inth.c Normal file
View file

@ -0,0 +1,171 @@
//---
// gint:touch:i2c_inth - I2C interrupt handlers
//---
#include <gint/exc.h>
#include <gint/config.h>
#if GINT_HW_CP
#include "./i2c.h"
//---
// Private
//---
/* _i2c_inth_read() - generic read byte operation */
static int _i2c_inth_io_operation(bool read)
{
if (read) {
__i2c_request.buffer[
__i2c_request.buffer_cursor
] = SH7305_I2C.ICDR;
} else {
SH7305_I2C.ICDR = __i2c_request.buffer[
__i2c_request.buffer_cursor
];
}
__i2c_request.buffer_cursor += 1;
__i2c_request.buffer_size_remaning -= 1;
return __i2c_request.buffer_size_remaning;
}
/* _i2c_inth_stop() - stop I2C module (with force wait) */
static void _i2c_inth_stop(void)
{
while(true) {
if (SH7305_I2C.ICSR.BUSY == 0)
break;
SH7305_I2C.ICDR = SH7305_I2C.ICDR;
}
SH7305_I2C.ICIC.byte = 0x00;
SH7305_I2C.ICSR.byte = 0x00;
SH7305_I2C.ICCR.byte = 0x00;
__i2c_request.state = I2C_REQ_STATE_DEAD;
__i2c_request.status = I2C_REQ_STATUS_FINISHED;
}
//---
// Public
//---
/* i2c_inth_trans() - TRANS interrupt handler */
void i2c_inth_trans(void)
{
switch (__i2c_request.state)
{
// start byte (writing or reading) and select the proper mode
// note that the "read stream" just changes the internal state
// because the starting byte (0x81) is force-sent over there
case I2C_REQ_STATE_START:
SH7305_I2C.ICIC.DTEE = 0;
SH7305_I2C.ICIC.WAITE = 1;
if (__i2c_request.mode == I2C_REQ_MODE_READ_STREAM) {
SH7305_I2C.ICDR = 0x81;
__i2c_request.state = I2C_REQ_STATE_SWITCH_TO_RECEIVE_WAIT;
} else {
SH7305_I2C.ICDR = 0x80;
__i2c_request.state = I2C_REQ_STATE_REG_SELECT;
}
break;
// switch the I2C module to receive mode and setup the next state
// use WAIT interrupt to really switch the I2C to receive
case I2C_REQ_STATE_SWITCH_TO_RECEIVE:
SH7305_I2C.ICIC.DTEE = 0;
SH7305_I2C.ICDR = 0x81;
__i2c_request.state = I2C_REQ_STATE_SWITCH_TO_RECEIVE_WAIT;
break;
// for the read operation, the only thing to do is to send the
// ACK at the end of the operation
case I2C_REQ_STATE_READ:
SH7305_I2C.ICIC.DTEE = 0;
if (_i2c_inth_io_operation(true) == 0)
_i2c_inth_stop();
break;
// error, unsupported sequences display tests/debug information
default:
gint_panic(0x10e0);
}
}
/* i2c_inth_wait() - WAIT interrupt handler */
void i2c_inth_wait(void)
{
switch (__i2c_request.state)
{
// indicate which register to perform the operation
// we will wait the next WAIT interrupt to ensure that the data has
// been sent
case I2C_REQ_STATE_REG_SELECT:
SH7305_I2C.ICDR = __i2c_request.target_register;
__i2c_request.state = I2C_REQ_STATE_REG_SELECT_WAIT;
SH7305_I2C.ICSR.WAIT = 0;
break;
// the selected register is confirmed, stop or restart
// note that if the "select register" request is performed (or if
// no buffer is provided) then we send the stop condition (0x90)
// and force-stop the module.
// Otherwise, we trigger a new request (0x94) to (after
// the restart interruption) switch manually from "reading" or
// "writing" mode
case I2C_REQ_STATE_REG_SELECT_WAIT:
if (
__i2c_request.mode == I2C_REQ_MODE_REG_SELECT
|| __i2c_request.buffer_size_remaning == 0
|| __i2c_request.buffer == NULL
) {
SH7305_I2C.ICCR.byte = 0x90;
SH7305_I2C.ICSR.WAIT = 0;
_i2c_inth_stop();
} else {
SH7305_I2C.ICCR.byte = 0x94;
__i2c_request.state = I2C_REQ_STATE_SWITCH_TO_RECEIVE;
SH7305_I2C.ICIC.DTEE = 1;
SH7305_I2C.ICSR.WAIT = 0;
}
break;
// switch to receive mode
// waiting the next WAIT interrupt to start reading
case I2C_REQ_STATE_SWITCH_TO_RECEIVE_WAIT:
SH7305_I2C.ICCR.byte = 0x81;
__i2c_request.state = I2C_REQ_STATE_READ;
SH7305_I2C.ICSR.WAIT = 0;
break;
// read operation
// can either be WAIT or DTE interrupt, a special case is
// performed to avoid DTE interrupt
case I2C_REQ_STATE_READ:
if (__i2c_request.buffer_size_remaning > 1) {
if (SH7305_I2C.ICSR.DTE != 0)
_i2c_inth_io_operation(true);
}
if (__i2c_request.buffer_size_remaning == 1)
SH7305_I2C.ICCR.byte = 0xc0;
SH7305_I2C.ICIC.DTEE = 1;
SH7305_I2C.ICSR.WAIT = 0;
break;
// error cases, unable to handle the WAIT interrupt
default:
gint_panic(0x10e0);
}
}
/* i2c_inth_tack() - TACK interrupt handler */
void i2c_inth_tack(void)
{
gint_panic(0x10e0);
}
/* i2c_inth_al() - AL interrupt handler */
void i2c_inth_al(void)
{
gint_panic(0x10e0);
}
#endif /* GINT_HW_CP */

95
src/touch/touch.c Normal file
View file

@ -0,0 +1,95 @@
//---
// gint:touch - touch driver (high-level)
//----
#include <string.h>
#include <gint/touch.h>
#include <gint/cpu.h>
#include <gint/config.h>
#if GINT_HW_CP
#include "./i2c.h"
#include "./adconv.h"
#include "./driver.h"
//---
// Internals
//---
/* __touch_drv_info - internal driver information */
extern struct _touch_drv_info __touch_drv_info;
//---
// Public
//---
// user-API
/* touch_calib_get() - get calibration information */
int touch_calib_get(touch_calibration_t *calib)
{
if (calib == NULL)
return -1;
memcpy(calib, &__touch_drv_info.calibration, sizeof(*calib));
return 0;
}
/* touch_calib_set() - set calibration information */
int touch_calib_set(touch_calibration_t *calib)
{
if (calib == NULL)
return -1;
memcpy(&__touch_drv_info.calibration, calib, sizeof(*calib));
return 0;
}
// low-level API
/* touch_next_event() - get the next touch event */
key_event_t touch_next_event(void)
{
struct _touch_adconv adconv;
struct _touch_addots addots;
struct _touch_adraw adraw;
key_event_t evt;
int type;
evt.type = KEYEV_TOUCH_RELEASE;
type = touch_adconv_get_raw(&adraw);
if (type != 0)
{
type = touch_adconv_get_conv(&adconv, &adraw, type);
type = touch_adconv_get_dots(&addots, &adconv, type);
if (type == 1)
{
evt.type = KEYEV_TOUCH_DRAG;
evt.x = addots.x1;
evt.y = addots.y1;
}
}
cpu_atomic_start();
if (evt.type == KEYEV_TOUCH_DRAG) {
if (
(__touch_drv_info.prev_evt.type == KEYEV_NONE) ||
(__touch_drv_info.prev_evt.type == KEYEV_TOUCH_RELEASE)
) {
evt.type = KEYEV_TOUCH_PRESSED;
}
}
if (evt.type == KEYEV_TOUCH_RELEASE) {
if (
(__touch_drv_info.prev_evt.type == KEYEV_NONE) ||
(__touch_drv_info.prev_evt.type == KEYEV_TOUCH_RELEASE)
) {
evt.type = KEYEV_NONE;
}
}
__touch_drv_info.prev_evt.type = evt.type;
__touch_drv_info.prev_evt.x = evt.x;
__touch_drv_info.prev_evt.y = evt.y;
cpu_atomic_end();
return evt;
}
#endif /* GINT_HW_CP */

112
src/usb/setup.c
View file

@ -33,7 +33,9 @@ static usb_dc_device_t dc_device = {
.bMaxPacketSize0 = 64, .bMaxPacketSize0 = 64,
.idVendor = htole16(0x07cf), /* Casio Computer Co., Ltd. */ .idVendor = htole16(0x07cf), /* Casio Computer Co., Ltd. */
.idProduct = htole16(ID_PRODUCT), .idProduct = htole16(ID_PRODUCT),
.bcdDevice = htole16(0x0100), /* CASIO sets bcdDevice to 0x0100. Use a different value so that Windows
won't rely on cached registry entries and check for WCID support. */
.bcdDevice = htole16(0x0177),
.iManufacturer = 0, .iManufacturer = 0,
.iProduct = 0, .iProduct = 0,
.iSerialNumber = 0, .iSerialNumber = 0,
@ -55,6 +57,65 @@ static usb_dc_string_t dc_string0 = {
.data = { htole16(0x0409) }, /* English (US) */ .data = { htole16(0x0409) }, /* English (US) */
}; };
struct MOS1_String_0xEE_Descriptor {
usb_dc_string_t dc;
u16 signature[7];
u8 bMS_VendorCode;
u8 bPad;
};
static struct MOS1_String_0xEE_Descriptor dc_string_ee = {
.dc = { .bLength = 18, .bDescriptorType = USB_DC_STRING },
.signature = { 0x4D00, 0x5300, 0x4600, 0x5400, 0x3100, 0x3000, 0x3000 },
.bMS_VendorCode = 0x7b, /* Arbitrarily-chosen value */
.bPad = 0,
};
struct MOS1_Extended_Compat_ID_Function_Section {
u8 bFirstInterfaceNumber;
u8 bReserved1;
u8 compatibleID[8];
u8 subcompatibleID[8];
u8 bReserved2[6];
};
struct MOS1_Extended_Compat_ID_Descriptor {
// 16 byte header
u32 dwLength;
u16 bcdVersion;
u16 wIndex;
u8 bCount;
u8 bReserved[7];
// hardcoded to size 1 for convenience here
struct MOS1_Extended_Compat_ID_Function_Section f;
};
static struct MOS1_Extended_Compat_ID_Descriptor dc_compatid = {
.dwLength = htole32(0x10 + 24 * 1),
.bcdVersion = htole16(0x0100),
.wIndex = htole16(0x0004),
.bCount = 1,
.f = {
.bFirstInterfaceNumber = 0,
.bReserved1 = 0x01,
.compatibleID = { 0x57, 0x49, 0x4e, 0x55, 0x53, 0x42, 0x00, 0x00 },
.subcompatibleID = { 0 },
.bReserved2 = { 0 },
},
};
struct MOS1_Extended_Properties_Descriptor {
// 10 byte header
u32 dwLength;
u16 bcdVersion;
u16 wIndex;
u16 wCount;
};
static struct MOS1_Extended_Properties_Descriptor dc_extprops = {
.dwLength = htole32(10),
.bcdVersion = htole16(0x0100),
.wIndex = htole16(0x0005),
.wCount = htole16(0),
};
GCONSTRUCTOR static void set_strings(void) GCONSTRUCTOR static void set_strings(void)
{ {
char const *serial_base = char const *serial_base =
@ -139,12 +200,40 @@ static void req_get_descriptor(int wValue, int wLength)
else if(type == USB_DC_STRING) else if(type == USB_DC_STRING)
{ {
usb_dc_string_t *dc = usb_dc_string_get(num); usb_dc_string_t *dc;
if(num == 0xee) {
dc = &dc_string_ee.dc;
USB_LOG("Selecting MOS1 string descriptor\n");
}
else
dc = usb_dc_string_get(num);
if(dc) dcp_write(dc, dc->bLength); if(dc) dcp_write(dc, dc->bLength);
else USB.DCPCTR.PID = 2; else USB.DCPCTR.PID = 2;
} }
} }
static void req_get_MOS_feature_descriptor(int wValue, int wIndex, int wLength)
{
int intf = (wValue >> 8) & 0xff;
int page = (wValue & 0xff);
USB_LOG("GET_MS_DESCRIPTOR: i%d p%d #%d len:%d\n", intf, page, wIndex, wLength);
if(wIndex == 0x0004) {
/* Extended Compat ID descriptor */
dcp_write(&dc_compatid, wLength);
USB_LOG("Compat ID descriptor given\n");
}
else if(wIndex == 0x0005) {
/* Extended Properties descriptor */
dcp_write(&dc_extprops, wLength);
USB_LOG("Extended properties descriptor given\n");
}
else {
USB_LOG("Unknown MS descriptor!\n");
}
}
static void req_get_configuration(void) static void req_get_configuration(void)
{ {
USB_LOG("GET_CONFIGURATION -> %d\n", 1); USB_LOG("GET_CONFIGURATION -> %d\n", 1);
@ -158,6 +247,12 @@ static void req_set_configuration(int wValue)
USB.DCPCTR.PID = (wValue == 1) ? 1 : 2; USB.DCPCTR.PID = (wValue == 1) ? 1 : 2;
} }
static void req_get_device_status(void)
{
USB_LOG("GET_STATUS device -> 0x0001\n");
dcp_write("\x01\x00", 2);
}
void usb_req_setup(void) void usb_req_setup(void)
{ {
/* Respond to setup requests */ /* Respond to setup requests */
@ -181,6 +276,19 @@ void usb_req_setup(void)
else if(bmRequestType == 0x00 && bRequest == SET_CONFIGURATION) else if(bmRequestType == 0x00 && bRequest == SET_CONFIGURATION)
req_set_configuration(wValue); req_set_configuration(wValue);
else if(bmRequestType == 0x80 && bRequest == GET_STATUS)
req_get_device_status();
// 0x81 / GET_STATUS : get intf status
// 0x82 / GET_STATUS : get endpoint status
// CESG502 initial 0x01 comm
// else if(bmRequestType == 0x41 && bRequest == 0x01)
// USB.DCPCTR.PID = 1;
else if((bmRequestType == 0xc0 || bmRequestType == 0xc1)
&& bRequest == 0x7b)
req_get_MOS_feature_descriptor(wValue, wIndex, wLength);
/* TODO: Other standard SETUP requests */ /* TODO: Other standard SETUP requests */
else USB_LOG("SETUP: bRequest=%02x bmRequestType=%02x wValue=%04x\n" else USB_LOG("SETUP: bRequest=%02x bmRequestType=%02x wValue=%04x\n"
" wIndex=%04x wLength=%d -> ???\n", " wIndex=%04x wLength=%d -> ???\n",