3c6782f379e4d328c309ef004f8116551c6def6b
[reactos.git] / subsystems / ntvdm / io.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: io.c
5 * PURPOSE: I/O Port Handlers
6 * PROGRAMMERS: Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
7 * Hermes Belusca-Maito (hermes.belusca@sfr.fr)
8 */
9
10 /* INCLUDES *******************************************************************/
11
12 #define NDEBUG
13
14 #include "emulator.h"
15 #include "io.h"
16
17 /* PRIVATE VARIABLES **********************************************************/
18
19 typedef struct _EMULATOR_IO_HANDLERS
20 {
21 EMULATOR_INB_PROC InB;
22 EMULATOR_INW_PROC InW;
23 EMULATOR_IND_PROC InD;
24
25 EMULATOR_INSB_PROC InsB;
26 EMULATOR_INSW_PROC InsW;
27 EMULATOR_INSD_PROC InsD;
28
29 EMULATOR_OUTB_PROC OutB;
30 EMULATOR_OUTW_PROC OutW;
31 EMULATOR_OUTD_PROC OutD;
32
33 EMULATOR_OUTSB_PROC OutsB;
34 EMULATOR_OUTSW_PROC OutsW;
35 EMULATOR_OUTSD_PROC OutsD;
36 } EMULATOR_IO_HANDLERS, *PEMULATOR_IO_HANDLERS;
37
38 typedef struct _EMULATOR_IOPORT_HANDLERS
39 {
40 HANDLE hVdd; // == 0 if unused,
41 // INVALID_HANDLE_VALUE if handled internally,
42 // a valid VDD handle if handled externally.
43 union
44 {
45 /* For Windows compatibility only, not used internally... */
46 VDD_IO_HANDLERS VddIoHandlers;
47
48 /* ... we use these members internally */
49 EMULATOR_IO_HANDLERS IoHandlers;
50 };
51 } EMULATOR_IOPORT_HANDLERS, *PEMULATOR_IOPORT_HANDLERS;
52
53 /*
54 * This is the list of registered I/O Port handlers.
55 */
56 EMULATOR_IOPORT_HANDLERS IoPortProc[EMULATOR_MAX_IOPORTS_NUM] = {{NULL}};
57
58 /* PRIVATE FUNCTIONS **********************************************************/
59
60 static VOID
61 IOReadB(ULONG Port,
62 PUCHAR Buffer)
63 {
64 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
65 IoPortProc[Port].IoHandlers.InB)
66 {
67 *Buffer = IoPortProc[Port].IoHandlers.InB(Port);
68 }
69 else if (IoPortProc[Port].hVdd > 0 &&
70 IoPortProc[Port].VddIoHandlers.inb_handler)
71 {
72 ASSERT(Port <= MAXWORD);
73 IoPortProc[Port].VddIoHandlers.inb_handler((WORD)Port, Buffer);
74 }
75 else
76 {
77 /* Return an empty port byte value */
78 DPRINT1("Read from unknown port: 0x%X\n", Port);
79 *Buffer = 0xFF;
80 }
81 }
82
83 static VOID
84 IOReadStrB(ULONG Port,
85 PUCHAR Buffer,
86 ULONG Count)
87 {
88 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
89 IoPortProc[Port].IoHandlers.InsB)
90 {
91 IoPortProc[Port].IoHandlers.InsB(Port, Buffer, Count);
92 }
93 else if (IoPortProc[Port].hVdd > 0 &&
94 IoPortProc[Port].VddIoHandlers.insb_handler)
95 {
96 ASSERT(Port <= MAXWORD);
97 ASSERT(Count <= MAXWORD);
98 IoPortProc[Port].VddIoHandlers.insb_handler((WORD)Port, Buffer, (WORD)Count);
99 }
100 else
101 {
102 while (Count--) IOReadB(Port, Buffer++);
103 }
104 }
105
106 static VOID
107 IOWriteB(ULONG Port,
108 PUCHAR Buffer)
109 {
110 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
111 IoPortProc[Port].IoHandlers.OutB)
112 {
113 IoPortProc[Port].IoHandlers.OutB(Port, *Buffer);
114 }
115 else if (IoPortProc[Port].hVdd > 0 &&
116 IoPortProc[Port].VddIoHandlers.outb_handler)
117 {
118 ASSERT(Port <= MAXWORD);
119 IoPortProc[Port].VddIoHandlers.outb_handler((WORD)Port, *Buffer);
120 }
121 else
122 {
123 /* Do nothing */
124 DPRINT1("Write to unknown port: 0x%X\n", Port);
125 }
126 }
127
128 static VOID
129 IOWriteStrB(ULONG Port,
130 PUCHAR Buffer,
131 ULONG Count)
132 {
133 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
134 IoPortProc[Port].IoHandlers.OutsB)
135 {
136 IoPortProc[Port].IoHandlers.OutsB(Port, Buffer, Count);
137 }
138 else if (IoPortProc[Port].hVdd > 0 &&
139 IoPortProc[Port].VddIoHandlers.outsb_handler)
140 {
141 ASSERT(Port <= MAXWORD);
142 ASSERT(Count <= MAXWORD);
143 IoPortProc[Port].VddIoHandlers.outsb_handler((WORD)Port, Buffer, (WORD)Count);
144 }
145 else
146 {
147 while (Count--) IOWriteB(Port, Buffer++);
148 }
149 }
150
151 static VOID
152 IOReadW(ULONG Port,
153 PUSHORT Buffer)
154 {
155 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
156 IoPortProc[Port].IoHandlers.InW)
157 {
158 *Buffer = IoPortProc[Port].IoHandlers.InW(Port);
159 }
160 else if (IoPortProc[Port].hVdd > 0 &&
161 IoPortProc[Port].VddIoHandlers.inw_handler)
162 {
163 ASSERT(Port <= MAXWORD);
164 IoPortProc[Port].VddIoHandlers.inw_handler((WORD)Port, Buffer);
165 }
166 else
167 {
168 UCHAR Low, High;
169
170 // FIXME: Is it ok on Little endian and Big endian ??
171 IOReadB(Port, &Low);
172 IOReadB(Port + sizeof(UCHAR), &High);
173 *Buffer = MAKEWORD(Low, High);
174 }
175 }
176
177 static VOID
178 IOReadStrW(ULONG Port,
179 PUSHORT Buffer,
180 ULONG Count)
181 {
182 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
183 IoPortProc[Port].IoHandlers.InsW)
184 {
185 IoPortProc[Port].IoHandlers.InsW(Port, Buffer, Count);
186 }
187 else if (IoPortProc[Port].hVdd > 0 &&
188 IoPortProc[Port].VddIoHandlers.insw_handler)
189 {
190 ASSERT(Port <= MAXWORD);
191 ASSERT(Count <= MAXWORD);
192 IoPortProc[Port].VddIoHandlers.insw_handler((WORD)Port, Buffer, (WORD)Count);
193 }
194 else
195 {
196 while (Count--) IOReadW(Port, Buffer++);
197 }
198 }
199
200 static VOID
201 IOWriteW(ULONG Port,
202 PUSHORT Buffer)
203 {
204 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
205 IoPortProc[Port].IoHandlers.OutW)
206 {
207 IoPortProc[Port].IoHandlers.OutW(Port, *Buffer);
208 }
209 else if (IoPortProc[Port].hVdd > 0 &&
210 IoPortProc[Port].VddIoHandlers.outw_handler)
211 {
212 ASSERT(Port <= MAXWORD);
213 IoPortProc[Port].VddIoHandlers.outw_handler((WORD)Port, *Buffer);
214 }
215 else
216 {
217 UCHAR Low, High;
218
219 // FIXME: Is it ok on Little endian and Big endian ??
220 Low = LOBYTE(*Buffer);
221 High = HIBYTE(*Buffer);
222 IOWriteB(Port, &Low);
223 IOWriteB(Port + sizeof(UCHAR), &High);
224 }
225 }
226
227 static VOID
228 IOWriteStrW(ULONG Port,
229 PUSHORT Buffer,
230 ULONG Count)
231 {
232 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
233 IoPortProc[Port].IoHandlers.OutsW)
234 {
235 IoPortProc[Port].IoHandlers.OutsW(Port, Buffer, Count);
236 }
237 else if (IoPortProc[Port].hVdd > 0 &&
238 IoPortProc[Port].VddIoHandlers.outsw_handler)
239 {
240 ASSERT(Port <= MAXWORD);
241 ASSERT(Count <= MAXWORD);
242 IoPortProc[Port].VddIoHandlers.outsw_handler((WORD)Port, Buffer, (WORD)Count);
243 }
244 else
245 {
246 while (Count--) IOWriteW(Port, Buffer++);
247 }
248 }
249
250 static VOID
251 IOReadD(ULONG Port,
252 PULONG Buffer)
253 {
254 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
255 IoPortProc[Port].IoHandlers.InD)
256 {
257 *Buffer = IoPortProc[Port].IoHandlers.InD(Port);
258 }
259 else
260 {
261 USHORT Low, High;
262
263 // FIXME: Is it ok on Little endian and Big endian ??
264 IOReadW(Port, &Low);
265 IOReadW(Port + sizeof(USHORT), &High);
266 *Buffer = MAKELONG(Low, High);
267 }
268 }
269
270 static VOID
271 IOReadStrD(ULONG Port,
272 PULONG Buffer,
273 ULONG Count)
274 {
275 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
276 IoPortProc[Port].IoHandlers.InsD)
277 {
278 IoPortProc[Port].IoHandlers.InsD(Port, Buffer, Count);
279 }
280 else
281 {
282 while (Count--) IOReadD(Port, Buffer++);
283 }
284 }
285
286 static VOID
287 IOWriteD(ULONG Port,
288 PULONG Buffer)
289 {
290 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
291 IoPortProc[Port].IoHandlers.OutD)
292 {
293 IoPortProc[Port].IoHandlers.OutD(Port, *Buffer);
294 }
295 else
296 {
297 USHORT Low, High;
298
299 // FIXME: Is it ok on Little endian and Big endian ??
300 Low = LOWORD(*Buffer);
301 High = HIWORD(*Buffer);
302 IOWriteW(Port, &Low);
303 IOWriteW(Port + sizeof(USHORT), &High);
304 }
305 }
306
307 static VOID
308 IOWriteStrD(ULONG Port,
309 PULONG Buffer,
310 ULONG Count)
311 {
312 if (IoPortProc[Port].hVdd == INVALID_HANDLE_VALUE &&
313 IoPortProc[Port].IoHandlers.OutsD)
314 {
315 IoPortProc[Port].IoHandlers.OutsD(Port, Buffer, Count);
316 }
317 else
318 {
319 while (Count--) IOWriteD(Port, Buffer++);
320 }
321 }
322
323 /* PUBLIC FUNCTIONS ***********************************************************/
324
325 VOID RegisterIoPort(ULONG Port,
326 EMULATOR_INB_PROC InHandler,
327 EMULATOR_OUTB_PROC OutHandler)
328 {
329 if (IoPortProc[Port].IoHandlers.InB == NULL)
330 IoPortProc[Port].IoHandlers.InB = InHandler;
331 else
332 DPRINT1("IoPortProc[0x%X].IoHandlers.InB already registered\n", Port);
333
334 if (IoPortProc[Port].IoHandlers.OutB == NULL)
335 IoPortProc[Port].IoHandlers.OutB = OutHandler;
336 else
337 DPRINT1("IoPortProc[0x%X].IoHandlers.OutB already registered\n", Port);
338
339 /* We hold the I/O port internally */
340 IoPortProc[Port].hVdd = INVALID_HANDLE_VALUE;
341 }
342
343 VOID UnregisterIoPort(ULONG Port)
344 {
345 /*
346 * Put automagically all the fields to zero:
347 * the hVdd gets unregistered as well as all the handlers.
348 */
349 // IoPortProc[Port] = {NULL};
350 ZeroMemory(&IoPortProc[Port], sizeof(IoPortProc[Port]));
351 }
352
353 VOID WINAPI
354 EmulatorReadIo(PFAST486_STATE State,
355 ULONG Port,
356 PVOID Buffer,
357 ULONG DataCount,
358 UCHAR DataSize)
359 {
360 UNREFERENCED_PARAMETER(State);
361
362 if (DataSize == 0 || DataCount == 0) return;
363
364 if (DataSize == sizeof(UCHAR))
365 {
366 if (DataCount == 1)
367 IOReadB(Port, Buffer);
368 else
369 IOReadStrB(Port, Buffer, DataCount);
370 }
371 else if (DataSize == sizeof(USHORT))
372 {
373 if (DataCount == 1)
374 IOReadW(Port, Buffer);
375 else
376 IOReadStrW(Port, Buffer, DataCount);
377 }
378 else if (DataSize == sizeof(ULONG))
379 {
380 if (DataCount == 1)
381 IOReadD(Port, Buffer);
382 else
383 IOReadStrD(Port, Buffer, DataCount);
384 }
385 else
386 {
387 PBYTE Address = (PBYTE)Buffer;
388
389 while (DataCount--)
390 {
391 ULONG CurrentPort = Port;
392 ULONG Count;
393 UCHAR NewDataSize = DataSize;
394
395 /* Read dword */
396 Count = NewDataSize / sizeof(ULONG);
397 NewDataSize = NewDataSize % sizeof(ULONG);
398 while (Count--)
399 {
400 IOReadD(CurrentPort, (PULONG)Address);
401 CurrentPort += sizeof(ULONG);
402 Address += sizeof(ULONG);
403 }
404
405 /* Read word */
406 Count = NewDataSize / sizeof(USHORT);
407 NewDataSize = NewDataSize % sizeof(USHORT);
408 while (Count--)
409 {
410 IOReadW(CurrentPort, (PUSHORT)Address);
411 CurrentPort += sizeof(USHORT);
412 Address += sizeof(USHORT);
413 }
414
415 /* Read byte */
416 Count = NewDataSize / sizeof(UCHAR);
417 NewDataSize = NewDataSize % sizeof(UCHAR);
418 while (Count--)
419 {
420 IOReadB(CurrentPort, (PUCHAR)Address);
421 CurrentPort += sizeof(UCHAR);
422 Address += sizeof(UCHAR);
423 }
424
425 ASSERT(Count == 0);
426 ASSERT(NewDataSize == 0);
427 }
428 }
429 }
430
431 VOID WINAPI
432 EmulatorWriteIo(PFAST486_STATE State,
433 ULONG Port,
434 PVOID Buffer,
435 ULONG DataCount,
436 UCHAR DataSize)
437 {
438 UNREFERENCED_PARAMETER(State);
439
440 if (DataSize == 0 || DataCount == 0) return;
441
442 if (DataSize == sizeof(UCHAR))
443 {
444 if (DataCount == 1)
445 IOWriteB(Port, Buffer);
446 else
447 IOWriteStrB(Port, Buffer, DataCount);
448 }
449 else if (DataSize == sizeof(USHORT))
450 {
451 if (DataCount == 1)
452 IOWriteW(Port, Buffer);
453 else
454 IOWriteStrW(Port, Buffer, DataCount);
455 }
456 else if (DataSize == sizeof(ULONG))
457 {
458 if (DataCount == 1)
459 IOWriteD(Port, Buffer);
460 else
461 IOWriteStrD(Port, Buffer, DataCount);
462 }
463 else
464 {
465 PBYTE Address = (PBYTE)Buffer;
466
467 while (DataCount--)
468 {
469 ULONG CurrentPort = Port;
470 ULONG Count;
471 UCHAR NewDataSize = DataSize;
472
473 /* Write dword */
474 Count = NewDataSize / sizeof(ULONG);
475 NewDataSize = NewDataSize % sizeof(ULONG);
476 while (Count--)
477 {
478 IOWriteD(CurrentPort, (PULONG)Address);
479 CurrentPort += sizeof(ULONG);
480 Address += sizeof(ULONG);
481 }
482
483 /* Write word */
484 Count = NewDataSize / sizeof(USHORT);
485 NewDataSize = NewDataSize % sizeof(USHORT);
486 while (Count--)
487 {
488 IOWriteW(CurrentPort, (PUSHORT)Address);
489 CurrentPort += sizeof(USHORT);
490 Address += sizeof(USHORT);
491 }
492
493 /* Write byte */
494 Count = NewDataSize / sizeof(UCHAR);
495 NewDataSize = NewDataSize % sizeof(UCHAR);
496 while (Count--)
497 {
498 IOWriteB(CurrentPort, (PUCHAR)Address);
499 CurrentPort += sizeof(UCHAR);
500 Address += sizeof(UCHAR);
501 }
502
503 ASSERT(Count == 0);
504 ASSERT(NewDataSize == 0);
505 }
506 }
507 }
508
509
510
511 BOOL
512 WINAPI
513 VDDInstallIOHook(HANDLE hVdd,
514 WORD cPortRange,
515 PVDD_IO_PORTRANGE pPortRange,
516 PVDD_IO_HANDLERS IOhandler)
517 {
518 /* Check possible validity of the VDD handle */
519 if (hVdd == 0 || hVdd == INVALID_HANDLE_VALUE) return FALSE;
520
521 /* Loop for each range of I/O ports */
522 while (cPortRange--)
523 {
524 WORD i;
525
526 /* Register the range of I/O ports */
527 for (i = pPortRange->First; i <= pPortRange->Last; ++i)
528 {
529 /*
530 * Don't do anything if the I/O port is already
531 * handled internally or externally.
532 */
533 if (IoPortProc[i].hVdd != 0)
534 {
535 DPRINT1("IoPortProc[0x%X] already registered\n", i);
536 continue;
537 }
538
539 /* Register wrt. the VDD */
540 IoPortProc[i].hVdd = hVdd;
541
542 /* Disable the internal handlers */
543 IoPortProc[i].IoHandlers.InB = NULL;
544 IoPortProc[i].IoHandlers.InW = NULL;
545 IoPortProc[i].IoHandlers.InD = NULL;
546
547 IoPortProc[i].IoHandlers.InsB = NULL;
548 IoPortProc[i].IoHandlers.InsW = NULL;
549 IoPortProc[i].IoHandlers.InsD = NULL;
550
551 IoPortProc[i].IoHandlers.OutB = NULL;
552 IoPortProc[i].IoHandlers.OutW = NULL;
553 IoPortProc[i].IoHandlers.OutD = NULL;
554
555 IoPortProc[i].IoHandlers.OutsB = NULL;
556 IoPortProc[i].IoHandlers.OutsW = NULL;
557 IoPortProc[i].IoHandlers.OutsD = NULL;
558
559 /* Save our handlers */
560 IoPortProc[i].VddIoHandlers = *IOhandler;
561 }
562
563 /* Go to the next range */
564 ++pPortRange;
565 ++IOhandler;
566 }
567
568 return TRUE;
569 }
570
571 VOID
572 WINAPI
573 VDDDeInstallIOHook(HANDLE hVdd,
574 WORD cPortRange,
575 PVDD_IO_PORTRANGE pPortRange)
576 {
577 /* Check possible validity of the VDD handle */
578 if (hVdd == 0 || hVdd == INVALID_HANDLE_VALUE) return;
579
580 /* Loop for each range of I/O ports */
581 while (cPortRange--)
582 {
583 WORD i;
584
585 /* Unregister the range of I/O ports */
586 for (i = pPortRange->First; i <= pPortRange->Last; ++i)
587 {
588 /*
589 * Don't do anything if we don't own the I/O port.
590 */
591 if (IoPortProc[i].hVdd != hVdd)
592 {
593 DPRINT1("IoPortProc[0x%X] owned by somebody else\n", i);
594 continue;
595 }
596
597 /*
598 * Put automagically all the fields to zero:
599 * the hVdd gets unregistered as well as all the handlers.
600 */
601 // IoPortProc[i] = {NULL};
602 ZeroMemory(&IoPortProc[i], sizeof(IoPortProc[i]));
603 }
604
605 /* Go to the next range */
606 ++pPortRange;
607 }
608 }
609
610 /* EOF */