![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kms.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src|
Return to kms.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src |
1.1 root 1: /* Previous - kms.c
2:
3: This file is distributed under the GNU Public License, version 2 or at
4: your option any later version. Read the file gpl.txt for details.
5:
6: Keyboard, Mouse and Sound logic Emulation.
7:
8: In real hardware this logic is located in the NeXT Megapixel Display
9: or Soundbox
10:
11: */
12:
13: #include "ioMem.h"
14: #include "ioMemTables.h"
15: #include "m68000.h"
16: #include "kms.h"
17: #include "sysReg.h"
18: #include "dma.h"
19: #include "rtcnvram.h"
20: #include "snd.h"
21: #include "video.h"
22: #include "host.h"
23:
24: #define LOG_KMS_LEVEL LOG_DEBUG
25: #define IO_SEG_MASK 0x1FFFF
26:
27:
28: struct {
29: struct {
30: Uint8 snd_dma;
31: Uint8 km;
32: Uint8 transmit;
33: Uint8 cmd;
34: } status;
35:
36: Uint32 data;
37: Uint32 km_data;
38: } kms;
39:
40: void KMS_Reset() {
41: kms.status.snd_dma = 0;
42: kms.status.km = 0;
43: kms.status.transmit = 0;
44: kms.status.cmd = 0;
45: kms.data = 0;
46: kms.km_data = 0;
47: }
48:
49: /* KMS control and status register (0x0200E000)
50: *
51: * x--- ---- ---- ---- ---- ---- ---- ---- sound out enable (r/w)
52: * -x-- ---- ---- ---- ---- ---- ---- ---- sound output request (r)
53: * --x- ---- ---- ---- ---- ---- ---- ---- sound output underrun detected (r/w)
54: * ---- x--- ---- ---- ---- ---- ---- ---- sound in enable (r/w)
55: * ---- -x-- ---- ---- ---- ---- ---- ---- sound input request (r)
56: * ---- --x- ---- ---- ---- ---- ---- ---- sound input overrun detected (r/w)
57: *
58: * ---- ---- x--- ---- ---- ---- ---- ---- keyboard interrupt (r)
59: * ---- ---- -x-- ---- ---- ---- ---- ---- keyboard data received (r)
60: * ---- ---- --x- ---- ---- ---- ---- ---- keyboard data overrun detected (r/w)
61: * ---- ---- ---x ---- ---- ---- ---- ---- non-maskable interrupt received (tilde and left or right cmd key) (r/w)
62: * ---- ---- ---- x--- ---- ---- ---- ---- kms interrupt (r)
63: * ---- ---- ---- -x-- ---- ---- ---- ---- kms data received (r)
64: * ---- ---- ---- --x- ---- ---- ---- ---- kms data overrun detected (r/w)
65: *
66: * ---- ---- ---- ---- x--- ---- ---- ---- dma sound out transmit pending (r)
67: * ---- ---- ---- ---- -x-- ---- ---- ---- dma sound out transmit in progress (r)
68: * ---- ---- ---- ---- --x- ---- ---- ---- cpu data transmit pending (r)
69: * ---- ---- ---- ---- ---x ---- ---- ---- cpu data transmit in progress (r)
70: * ---- ---- ---- ---- ---- x--- ---- ---- rtx_pend ???
71: * ---- ---- ---- ---- ---- -x-- ---- ---- rtx ???
72: * ---- ---- ---- ---- ---- --x- ---- ---- kms enable (return from reset state) (r/w)
73: * ---- ---- ---- ---- ---- ---x ---- ---- loop back transmitter data (r/w)
74: *
75: * ---- ---- ---- ---- ---- ---- xxxx xxxx command to append on kms data (r/w)
76: *
77: * ---x ---x ---- ---x ---- ---- ---- ---- zero bits
78: */
79:
80:
81: #define SNDOUT_DMA_ENABLE 0x80
82: #define SNDOUT_DMA_REQUEST 0x40
83: #define SNDOUT_DMA_UNDERRUN 0x20
84: #define SNDIN_DMA_ENABLE 0x08
85: #define SNDIN_DMA_REQUEST 0x04
86: #define SNDIN_DMA_OVERRUN 0x02
87:
88: #define KBD_INT 0x80
89: #define KBD_RECEIVED 0x40
90: #define KBD_OVERRUN 0x20
91: #define NMI_RECEIVED 0x10
92: #define KMS_INT 0x08
93: #define KMS_RECEIVED 0x04
94: #define KMS_OVERRUN 0x02
95:
96: #define TX_DMA_PENDING 0x80
97: #define TX_DMA 0x40
98: #define TX_CPU_PENDING 0x20
99: #define TX_CPU 0x10
100: #define RTX_PEND 0x08
101: #define RTX 0x04
102: #define KMS_ENABLE 0x02
103: #define TX_LOOP 0x01
104:
105:
106: /* KMS commands */
107:
108: /* Host commands */
109: #define KMSCMD_RESET 0xFF
110: #define KMSCMD_ASNDOUT 0xC7 /* analog sound out */
111: #define KMSCMD_KMREG 0xC5 /* access keyboard or mouse register */
112: #define KMSCMD_CTRLOUT 0xC4 /* access volume control logic */
113: #define KMSCMD_VOLCTRL 0xC2 /* simplified access to volume control */
114:
115: #define KMSCMD_SND_IN 0x03 /* sound in */
116: #define KMSCMD_SND_OUT 0x07 /* sound out */
117: #define KMSCMD_SIO_MASK 0xC7 /* mask for sound in/out */
118:
119: #define SIO_ENABLE 0x08 /* 1=enable, 0=disable sound */
120: #define SIO_DBL_SMPL 0x10 /* 1=double sample, 0=normal */
121: #define SIO_ZERO 0x20 /* double sample by 1=zero filling, 0=repetition */
122:
123: /* Commands from KMS board */
124: #define KMSCMD_CODEC_IN 0xC7 /* CODEC sound in */
125: #define KMSCMD_KBD_RECV 0xC6 /* receive data from keyboard/mouse */
126: #define KMSCMD_SO_REQ 0x07 /* sound out request */
127: #define KMSCMD_SO_UNDR 0x0F /* sound out underrun */
128:
129: void KMS_command(Uint8 command, Uint32 data);
130:
131:
132: /* Keyboard Registers */
133: #define KM_REG_MASK 0xE0
134: #define KM_READ 0x10
135: #define KM_RESET 0x0F
136: #define KM_SET_ADDR 0xEF
137: #define KM_ADDR_MASK 0x0E
138: #define KM_ADDR_MOUSE 0x01
139:
140:
141: /* Device mask
142: *
143: * xxxx xxxx xxxx xxxx xxxx xxxx xxxx ---- polled devices (7 device addresses, 4 bit each)
144: * ---- ---- ---- ---- ---- ---- ---- xxxx poll speed
145: */
146:
147: Uint32 km_address = 0;
148: Uint32 km_dev_msk = 0;
149:
150: static void access_km_reg(Uint32 data) {
151: Uint8 reg_addr = (data>>24)&0xFF;
152: Uint8 reg_data = (data>>16)&0xFF;
153:
154: if (reg_addr==KM_RESET) {
155: Log_Printf(LOG_KMS_LEVEL, "Keyboard/Mouse: Reset");
156: kms_response();
157: return;
158: }
159: if (reg_addr==KM_SET_ADDR) {
160: Log_Printf(LOG_KMS_LEVEL, "Keyboard/Mouse: Set address to %i",(reg_data&KM_ADDR_MASK)>>1);
161: km_address = reg_data&KM_ADDR_MASK;
162: kms_response();
163: return;
164: }
165:
166: bool device_kbd = (reg_addr&KM_ADDR_MOUSE) ? false : true;
167: int device_addr = (reg_addr&KM_ADDR_MASK)>>1;
168: int device_reg = (reg_addr&KM_REG_MASK)>>5;
169: bool read_reg = (reg_addr&KM_READ) ? true : false;
170:
171: Log_Printf(LOG_KMS_LEVEL, "%s %s %i, register %i",read_reg?"Reading":"Writing",
172: device_kbd?"keyboard":"mouse",device_addr,device_reg);
173:
174: if (reg_addr&KM_READ) {
175: switch (device_reg) {
176: case 0:
177: Log_Printf(LOG_KMS_LEVEL, "Poll device");
178: break;
179: case 7:
180: Log_Printf(LOG_KMS_LEVEL, "Request device revision");
181: break;
182: default:
183: Log_Printf(LOG_WARN, "Unknown device register");
184: break;
185: }
186: } else { // device write
187: switch (device_reg) {
188: case 0:
189: if (device_kbd) {
190: Log_Printf(LOG_KMS_LEVEL, "Turn %s keyboard LED1",(reg_data&1)?"on":"off");
191: Log_Printf(LOG_KMS_LEVEL, "Turn %s keyboard LED2",(reg_data&2)?"on":"off");
192: break;
193: }
194: default:
195: Log_Printf(LOG_WARN, "Unknown device register");
196: break;
197: }
198: }
199: kms_response();
200: }
201:
202: void KMS_command(Uint8 command, Uint32 data) {
203: switch (command) {
204: case KMSCMD_KBD_RECV: // keyboard poll
205: km_dev_msk=data;
206: return;
207:
208: case KMSCMD_RESET:
209: Log_Printf(LOG_KMS_LEVEL, "[KMS] Reset");
210: Log_Printf(LOG_KMS_LEVEL, "[KMS] Data = %08X",data);
211: break;
212: case KMSCMD_ASNDOUT:
213: Log_Printf(LOG_KMS_LEVEL, "[KMS] Analog sound out");
214: Log_Printf(LOG_KMS_LEVEL, "[KMS] Data = %08X",data);
215: break;
216: case KMSCMD_KMREG:
217: Log_Printf(LOG_KMS_LEVEL, "[KMS] Access keyboard/mouse register");
218: Log_Printf(LOG_KMS_LEVEL, "[KMS] Data = %08X",data);
219: access_km_reg(data);
220: break;
221: case KMSCMD_CTRLOUT:
222: Log_Printf(LOG_KMS_LEVEL, "[KMS] Access volume control logic");
223: Log_Printf(LOG_KMS_LEVEL, "[KMS] Data = %08X",data);
224: snd_gpo_access(data>>24);
225: break;
226: case KMSCMD_VOLCTRL:
227: Log_Printf(LOG_KMS_LEVEL, "[KMS] Access volume control (simple)");
228: Log_Printf(LOG_KMS_LEVEL, "[KMS] Data = %08X",data);
229: break;
230:
231: default: // commands without data
232: if ((command&KMSCMD_SIO_MASK)==KMSCMD_SND_OUT) {
233: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out command:");
234:
235: if (command&SIO_ENABLE) {
236: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out enable.");
237: if (command&SIO_DBL_SMPL) {
238: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out double sample.");
239: if (command&SIO_ZERO) {
240: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out double sample by zero filling.");
241: } else {
242: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out double sample by repetition.");
243: }
244: } else {
245: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out normal sample.");
246: }
247: snd_start_output(command&(SIO_DBL_SMPL|SIO_ZERO));
248: } else {
249: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound out disable.");
250: kms.status.snd_dma &= ~(SNDOUT_DMA_UNDERRUN|SNDOUT_DMA_REQUEST);
251: snd_stop_output();
252: }
253: } else if ((command&KMSCMD_SIO_MASK)==KMSCMD_SND_IN) {
254: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound in command");
255:
256: if (command&SIO_ENABLE) {
257: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound in enable.");
258: snd_start_input(command);
259: } else {
260: Log_Printf(LOG_KMS_LEVEL, "[KMS] Sound in disable.");
261: kms.status.snd_dma &= ~(SNDIN_DMA_OVERRUN|SNDIN_DMA_REQUEST);
262: snd_stop_input();
263: }
264: } else {
265: Log_Printf(LOG_WARN, "[KMS] Unknown command!");
266: }
267: return;
268: }
269: }
270:
271:
272: void KMS_Ctrl_Snd_Write(void) {
273: Uint8 val = IoMem[IoAccessCurrentAddress&IO_SEG_MASK];
274:
275: kms.status.snd_dma &= ~(SNDOUT_DMA_ENABLE|SNDIN_DMA_ENABLE);
276: kms.status.snd_dma |= (val&(SNDOUT_DMA_ENABLE|SNDIN_DMA_ENABLE));
277:
278: if (val&SNDOUT_DMA_UNDERRUN && (!snd_output_active())) {
279: kms.status.snd_dma &= ~(SNDOUT_DMA_UNDERRUN|SNDOUT_DMA_REQUEST);
280: set_interrupt(INT_SOUND_OVRUN, RELEASE_INT);
281: }
282: if (val&SNDIN_DMA_OVERRUN && (!snd_input_active())) {
283: kms.status.snd_dma &= ~(SNDIN_DMA_OVERRUN|SNDIN_DMA_REQUEST);
284: set_interrupt(INT_SOUND_OVRUN, RELEASE_INT);
285: }
286: }
287:
288: void KMS_Stat_Snd_Read(void) {
289: IoMem[IoAccessCurrentAddress&IO_SEG_MASK] = kms.status.snd_dma;
290: }
291:
292: void kms_sndout_underrun() {
293: kms.status.snd_dma |= SNDOUT_DMA_UNDERRUN|SNDOUT_DMA_REQUEST;
294: set_interrupt(INT_SOUND_OVRUN, SET_INT);
295: }
296:
297: void kms_sndin_overrun() {
298: kms.status.snd_dma |= SNDIN_DMA_OVERRUN|SNDIN_DMA_REQUEST;
299: set_interrupt(INT_SOUND_OVRUN, SET_INT);
300: }
301:
302: void KMS_Ctrl_KM_Write(void) {
303: Uint8 val = IoMem[IoAccessCurrentAddress&IO_SEG_MASK];
304:
305: if (val&KBD_OVERRUN) {
306: kms.status.km &= ~(KBD_RECEIVED|KBD_OVERRUN|KBD_INT);
307: set_interrupt(INT_KEYMOUSE, RELEASE_INT);
308: }
309: if (val&NMI_RECEIVED) {
310: kms.status.km &= ~NMI_RECEIVED;
311: set_interrupt(INT_NMI, RELEASE_INT);
312: }
313: if (val&KMS_OVERRUN) {
314: kms.status.km &= ~(KMS_RECEIVED|KMS_OVERRUN|KMS_INT);
315: set_interrupt(INT_MONITOR, RELEASE_INT);
316: }
317: }
318:
319: void KMS_Stat_KM_Read(void) {
320: IoMem[IoAccessCurrentAddress&IO_SEG_MASK] = kms.status.km;
321: }
322:
323: void KMS_Ctrl_TX_Write(void) {
324: Uint8 val = IoMem[IoAccessCurrentAddress&IO_SEG_MASK];
325:
326: kms.status.transmit &= ~(KMS_ENABLE|TX_LOOP);
327: kms.status.transmit |= (val&(KMS_ENABLE|TX_LOOP));
328: }
329:
330: void KMS_Stat_TX_Read(void) {
331: IoMem[IoAccessCurrentAddress&IO_SEG_MASK] = kms.status.transmit;
332: }
333:
334: void KMS_Ctrl_Cmd_Write(void) {
335: kms.status.cmd = IoMem[IoAccessCurrentAddress&IO_SEG_MASK];
336: }
337:
338: void KMS_Stat_Cmd_Read(void) {
339: IoMem[IoAccessCurrentAddress&IO_SEG_MASK] = kms.status.cmd;
340: }
341:
342:
343: /* KMS data register (0x0200E004) */
344:
345: void KMS_Data_Write(void) {
346: kms.data = IoMem_ReadLong(IoAccessCurrentAddress&IO_SEG_MASK);
347: KMS_command(kms.status.cmd, kms.data);
348: }
349:
350: void KMS_Data_Read(void) {
351: IoMem_WriteLong(IoAccessCurrentAddress&IO_SEG_MASK, kms.data);
352: }
353:
354:
355: /* KMS keyboard and mouse data register (0x0200E008) *
356: *
357: * x--- ---- ---- ---- ---- ---- ---- ---- always 0
358: * -x-- ---- ---- ---- ---- ---- ---- ---- 1 = no response error, 0 = normal event
359: * --x- ---- ---- ---- ---- ---- ---- ---- 1 = user poll, 0 = internal poll
360: * ---x ---- ---- ---- ---- ---- ---- ---- 1 = invalid/master, 0 = valid/slave (user/internal)
361: * ---- xxxx ---- ---- ---- ---- ---- ---- device address (lowest bit 1 = mouse, 0 = keyboard)
362: * ---- ---- xxxx xxxx ---- ---- ---- ---- chip revision: 0 = old, 1 = new, 2 = digital
363: *
364: * Mouse data:
365: * ---- ---- ---- ---- xxxx xxx- ---- ---- mouse y
366: * ---- ---- ---- ---- ---- ---x ---- ---- right button up (1) or down (0)
367: * ---- ---- ---- ---- ---- ---- xxxx xxx- mouse x
368: * ---- ---- ---- ---- ---- ---- ---- ---x left button up (1) or down (0)
369: *
370: * Keyboard data:
371: * ---- ---- ---- ---- x--- ---- ---- ---- valid (1) or invalid (0)
372: * ---- ---- ---- ---- -x-- ---- ---- ---- right alt
373: * ---- ---- ---- ---- --x- ---- ---- ---- left alt
374: * ---- ---- ---- ---- ---x ---- ---- ---- right command
375: * ---- ---- ---- ---- ---- x--- ---- ---- left command
376: * ---- ---- ---- ---- ---- -x-- ---- ---- right shift
377: * ---- ---- ---- ---- ---- --x- ---- ---- left shift
378: * ---- ---- ---- ---- ---- ---x ---- ---- control
379: * ---- ---- ---- ---- ---- ---- x--- ---- key up (1) or down (0)
380: * ---- ---- ---- ---- ---- ---- -xxx xxxx keycode
381: */
382:
383: #define NO_RESPONSE_ERR 0x40000000
384: #define USER_POLL 0x20000000
385: #define DEVICE_INVALID 0x10000000
386: #define DEVICE_MASTER 0x10000000
387:
388: #define DEVICE_ADDR_MSK 0x0E000000
389: #define DEVICE_MOUSE 0x01000000
390:
391: #define MOUSE_Y 0x0000FE00
392: #define MOUSE_RIGHT_UP 0x00000100
393: #define MOUSE_X 0x000000FE
394: #define MOUSE_LEFT_UP 0x00000001
395:
396: #define KBD_KEY_VALID 0x00008000
397: #define KBD_MOD_MASK 0x00007F00
398: #define KBD_KEY_UP 0x00000080
399: #define KBD_KEY_MASK 0x0000007F
400:
401:
402: bool m_button_right = false;
403: bool m_button_left = false;
404: bool m_move_left = false;
405: bool m_move_up = false;
406: int m_move_x = 0;
407: int m_move_y = 0;
408: int m_move_dx = 0;
409: int m_move_dy = 0;
410: void kms_mouse_move_step(void);
411:
412:
413: void KMS_KM_Data_Read(void) {
414: IoMem_WriteLong(IoAccessCurrentAddress & IO_SEG_MASK, kms.km_data);
415:
416: kms.status.km &= ~(KBD_RECEIVED|KBD_INT);
417: set_interrupt(INT_KEYMOUSE, RELEASE_INT);
418: }
419:
420: static void kms_interrupt(void) {
421: kms.status.cmd = KMSCMD_KBD_RECV;
422:
423: if (kms.status.km&KBD_RECEIVED) {
424: kms.status.km |= KBD_OVERRUN;
425: }
426: kms.status.km |= (KBD_RECEIVED|KBD_INT);
427: set_interrupt(INT_KEYMOUSE, SET_INT);
428: }
429:
430: static bool kms_device_enabled(int dev_addr) {
431: int i,mask;
432:
433: for (i=28; i>4; i-=4) {
434: mask=(km_dev_msk>>i)&0xF;
435: if(mask==dev_addr && mask!=0xF)
436: return true;
437: }
438: Log_Printf(LOG_KMS_LEVEL, "[KMS] Device %i disabled (mask: %08X)",dev_addr,km_dev_msk);
439: return false;
440: }
441:
442: void kms_keydown(Uint8 modkeys, Uint8 keycode) {
443: if ((keycode==0x26)&&(modkeys&0x18)) { /* backquote and one or both command keys */
444: Log_Printf(LOG_WARN, "Keyboard initiated NMI!");
445: set_interrupt(INT_NMI, SET_INT);
446: return;
447: }
448:
449: if ((keycode==0x25)&&((modkeys&0x28)==0x28)) { /* asterisk and left alt and left command key */
450: Log_Printf(LOG_WARN, "Keyboard initiated CPU reset!");
451: host_darkmatter(false);
452: M68000_Reset(false);
453: return;
454: }
455:
456: if (keycode==0x58) { /* Power key */
457: rtc_request_power_down();
458: return;
459: }
460:
461: if (kms_device_enabled(km_address)) {
462: kms.km_data = (km_address<<24)|DEVICE_MASTER; /* keyboard */
463:
464: kms.km_data |= (modkeys<<8)|keycode|KBD_KEY_VALID;
465:
466: kms_interrupt();
467: }
468: }
469:
470: void kms_keyup(Uint8 modkeys, Uint8 keycode) {
471: if (keycode==0x58) {
472: rtc_stop_pdown_request();
473: return;
474: }
475:
476: if (kms_device_enabled(km_address)) {
477: kms.km_data = (km_address<<24)|DEVICE_MASTER; /* keyboard */
478:
479: kms.km_data |= (modkeys<<8)|keycode|KBD_KEY_VALID|KBD_KEY_UP;
480:
481: kms_interrupt();
482: }
483: }
484:
485: void kms_mouse_button(bool left, bool down) {
486: if (left) {
487: m_button_left = down;
488: } else {
489: m_button_right = down;
490: }
491:
492: if (kms_device_enabled(km_address|KM_ADDR_MOUSE)) {
493: kms.km_data = (km_address|KM_ADDR_MOUSE)<<24; /* mouse */
494:
495: kms.km_data |= m_button_left?0:MOUSE_LEFT_UP;
496: kms.km_data |= m_button_right?0:MOUSE_RIGHT_UP;
497:
498: kms_interrupt();
499: }
500: }
501:
502: #define MOUSE_STEP_FREQ 1000
503:
504: void kms_mouse_move(int x, bool left, int y, bool up) {
505: if (x<0 || y<0) abort();
506:
507: m_move_left = left;
508: m_move_up = up;
509:
510: int xsteps = x / 8; if(xsteps == 0) xsteps = 1;
511: int ysteps = y / 8; if(ysteps == 0) ysteps = 1;
512:
513: m_move_x = x;
514: m_move_dx = x / xsteps;
515:
516: m_move_y = y;
517: m_move_dy = y / ysteps;
518:
519: CycInt_AddRelativeInterruptCycles(10, INTERRUPT_MOUSE);
520: }
521:
522: void kms_mouse_move_step(void) {
523:
524: int x = m_move_x > m_move_dx ? m_move_dx : m_move_x;
525: int y = m_move_y > m_move_dy ? m_move_dy : m_move_y;
526:
527: m_move_x -= x;
528: m_move_y -= y;
529:
530: if (!m_move_left && x>0) /* right */
531: x=(0x40-x)|0x40;
532: if (!m_move_up && y>0) /* down */
533: y=(0x40-y)|0x40;
534:
535: if (kms_device_enabled(km_address|KM_ADDR_MOUSE)) {
536: kms.km_data = (km_address|KM_ADDR_MOUSE)<<24; /* mouse */
537:
538: kms.km_data |= (x<<1)&MOUSE_X;
539: kms.km_data |= (y<<9)&MOUSE_Y;
540:
541: kms.km_data |= m_button_left?0:MOUSE_LEFT_UP;
542: kms.km_data |= m_button_right?0:MOUSE_RIGHT_UP;
543:
544: kms_interrupt();
545: }
546: }
547:
548: void kms_response(void) {
549: kms.km_data = km_address<<24; /* keyboard */
550: kms.km_data |= USER_POLL;
551: kms.km_data |= (NO_RESPONSE_ERR|DEVICE_INVALID); /* checked on real hardware */
552:
553: kms_interrupt();
554: }
555:
556: void Mouse_Handler(void) {
557: CycInt_AcknowledgeInterrupt();
558:
559: if (m_move_x > 0 || m_move_y > 0) {
560: kms_mouse_move_step();
561: CycInt_AddRelativeInterruptUs((1000*1000)/MOUSE_STEP_FREQ, 0, INTERRUPT_MOUSE);
562: }
563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.