Macintosh-Tools
/
macemu
mirror of https://github.com/kanjitalk755/macemu.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Try to fix build error on SheepShaver XCode Project

This commit is contained in:
jvernet 2017-10-09 22:19:16 +02:00
parent e6808d6556
commit b904304e89
2 changed files with 861 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

401
SheepShaver/src/Unix/timer_unix.cpp Normal file
View File

@ -0,0 +1,401 @@
/*
* timer_unix.cpp - Time Manager emulation, Unix specific stuff
*
* Basilisk II (C) 1997-2008 Christian Bauer
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "sysdeps.h"
#include "macos_util.h"
#include "timer.h"
#include <errno.h>
#define DEBUG 0
#include "debug.h"
// For NetBSD with broken pthreads headers
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 0
#endif
#if defined(__MACH__)
#include <mach/mach.h>
#include <mach/clock.h>
static clock_serv_t host_clock;
static bool host_clock_inited = false;
static inline void mach_current_time(tm_time_t &t) {
if(!host_clock_inited) {
host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &host_clock);
host_clock_inited = true;
}
clock_get_time(host_clock, (mach_timespec_t *)&t);
}
#endif
/*
* Return microseconds since boot (64 bit)
*/
void Microseconds(uint32 &hi, uint32 &lo)
{
D(bug("Microseconds\n"));
#if defined(__MACH__)
tm_time_t t;
mach_current_time(t);
uint64 tl = (uint64)t.tv_sec * 1000000 + t.tv_nsec / 1000;
#elif defined(HAVE_CLOCK_GETTIME)
struct timespec t;
clock_gettime(CLOCK_REALTIME, &t);
uint64 tl = (uint64)t.tv_sec * 1000000 + t.tv_nsec / 1000;
#else
struct timeval t;
gettimeofday(&t, NULL);
uint64 tl = (uint64)t.tv_sec * 1000000 + t.tv_usec;
#endif
hi = tl >> 32;
lo = tl;
}
/*
* Return local date/time in Mac format (seconds since 1.1.1904)
*/
uint32 TimerDateTime(void)
{
return TimeToMacTime(time(NULL));
}
/*
* Get current time
*/
void timer_current_time(tm_time_t &t)
{
#if defined(__MACH__)
mach_current_time(t);
#elif defined(HAVE_CLOCK_GETTIME)
clock_gettime(CLOCK_REALTIME, &t);
#else
gettimeofday(&t, NULL);
#endif
}
/*
* Add times
*/
void timer_add_time(tm_time_t &res, tm_time_t a, tm_time_t b)
{
#if defined(HAVE_CLOCK_GETTIME) || defined(__MACH__)
res.tv_sec = a.tv_sec + b.tv_sec;
res.tv_nsec = a.tv_nsec + b.tv_nsec;
if (res.tv_nsec >= 1000000000) {
res.tv_sec++;
res.tv_nsec -= 1000000000;
}
#else
res.tv_sec = a.tv_sec + b.tv_sec;
res.tv_usec = a.tv_usec + b.tv_usec;
if (res.tv_usec >= 1000000) {
res.tv_sec++;
res.tv_usec -= 1000000;
}
#endif
}
/*
* Subtract times
*/
void timer_sub_time(tm_time_t &res, tm_time_t a, tm_time_t b)
{
#if defined(HAVE_CLOCK_GETTIME) || defined(__MACH__)
res.tv_sec = a.tv_sec - b.tv_sec;
res.tv_nsec = a.tv_nsec - b.tv_nsec;
if (res.tv_nsec < 0) {
res.tv_sec--;
res.tv_nsec += 1000000000;
}
#else
res.tv_sec = a.tv_sec - b.tv_sec;
res.tv_usec = a.tv_usec - b.tv_usec;
if (res.tv_usec < 0) {
res.tv_sec--;
res.tv_usec += 1000000;
}
#endif
}
/*
* Compare times (<0: a < b, =0: a = b, >0: a > b)
*/
int timer_cmp_time(tm_time_t a, tm_time_t b)
{
#if defined(HAVE_CLOCK_GETTIME) || defined(__MACH__)
if (a.tv_sec == b.tv_sec)
return a.tv_nsec - b.tv_nsec;
else
return a.tv_sec - b.tv_sec;
#else
if (a.tv_sec == b.tv_sec)
return a.tv_usec - b.tv_usec;
else
return a.tv_sec - b.tv_sec;
#endif
}
/*
* Convert Mac time value (>0: microseconds, <0: microseconds) to tm_time_t
*/
void timer_mac2host_time(tm_time_t &res, int32 mactime)
{
#if defined(HAVE_CLOCK_GETTIME) || defined(__MACH__)
if (mactime > 0) {
// Time in milliseconds
res.tv_sec = mactime / 1000;
res.tv_nsec = (mactime % 1000) * 1000000;
} else {
// Time in negative microseconds
res.tv_sec = -mactime / 1000000;
res.tv_nsec = (-mactime % 1000000) * 1000;
}
#else
if (mactime > 0) {
// Time in milliseconds
res.tv_sec = mactime / 1000;
res.tv_usec = (mactime % 1000) * 1000;
} else {
// Time in negative microseconds
res.tv_sec = -mactime / 1000000;
res.tv_usec = -mactime % 1000000;
}
#endif
}
/*
* Convert positive tm_time_t to Mac time value (>0: microseconds, <0: microseconds)
* A negative input value for hosttime results in a zero return value
* As long as the microseconds value fits in 32 bit, it must not be converted to milliseconds!
*/
int32 timer_host2mac_time(tm_time_t hosttime)
{
if (hosttime.tv_sec < 0)
return 0;
else {
#if defined(HAVE_CLOCK_GETTIME) || defined(__MACH__)
uint64 t = (uint64)hosttime.tv_sec * 1000000 + hosttime.tv_nsec / 1000;
#else
uint64 t = (uint64)hosttime.tv_sec * 1000000 + hosttime.tv_usec;
#endif
if (t > 0x7fffffff)
return t / 1000; // Time in milliseconds
else
return -t; // Time in negative microseconds
}
}
/*
* Get current value of microsecond timer
*/
uint64 GetTicks_usec(void)
{
#if defined(__MACH__)
tm_time_t t;
mach_current_time(t);
return (uint64)t.tv_sec * 1000000 + t.tv_nsec / 1000;
#elif defined(HAVE_CLOCK_GETTIME)
struct timespec t;
clock_gettime(CLOCK_REALTIME, &t);
return (uint64)t.tv_sec * 1000000 + t.tv_nsec / 1000;
#else
struct timeval t;
gettimeofday(&t, NULL);
return (uint64)t.tv_sec * 1000000 + t.tv_usec;
#endif
}
/*
* Delay by specified number of microseconds (<1 second)
* (adapted from SDL_Delay() source; this function is designed to provide
* the highest accuracy possible)
*/
#if defined(linux)
// Linux select() changes its timeout parameter upon return to contain
// the remaining time. Most other unixen leave it unchanged or undefined.
#define SELECT_SETS_REMAINING
#elif defined(__FreeBSD__) || defined(__sun__) || (defined(__MACH__) && defined(__APPLE__))
#define USE_NANOSLEEP
#elif defined(HAVE_PTHREADS) && defined(sgi)
// SGI pthreads has a bug when using pthreads+signals+nanosleep,
// so instead of using nanosleep, wait on a CV which is never signalled.
#include <pthread.h>
#define USE_COND_TIMEDWAIT
#endif
void Delay_usec(uint64 usec)
{
int was_error;
#if defined(USE_NANOSLEEP)
struct timespec elapsed, tv;
#elif defined(USE_COND_TIMEDWAIT)
// Use a local mutex and cv, so threads remain independent
pthread_cond_t delay_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t delay_mutex = PTHREAD_MUTEX_INITIALIZER;
struct timespec elapsed;
uint64 future;
#else
struct timeval tv;
#ifndef SELECT_SETS_REMAINING
uint64 then, now, elapsed;
#endif
#endif
// Set the timeout interval - Linux only needs to do this once
#if defined(SELECT_SETS_REMAINING)
tv.tv_sec = 0;
tv.tv_usec = usec;
#elif defined(USE_NANOSLEEP)
elapsed.tv_sec = 0;
elapsed.tv_nsec = usec * 1000;
#elif defined(USE_COND_TIMEDWAIT)
future = GetTicks_usec() + usec;
elapsed.tv_sec = future / 1000000;
elapsed.tv_nsec = (future % 1000000) * 1000;
#else
then = GetTicks_usec();
#endif
do {
errno = 0;
#if defined(USE_NANOSLEEP)
tv.tv_sec = elapsed.tv_sec;
tv.tv_nsec = elapsed.tv_nsec;
was_error = nanosleep(&tv, &elapsed);
#elif defined(USE_COND_TIMEDWAIT)
was_error = pthread_mutex_lock(&delay_mutex);
was_error = pthread_cond_timedwait(&delay_cond, &delay_mutex, &elapsed);
was_error = pthread_mutex_unlock(&delay_mutex);
#else
#ifndef SELECT_SETS_REMAINING
// Calculate the time interval left (in case of interrupt)
now = GetTicks_usec();
elapsed = now - then;
then = now;
if (elapsed >= usec)
break;
usec -= elapsed;
tv.tv_sec = 0;
tv.tv_usec = usec;
#endif
was_error = select(0, NULL, NULL, NULL, &tv);
#endif
} while (was_error && (errno == EINTR));
}
/*
* Suspend emulator thread, virtual CPU in idle mode
*/
#ifdef HAVE_PTHREADS
#if defined(HAVE_PTHREAD_COND_INIT)
#define IDLE_USES_COND_WAIT 1
static pthread_mutex_t idle_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t idle_cond = PTHREAD_COND_INITIALIZER;
#elif defined(HAVE_SEM_INIT)
#define IDLE_USES_SEMAPHORE 1
#include <semaphore.h>
#ifdef HAVE_SPINLOCKS
static spinlock_t idle_lock = SPIN_LOCK_UNLOCKED;
#define LOCK_IDLE spin_lock(&idle_lock)
#define UNLOCK_IDLE spin_unlock(&idle_lock)
#else
static pthread_mutex_t idle_lock = PTHREAD_MUTEX_INITIALIZER;
#define LOCK_IDLE pthread_mutex_lock(&idle_lock)
#define UNLOCK_IDLE pthread_mutex_unlock(&idle_lock)
#endif
static sem_t idle_sem;
static int idle_sem_ok = -1;
#endif
#endif
void idle_wait(void)
{
#ifdef IDLE_USES_COND_WAIT
pthread_mutex_lock(&idle_lock);
pthread_cond_wait(&idle_cond, &idle_lock);
pthread_mutex_unlock(&idle_lock);
#else
#ifdef IDLE_USES_SEMAPHORE
LOCK_IDLE;
if (idle_sem_ok < 0)
idle_sem_ok = (sem_init(&idle_sem, 0, 0) == 0);
if (idle_sem_ok > 0) {
idle_sem_ok++;
UNLOCK_IDLE;
sem_wait(&idle_sem);
return;
}
UNLOCK_IDLE;
#endif
// Fallback: sleep 10 ms
Delay_usec(10000);
#endif
}
/*
* Resume execution of emulator thread, events just arrived
*/
void idle_resume(void)
{
#ifdef IDLE_USES_COND_WAIT
pthread_cond_signal(&idle_cond);
#else
#ifdef IDLE_USES_SEMAPHORE
LOCK_IDLE;
if (idle_sem_ok > 1) {
idle_sem_ok--;
UNLOCK_IDLE;
sem_post(&idle_sem);
return;
}
UNLOCK_IDLE;
#endif
#endif
}

460
SheepShaver/src/adb.cpp Normal file
View File

@ -0,0 +1,460 @@
/*
* adb.cpp - ADB emulation (mouse/keyboard)
*
* Basilisk II (C) Christian Bauer
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* SEE ALSO
* Inside Macintosh: Devices, chapter 5 "ADB Manager"
* Technote HW 01: "ADB - The Untold Story: Space Aliens Ate My Mouse"
*/
#include <stdlib.h>
#include "sysdeps.h"
#include "cpu_emulation.h"
#include "emul_op.h"
#include "main.h"
#include "prefs.h"
#include "video.h"
#include "adb.h"
#ifdef POWERPC_ROM
#include "thunks.h"
#endif
#define DEBUG 0
#include "debug.h"
// Global variables
static int mouse_x = 0, mouse_y = 0; // Mouse position
static int old_mouse_x = 0, old_mouse_y = 0;
static bool mouse_button[3] = {false, false, false}; // Mouse button states
static bool old_mouse_button[3] = {false, false, false};
static bool relative_mouse = false;
static uint8 key_states[16]; // Key states (Mac keycodes)
#define MATRIX(code) (key_states[code >> 3] & (1 << (~code & 7)))
// Keyboard event buffer (Mac keycodes with up/down flag)
const int KEY_BUFFER_SIZE = 16;
static uint8 key_buffer[KEY_BUFFER_SIZE];
static unsigned int key_read_ptr = 0, key_write_ptr = 0;
static uint8 mouse_reg_3[2] = {0x63, 0x01}; // Mouse ADB register 3
static uint8 key_reg_2[2] = {0xff, 0xff}; // Keyboard ADB register 2
static uint8 key_reg_3[2] = {0x62, 0x05}; // Keyboard ADB register 3
static uint8 m_keyboard_type = 0x05;
// ADB mouse motion lock (for platforms that use separate input thread)
static B2_mutex *mouse_lock;
/*
* Initialize ADB emulation
*/
void ADBInit(void)
{
mouse_lock = B2_create_mutex();
m_keyboard_type = (uint8)PrefsFindInt32("keyboardtype");
key_reg_3[1] = m_keyboard_type;
}
/*
* Exit ADB emulation
*/
void ADBExit(void)
{
if (mouse_lock) {
B2_delete_mutex(mouse_lock);
mouse_lock = NULL;
}
}
/*
* ADBOp() replacement
*/
void ADBOp(uint8 op, uint8 *data)
{
D(bug("ADBOp op %02x, data %02x %02x %02x\n", op, data[0], data[1], data[2]));
// ADB reset?
if ((op & 0x0f) == 0) {
mouse_reg_3[0] = 0x63;
mouse_reg_3[1] = 0x01;
key_reg_2[0] = 0xff;
key_reg_2[1] = 0xff;
key_reg_3[0] = 0x62;
key_reg_3[1] = m_keyboard_type;
return;
}
// Cut op into fields
uint8 adr = op >> 4;
uint8 cmd = (op >> 2) & 3;
uint8 reg = op & 3;
// Check which device was addressed and act accordingly
if (adr == (mouse_reg_3[0] & 0x0f)) {
// Mouse
if (cmd == 2) {
// Listen
switch (reg) {
case 3: // Address/HandlerID
if (data[2] == 0xfe) // Change address
mouse_reg_3[0] = (mouse_reg_3[0] & 0xf0) | (data[1] & 0x0f);
else if (data[2] == 1 || data[2] == 2 || data[2] == 4) // Change device handler ID
mouse_reg_3[1] = data[2];
else if (data[2] == 0x00) // Change address and enable bit
mouse_reg_3[0] = (mouse_reg_3[0] & 0xd0) | (data[1] & 0x2f);
break;
}
} else if (cmd == 3) {
// Talk
switch (reg) {
case 1: // Extended mouse protocol
data[0] = 8;
data[1] = 'a'; // Identifier
data[2] = 'p';
data[3] = 'p';
data[4] = 'l';
data[5] = 300 >> 8; // Resolution (dpi)
data[6] = 300 & 0xff;
data[7] = 1; // Class (mouse)
data[8] = 3; // Number of buttons
break;
case 3: // Address/HandlerID
data[0] = 2;
data[1] = (mouse_reg_3[0] & 0xf0) | (rand() & 0x0f);
data[2] = mouse_reg_3[1];
break;
default:
data[0] = 0;
break;
}
}
D(bug(" mouse reg 3 %02x%02x\n", mouse_reg_3[0], mouse_reg_3[1]));
} else if (adr == (key_reg_3[0] & 0x0f)) {
// Keyboard
if (cmd == 2) {
// Listen
switch (reg) {
case 2: // LEDs/Modifiers
key_reg_2[0] = data[1];
key_reg_2[1] = data[2];
break;
case 3: // Address/HandlerID
if (data[2] == 0xfe) // Change address
key_reg_3[0] = (key_reg_3[0] & 0xf0) | (data[1] & 0x0f);
else if (data[2] == 0x00) // Change address and enable bit
key_reg_3[0] = (key_reg_3[0] & 0xd0) | (data[1] & 0x2f);
break;
}
} else if (cmd == 3) {
// Talk
switch (reg) {
case 2: { // LEDs/Modifiers
uint8 reg2hi = 0xff;
uint8 reg2lo = key_reg_2[1] | 0xf8;
if (MATRIX(0x6b)) // Scroll Lock
reg2lo &= ~0x40;
if (MATRIX(0x47)) // Num Lock
reg2lo &= ~0x80;
if (MATRIX(0x37)) // Command
reg2hi &= ~0x01;
if (MATRIX(0x3a)) // Option
reg2hi &= ~0x02;
if (MATRIX(0x38)) // Shift
reg2hi &= ~0x04;
if (MATRIX(0x36)) // Control
reg2hi &= ~0x08;
if (MATRIX(0x39)) // Caps Lock
reg2hi &= ~0x20;
if (MATRIX(0x75)) // Delete
reg2hi &= ~0x40;
data[0] = 2;
data[1] = reg2hi;
data[2] = reg2lo;
break;
}
case 3: // Address/HandlerID
data[0] = 2;
data[1] = (key_reg_3[0] & 0xf0) | (rand() & 0x0f);
data[2] = key_reg_3[1];
break;
default:
data[0] = 0;
break;
}
}
D(bug(" keyboard reg 3 %02x%02x\n", key_reg_3[0], key_reg_3[1]));
} else // Unknown address
if (cmd == 3)
data[0] = 0; // Talk: 0 bytes of data
}
/*
* Mouse was moved (x/y are absolute or relative, depending on ADBSetRelMouseMode())
*/
void ADBMouseMoved(int x, int y)
{
B2_lock_mutex(mouse_lock);
if (relative_mouse) {
mouse_x += x; mouse_y += y;
} else {
mouse_x = x; mouse_y = y;
}
B2_unlock_mutex(mouse_lock);
SetInterruptFlag(INTFLAG_ADB);
TriggerInterrupt();
}
/*
* Mouse button pressed
*/
void ADBMouseDown(int button)
{
mouse_button[button] = true;
SetInterruptFlag(INTFLAG_ADB);
TriggerInterrupt();
}
/*
* Mouse button released
*/
void ADBMouseUp(int button)
{
mouse_button[button] = false;
SetInterruptFlag(INTFLAG_ADB);
TriggerInterrupt();
}
/*
* Set mouse mode (absolute or relative)
*/
void ADBSetRelMouseMode(bool relative)
{
if (relative_mouse != relative) {
relative_mouse = relative;
mouse_x = mouse_y = 0;
}
}
/*
* Key pressed ("code" is the Mac key code)
*/
void ADBKeyDown(int code)
{
// Add keycode to buffer
key_buffer[key_write_ptr] = code;
key_write_ptr = (key_write_ptr + 1) % KEY_BUFFER_SIZE;
// Set key in matrix
key_states[code >> 3] |= (1 << (~code & 7));
// Trigger interrupt
SetInterruptFlag(INTFLAG_ADB);
TriggerInterrupt();
}
/*
* Key released ("code" is the Mac key code)
*/
void ADBKeyUp(int code)
{
// Add keycode to buffer
key_buffer[key_write_ptr] = code | 0x80; // Key-up flag
key_write_ptr = (key_write_ptr + 1) % KEY_BUFFER_SIZE;
// Clear key in matrix
key_states[code >> 3] &= ~(1 << (~code & 7));
// Trigger interrupt
SetInterruptFlag(INTFLAG_ADB);
TriggerInterrupt();
}
/*
* ADB interrupt function (executed as part of 60Hz interrupt)
*/
void ADBInterrupt(void)
{
M68kRegisters r;
// Return if ADB is not initialized
uint32 adb_base = ReadMacInt32(0xcf8);
if (!adb_base || adb_base == 0xffffffff)
return;
uint32 tmp_data = adb_base + 0x163; // Temporary storage for faked ADB data
// Get mouse state
B2_lock_mutex(mouse_lock);
int mx = mouse_x;
int my = mouse_y;
if (relative_mouse)
mouse_x = mouse_y = 0;
bool mb[3] = {mouse_button[0], mouse_button[1], mouse_button[2]};
B2_unlock_mutex(mouse_lock);
uint32 key_base = adb_base + 4;
uint32 mouse_base = adb_base + 16;
if (relative_mouse) {
// Mouse movement (relative) and buttons
if (mx != 0 || my != 0 || mb[0] != old_mouse_button[0] || mb[1] != old_mouse_button[1] || mb[2] != old_mouse_button[2]) {
// Call mouse ADB handler
if (mouse_reg_3[1] == 4) {
// Extended mouse protocol
WriteMacInt8(tmp_data, 3);
WriteMacInt8(tmp_data + 1, (my & 0x7f) | (mb[0] ? 0 : 0x80));
WriteMacInt8(tmp_data + 2, (mx & 0x7f) | (mb[1] ? 0 : 0x80));
WriteMacInt8(tmp_data + 3, ((my >> 3) & 0x70) | ((mx >> 7) & 0x07) | (mb[2] ? 0x08 : 0x88));
} else {
// 100/200 dpi mode
WriteMacInt8(tmp_data, 2);
WriteMacInt8(tmp_data + 1, (my & 0x7f) | (mb[0] ? 0 : 0x80));
WriteMacInt8(tmp_data + 2, (mx & 0x7f) | (mb[1] ? 0 : 0x80));
}
r.a[0] = tmp_data;
r.a[1] = ReadMacInt32(mouse_base);
r.a[2] = ReadMacInt32(mouse_base + 4);
r.a[3] = adb_base;
r.d[0] = (mouse_reg_3[0] << 4) | 0x0c; // Talk 0
Execute68k(r.a[1], &r);
old_mouse_button[0] = mb[0];
old_mouse_button[1] = mb[1];
old_mouse_button[2] = mb[2];
}
} else {
// Update mouse position (absolute)
if (mx != old_mouse_x || my != old_mouse_y) {
#ifdef POWERPC_ROM
static const uint8 proc_template[] = {
0x2f, 0x08, // move.l a0,-(sp)
0x2f, 0x00, // move.l d0,-(sp)
0x2f, 0x01, // move.l d1,-(sp)
0x70, 0x01, // moveq #1,d0 (MoveTo)
0xaa, 0xdb, // CursorDeviceDispatch
M68K_RTS >> 8, M68K_RTS & 0xff
};
BUILD_SHEEPSHAVER_PROCEDURE(proc);
r.a[0] = ReadMacInt32(mouse_base + 4);
r.d[0] = mx;
r.d[1] = my;
Execute68k(proc, &r);
#else
WriteMacInt16(0x82a, mx);
WriteMacInt16(0x828, my);
WriteMacInt16(0x82e, mx);
WriteMacInt16(0x82c, my);
WriteMacInt8(0x8ce, ReadMacInt8(0x8cf)); // CrsrCouple -> CrsrNew
#endif
old_mouse_x = mx;
old_mouse_y = my;
}
// Send mouse button events
if (mb[0] != old_mouse_button[0] || mb[1] != old_mouse_button[1] || mb[2] != old_mouse_button[2]) {
uint32 mouse_base = adb_base + 16;
// Call mouse ADB handler
if (mouse_reg_3[1] == 4) {
// Extended mouse protocol
WriteMacInt8(tmp_data, 3);
WriteMacInt8(tmp_data + 1, mb[0] ? 0 : 0x80);
WriteMacInt8(tmp_data + 2, mb[1] ? 0 : 0x80);
WriteMacInt8(tmp_data + 3, mb[2] ? 0x08 : 0x88);
} else {
// 100/200 dpi mode
WriteMacInt8(tmp_data, 2);
WriteMacInt8(tmp_data + 1, mb[0] ? 0 : 0x80);
WriteMacInt8(tmp_data + 2, mb[1] ? 0 : 0x80);
}
r.a[0] = tmp_data;
r.a[1] = ReadMacInt32(mouse_base);
r.a[2] = ReadMacInt32(mouse_base + 4);
r.a[3] = adb_base;
r.d[0] = (mouse_reg_3[0] << 4) | 0x0c; // Talk 0
Execute68k(r.a[1], &r);
old_mouse_button[0] = mb[0];
old_mouse_button[1] = mb[1];
old_mouse_button[2] = mb[2];
}
}
// Process accumulated keyboard events
while (key_read_ptr != key_write_ptr) {
// Read keyboard event
uint8 mac_code = key_buffer[key_read_ptr];
key_read_ptr = (key_read_ptr + 1) % KEY_BUFFER_SIZE;
// Call keyboard ADB handler
WriteMacInt8(tmp_data, 2);
WriteMacInt8(tmp_data + 1, mac_code);
WriteMacInt8(tmp_data + 2, mac_code == 0x7f ? 0x7f : 0xff); // Power key is special
r.a[0] = tmp_data;
r.a[1] = ReadMacInt32(key_base);
r.a[2] = ReadMacInt32(key_base + 4);
r.a[3] = adb_base;
r.d[0] = (key_reg_3[0] << 4) | 0x0c; // Talk 0
Execute68k(r.a[1], &r);
}
// Clear temporary data
WriteMacInt32(tmp_data, 0);
WriteMacInt32(tmp_data + 4, 0);
}