ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/adb.cpp

Comparing BasiliskII/src/adb.cpp (file contents):
Revision 1.1.1.1 by cebix, 1999-10-03T14:16:25Z vs.
Revision 1.17 by cebix, 2010-02-21T09:55:36Z

#	Line 1 | Line 1
1		/*
2		*  adb.cpp - ADB emulation (mouse/keyboard)
3		*
4	<	*  Basilisk II (C) 1997-1999 Christian Bauer
4	>	*  Basilisk II (C) Christian Bauer
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 28 | Line 28
28
29		#include "sysdeps.h"
30		#include "cpu_emulation.h"
31	+	#include "emul_op.h"
32		#include "main.h"
33	+	#include "prefs.h"
34		#include "video.h"
35		#include "adb.h"
36
37	+	#ifdef POWERPC_ROM
38	+	#include "thunks.h"
39	+	#endif
40	+
41		#define DEBUG 0
42		#include "debug.h"
43
#	Line 56 | Line 62 | static uint8 mouse_reg_3[2] = {0x63, 0x0
62		static uint8 key_reg_2[2] = {0xff, 0xff};       // Keyboard ADB register 2
63		static uint8 key_reg_3[2] = {0x62, 0x05};       // Keyboard ADB register 3
64
65	+	static uint8 m_keyboard_type = 0x05;
66	+
67	+	// ADB mouse motion lock (for platforms that use separate input thread)
68	+	static B2_mutex *mouse_lock;
69	+
70	+
71	+	/*
72	+	*  Initialize ADB emulation
73	+	*/
74	+
75	+	void ADBInit(void)
76	+	{
77	+	mouse_lock = B2_create_mutex();
78	+	m_keyboard_type = (uint8)PrefsFindInt32("keyboardtype");
79	+	key_reg_3[1] = m_keyboard_type;
80	+	}
81	+
82	+
83	+	/*
84	+	*  Exit ADB emulation
85	+	*/
86	+
87	+	void ADBExit(void)
88	+	{
89	+	if (mouse_lock) {
90	+	B2_delete_mutex(mouse_lock);
91	+	mouse_lock = NULL;
92	+	}
93	+	}
94	+
95
96		/*
97		*  ADBOp() replacement
#	Line 72 | Line 108 | void ADBOp(uint8 op, uint8 *data)
108		key_reg_2[0] = 0xff;
109		key_reg_2[1] = 0xff;
110		key_reg_3[0] = 0x62;
111	<	key_reg_3[1] = 0x05;
111	>	key_reg_3[1] = m_keyboard_type;
112		return;
113		}
114
#	Line 192 | Line 228 | void ADBOp(uint8 op, uint8 *data)
228
229
230		/*
231	<	*  Mouse was moved (x/y are absolute or relative, depending on ADBSetMouseMode())
231	>	*  Mouse was moved (x/y are absolute or relative, depending on ADBSetRelMouseMode())
232		*/
233
234		void ADBMouseMoved(int x, int y)
235		{
236	+	B2_lock_mutex(mouse_lock);
237		if (relative_mouse) {
238		mouse_x += x; mouse_y += y;
239		} else {
240		mouse_x = x; mouse_y = y;
241		}
242	+	B2_unlock_mutex(mouse_lock);
243	+	SetInterruptFlag(INTFLAG_ADB);
244	+	TriggerInterrupt();
245		}
246
247
#	Line 212 | Line 252 | void ADBMouseMoved(int x, int y)
252		void ADBMouseDown(int button)
253		{
254		mouse_button[button] = true;
255	+	SetInterruptFlag(INTFLAG_ADB);
256	+	TriggerInterrupt();
257		}
258
259
260		/*
261	<	*  First mouse button released
261	>	*  Mouse button released
262		*/
263
264		void ADBMouseUp(int button)
265		{
266		mouse_button[button] = false;
267	+	SetInterruptFlag(INTFLAG_ADB);
268	+	TriggerInterrupt();
269		}
270
271
#	Line 231 | Line 275 | void ADBMouseUp(int button)
275
276		void ADBSetRelMouseMode(bool relative)
277		{
278	<	relative_mouse = relative;
278	>	if (relative_mouse != relative) {
279	>	relative_mouse = relative;
280	>	mouse_x = mouse_y = 0;
281	>	}
282		}
283
284
#	Line 247 | Line 294 | void ADBKeyDown(int code)
294
295		// Set key in matrix
296		key_states[code >> 3] |= (1 << (~code & 7));
297	+
298	+	// Trigger interrupt
299	+	SetInterruptFlag(INTFLAG_ADB);
300	+	TriggerInterrupt();
301		}
302
303
#	Line 262 | Line 313 | void ADBKeyUp(int code)
313
314		// Clear key in matrix
315		key_states[code >> 3] &= ~(1 << (~code & 7));
316	+
317	+	// Trigger interrupt
318	+	SetInterruptFlag(INTFLAG_ADB);
319	+	TriggerInterrupt();
320		}
321
322
#	Line 279 | Line 334 | void ADBInterrupt(void)
334		return;
335		uint32 tmp_data = adb_base + 0x163;     // Temporary storage for faked ADB data
336
337	<	// Get position so that it won't change during processing
337	>	// Get mouse state
338	>	B2_lock_mutex(mouse_lock);
339		int mx = mouse_x;
340		int my = mouse_y;
341	+	if (relative_mouse)
342	+	mouse_x = mouse_y = 0;
343	+	int mb[3] = {mouse_button[0], mouse_button[1], mouse_button[2]};
344	+	B2_unlock_mutex(mouse_lock);
345	+
346	+	uint32 key_base = adb_base + 4;
347	+	uint32 mouse_base = adb_base + 16;
348
349		if (relative_mouse) {
350
351		// Mouse movement (relative) and buttons
352	<	if (mx != 0 || my != 0 || mouse_button[0] != old_mouse_button[0] || mouse_button[1] != old_mouse_button[1] || mouse_button[2] != old_mouse_button[2]) {
290	<	uint32 mouse_base = adb_base + 16;
291	<	uint8 *mouse_data = Mac2HostAddr(tmp_data);
352	>	if (mx != 0 || my != 0 || mb[0] != old_mouse_button[0] || mb[1] != old_mouse_button[1] || mb[2] != old_mouse_button[2]) {
353
354		// Call mouse ADB handler
355		if (mouse_reg_3[1] == 4) {
356		// Extended mouse protocol
357	<	mouse_data[0] = 3;
358	<	mouse_data[1] = (my & 0x7f) | (mouse_button[0] ? 0 : 0x80);
359	<	mouse_data[2] = (mx & 0x7f) | (mouse_button[1] ? 0 : 0x80);
360	<	mouse_data[3] = ((my >> 3) & 0x70) | ((mx >> 7) & 0x07) | (mouse_button[2] ? 0x08 : 0x88);
357	>	WriteMacInt8(tmp_data, 3);
358	>	WriteMacInt8(tmp_data + 1, (my & 0x7f) | (mb[0] ? 0 : 0x80));
359	>	WriteMacInt8(tmp_data + 2, (mx & 0x7f) | (mb[1] ? 0 : 0x80));
360	>	WriteMacInt8(tmp_data + 3, ((my >> 3) & 0x70) | ((mx >> 7) & 0x07) | (mb[2] ? 0x08 : 0x88));
361		} else {
362		// 100/200 dpi mode
363	<	mouse_data[0] = 2;
364	<	mouse_data[1] = (my & 0x7f) | (mouse_button[0] ? 0 : 0x80);
365	<	mouse_data[2] = (mx & 0x7f) | (mouse_button[1] ? 0 : 0x80);
363	>	WriteMacInt8(tmp_data, 2);
364	>	WriteMacInt8(tmp_data + 1, (my & 0x7f) | (mb[0] ? 0 : 0x80));
365	>	WriteMacInt8(tmp_data + 2, (mx & 0x7f) | (mb[1] ? 0 : 0x80));
366		}
367		r.a[0] = tmp_data;
368		r.a[1] = ReadMacInt32(mouse_base);
#	Line 310 | Line 371 | void ADBInterrupt(void)
371		r.d[0] = (mouse_reg_3[0] << 4) | 0x0c;  // Talk 0
372		Execute68k(r.a[1], &r);
373
374	<	mouse_x = mouse_y = 0;
375	<	old_mouse_button[0] = mouse_button[0];
376	<	old_mouse_button[1] = mouse_button[1];
316	<	old_mouse_button[2] = mouse_button[2];
374	>	old_mouse_button[0] = mb[0];
375	>	old_mouse_button[1] = mb[1];
376	>	old_mouse_button[2] = mb[2];
377		}
378
379		} else {
380
381		// Update mouse position (absolute)
382		if (mx != old_mouse_x || my != old_mouse_y) {
383	+	#ifdef POWERPC_ROM
384	+	static const uint8 proc_template[] = {
385	+	0x2f, 0x08,             // move.l a0,-(sp)
386	+	0x2f, 0x00,             // move.l d0,-(sp)
387	+	0x2f, 0x01,             // move.l d1,-(sp)
388	+	0x70, 0x01,             // moveq #1,d0 (MoveTo)
389	+	0xaa, 0xdb,             // CursorDeviceDispatch
390	+	M68K_RTS >> 8, M68K_RTS & 0xff
391	+	};
392	+	BUILD_SHEEPSHAVER_PROCEDURE(proc);
393	+	r.a[0] = ReadMacInt32(mouse_base + 4);
394	+	r.d[0] = mx;
395	+	r.d[1] = my;
396	+	Execute68k(proc, &r);
397	+	#else
398		WriteMacInt16(0x82a, mx);
399		WriteMacInt16(0x828, my);
400		WriteMacInt16(0x82e, mx);
401		WriteMacInt16(0x82c, my);
402		WriteMacInt8(0x8ce, ReadMacInt8(0x8cf));        // CrsrCouple -> CrsrNew
403	+	#endif
404		old_mouse_x = mx;
405		old_mouse_y = my;
406		}
407
408		// Send mouse button events
409	<	if (mouse_button[0] != old_mouse_button[0]) {
409	>	if (mb[0] != old_mouse_button[0] || mb[1] != old_mouse_button[1] || mb[2] != old_mouse_button[2]) {
410		uint32 mouse_base = adb_base + 16;
335	–	uint8 *mouse_data = Mac2HostAddr(tmp_data);
411
412		// Call mouse ADB handler
413		if (mouse_reg_3[1] == 4) {
414		// Extended mouse protocol
415	<	mouse_data[0] = 3;
416	<	mouse_data[1] = mouse_button[0] ? 0 : 0x80;
417	<	mouse_data[2] = mouse_button[1] ? 0 : 0x80;
418	<	mouse_data[3] = mouse_button[2] ? 0x08 : 0x88;
415	>	WriteMacInt8(tmp_data, 3);
416	>	WriteMacInt8(tmp_data + 1, mb[0] ? 0 : 0x80);
417	>	WriteMacInt8(tmp_data + 2, mb[1] ? 0 : 0x80);
418	>	WriteMacInt8(tmp_data + 3, mb[2] ? 0x08 : 0x88);
419		} else {
420		// 100/200 dpi mode
421	<	mouse_data[0] = 2;
422	<	mouse_data[1] = mouse_button[0] ? 0 : 0x80;
423	<	mouse_data[2] = mouse_button[1] ? 0 : 0x80;
421	>	WriteMacInt8(tmp_data, 2);
422	>	WriteMacInt8(tmp_data + 1, mb[0] ? 0 : 0x80);
423	>	WriteMacInt8(tmp_data + 2, mb[1] ? 0 : 0x80);
424		}
425		r.a[0] = tmp_data;
426		r.a[1] = ReadMacInt32(mouse_base);
#	Line 354 | Line 429 | void ADBInterrupt(void)
429		r.d[0] = (mouse_reg_3[0] << 4) | 0x0c;  // Talk 0
430		Execute68k(r.a[1], &r);
431
432	<	old_mouse_button[0] = mouse_button[0];
433	<	old_mouse_button[1] = mouse_button[1];
434	<	old_mouse_button[2] = mouse_button[2];
432	>	old_mouse_button[0] = mb[0];
433	>	old_mouse_button[1] = mb[1];
434	>	old_mouse_button[2] = mb[2];
435		}
436		}
437
438		// Process accumulated keyboard events
364	–	uint32 key_base = adb_base + 4;
365	–	uint8 *key_data = Mac2HostAddr(tmp_data);
439		while (key_read_ptr != key_write_ptr) {
440
441		// Read keyboard event
#	Line 370 | Line 443 | void ADBInterrupt(void)
443		key_read_ptr = (key_read_ptr + 1) % KEY_BUFFER_SIZE;
444
445		// Call keyboard ADB handler
446	<	key_data[0] = 2;
447	<	key_data[1] = mac_code;
448	<	key_data[2] = mac_code == 0x7f ? 0x7f : 0xff;   // Power key is special
446	>	WriteMacInt8(tmp_data, 2);
447	>	WriteMacInt8(tmp_data + 1, mac_code);
448	>	WriteMacInt8(tmp_data + 2, mac_code == 0x7f ? 0x7f : 0xff);     // Power key is special
449		r.a[0] = tmp_data;
450		r.a[1] = ReadMacInt32(key_base);
451		r.a[2] = ReadMacInt32(key_base + 4);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines