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