VirtualBox

source: vbox/trunk/src/VBox/Devices/PC/DevDMA.cpp@ 89394

Last change on this file since 89394 was 87127, checked in by vboxsync, 4 years ago

DMA,PDM: Pass the pDevIns of the caller to PDMDMAREG::pfnRegister. DMA controller now locks all registered DMA devices before doing callbacks, as it is in the best position to deal with the lock order inversion issue. bugref:9888
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 45.8 KB
Line 
1/* $Id: DevDMA.cpp 87127 2020-12-25 13:10:15Z vboxsync $ */
2/** @file
3 * DevDMA - DMA Controller Device.
4 */
5
6/*
7 * Copyright (C) 2006-2020 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 * --------------------------------------------------------------------
17 *
18 * This code is loosely based on:
19 *
20 * QEMU DMA emulation
21 *
22 * Copyright (c) 2003 Vassili Karpov (malc)
23 *
24 * Permission is hereby granted, free of charge, to any person obtaining a copy
25 * of this software and associated documentation files (the "Software"), to deal
26 * in the Software without restriction, including without limitation the rights
27 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
28 * copies of the Software, and to permit persons to whom the Software is
29 * furnished to do so, subject to the following conditions:
30 *
31 * The above copyright notice and this permission notice shall be included in
32 * all copies or substantial portions of the Software.
33 *
34 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
35 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
36 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
37 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
38 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
39 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
40 * THE SOFTWARE.
41 */
42
43
44/*********************************************************************************************************************************
45* Header Files *
46*********************************************************************************************************************************/
47#define LOG_GROUP LOG_GROUP_DEV_DMA
48#include <VBox/vmm/pdmdev.h>
49#include <VBox/err.h>
50
51#include <VBox/AssertGuest.h>
52#include <VBox/log.h>
53#include <iprt/assert.h>
54#include <iprt/string.h>
55
56#include "VBoxDD.h"
57
58
59/** @page pg_dev_dma DMA Overview and notes
60 *
61 * Modern PCs typically emulate AT-compatible DMA. The IBM PC/AT used dual
62 * cascaded 8237A DMA controllers, augmented with a 74LS612 memory mapper.
63 * The 8237As are 8-bit parts, only capable of addressing up to 64KB; the
64 * 74LS612 extends addressing to 24 bits. That leads to well known and
65 * inconvenient DMA limitations:
66 * - DMA can only access physical memory under the 16MB line
67 * - DMA transfers must occur within a 64KB/128KB 'page'
68 *
69 * The 16-bit DMA controller added in the PC/AT shifts all 8237A addresses
70 * left by one, including the control registers addresses. The DMA register
71 * offsets (except for the page registers) are therefore "double spaced".
72 *
73 * Due to the address shifting, the DMA controller decodes more addresses
74 * than are usually documented, with aliasing. See the ICH8 datasheet.
75 *
76 * In the IBM PC and PC/XT, DMA channel 0 was used for memory refresh, thus
77 * preventing the use of memory-to-memory DMA transfers (which use channels
78 * 0 and 1). In the PC/AT, memory-to-memory DMA was theoretically possible.
79 * However, it would transfer a single byte at a time, while the CPU can
80 * transfer two (on a 286) or four (on a 386+) bytes at a time. On many
81 * compatibles, memory-to-memory DMA is not even implemented at all, and
82 * therefore has no practical use.
83 *
84 * Auto-init mode is handled implicitly; a device's transfer handler may
85 * return an end count lower than the start count.
86 *
87 * Naming convention: 'channel' refers to a system-wide DMA channel (0-7)
88 * while 'chidx' refers to a DMA channel index within a controller (0-3).
89 *
90 * References:
91 * - IBM Personal Computer AT Technical Reference, 1984
92 * - Intel 8237A-5 Datasheet, 1993
93 * - Frank van Gilluwe, The Undocumented PC, 1994
94 * - OPTi 82C206 Data Book, 1996 (or Chips & Tech 82C206)
95 * - Intel ICH8 Datasheet, 2007
96 */
97
98
99/* Saved state versions. */
100#define DMA_SAVESTATE_OLD 1 /* The original saved state. */
101#define DMA_SAVESTATE_CURRENT 2 /* The new and improved saved state. */
102
103/* State information for a single DMA channel. */
104typedef struct {
105 PPDMDEVINS pDevInsHandler; /**< The device instance the channel is associated with. */
106 RTR3PTR pvUser; /* User specific context. */
107 R3PTRTYPE(PFNDMATRANSFERHANDLER) pfnXferHandler; /* Transfer handler for channel. */
108 uint16_t u16BaseAddr; /* Base address for transfers. */
109 uint16_t u16BaseCount; /* Base count for transfers. */
110 uint16_t u16CurAddr; /* Current address. */
111 uint16_t u16CurCount; /* Current count. */
112 uint8_t u8Mode; /* Channel mode. */
113 uint8_t abPadding[7];
114} DMAChannel, DMACHANNEL;
115typedef DMACHANNEL *PDMACHANNEL;
116
117/* State information for a DMA controller (DMA8 or DMA16). */
118typedef struct {
119 DMAChannel ChState[4]; /* Per-channel state. */
120 uint8_t au8Page[8]; /* Page registers (A16-A23). */
121 uint8_t au8PageHi[8]; /* High page registers (A24-A31). */
122 uint8_t u8Command; /* Command register. */
123 uint8_t u8Status; /* Status register. */
124 uint8_t u8Mask; /* Mask register. */
125 uint8_t u8Temp; /* Temporary (mem/mem) register. */
126 uint8_t u8ModeCtr; /* Mode register counter for reads. */
127 bool fHiByte; /* Byte pointer (T/F -> high/low). */
128 uint8_t abPadding0[2];
129 uint32_t is16bit; /* True for 16-bit DMA. */
130 uint8_t abPadding1[4];
131 /** The base abd current address I/O port registration. */
132 IOMIOPORTHANDLE hIoPortBase;
133 /** The control register I/O port registration. */
134 IOMIOPORTHANDLE hIoPortCtl;
135 /** The page registers I/O port registration. */
136 IOMIOPORTHANDLE hIoPortPage;
137 /** The EISA style high page registers I/O port registration. */
138 IOMIOPORTHANDLE hIoPortHi;
139} DMAControl, DMACONTROLLER;
140/** Pointer to the shared DMA controller state. */
141typedef DMACONTROLLER *PDMACONTROLLER;
142
143/* Complete DMA state information. */
144typedef struct {
145 DMAControl DMAC[2]; /* Two DMA controllers. */
146 PPDMDEVINSR3 pDevIns; /* Device instance. */
147 R3PTRTYPE(PCPDMDMACHLP) pHlp; /* PDM DMA helpers. */
148 STAMPROFILE StatRun;
149} DMAState, DMASTATE;
150/** Pointer to the shared DMA state information. */
151typedef DMASTATE *PDMASTATE;
152
153/* DMA command register bits. */
154enum {
155 CMD_MEMTOMEM = 0x01, /* Enable mem-to-mem trasfers. */
156 CMD_ADRHOLD = 0x02, /* Address hold for mem-to-mem. */
157 CMD_DISABLE = 0x04, /* Disable controller. */
158 CMD_COMPRTIME = 0x08, /* Compressed timing. */
159 CMD_ROTPRIO = 0x10, /* Rotating priority. */
160 CMD_EXTWR = 0x20, /* Extended write. */
161 CMD_DREQHI = 0x40, /* DREQ is active high if set. */
162 CMD_DACKHI = 0x80, /* DACK is active high if set. */
163 CMD_UNSUPPORTED = CMD_MEMTOMEM | CMD_ADRHOLD | CMD_COMPRTIME
164 | CMD_EXTWR | CMD_DREQHI | CMD_DACKHI
165};
166
167/* DMA control register offsets for read accesses. */
168enum {
169 CTL_R_STAT, /* Read status registers. */
170 CTL_R_DMAREQ, /* Read DRQ register. */
171 CTL_R_CMD, /* Read command register. */
172 CTL_R_MODE, /* Read mode register. */
173 CTL_R_SETBPTR, /* Set byte pointer flip-flop. */
174 CTL_R_TEMP, /* Read temporary register. */
175 CTL_R_CLRMODE, /* Clear mode register counter. */
176 CTL_R_MASK /* Read all DRQ mask bits. */
177};
178
179/* DMA control register offsets for read accesses. */
180enum {
181 CTL_W_CMD, /* Write command register. */
182 CTL_W_DMAREQ, /* Write DRQ register. */
183 CTL_W_MASKONE, /* Write single DRQ mask bit. */
184 CTL_W_MODE, /* Write mode register. */
185 CTL_W_CLRBPTR, /* Clear byte pointer flip-flop. */
186 CTL_W_MASTRCLR, /* Master clear. */
187 CTL_W_CLRMASK, /* Clear all DRQ mask bits. */
188 CTL_W_MASK /* Write all DRQ mask bits. */
189};
190
191/* DMA transfer modes. */
192enum {
193 DMODE_DEMAND, /* Demand transfer mode. */
194 DMODE_SINGLE, /* Single transfer mode. */
195 DMODE_BLOCK, /* Block transfer mode. */
196 DMODE_CASCADE /* Cascade mode. */
197};
198
199/* DMA transfer types. */
200enum {
201 DTYPE_VERIFY, /* Verify transfer type. */
202 DTYPE_WRITE, /* Write transfer type. */
203 DTYPE_READ, /* Read transfer type. */
204 DTYPE_ILLEGAL /* Undefined. */
205};
206
207#ifndef VBOX_DEVICE_STRUCT_TESTCASE
208
209
210/* Convert DMA channel number (0-7) to controller number (0-1). */
211#define DMACH2C(c) (c < 4 ? 0 : 1)
212
213#ifdef LOG_ENABLED
214static int const g_aiDmaChannelMap[8] = {-1, 2, 3, 1, -1, -1, -1, 0};
215/* Map a DMA page register offset (0-7) to channel index (0-3). */
216# define DMAPG2CX(c) (g_aiDmaChannelMap[c])
217#endif
218
219#ifdef IN_RING3
220static int const g_aiDmaMapChannel[4] = {7, 3, 1, 2};
221/* Map a channel index (0-3) to DMA page register offset (0-7). */
222# define DMACX2PG(c) (g_aiDmaMapChannel[c])
223/* Map a channel number (0-7) to DMA page register offset (0-7). */
224# define DMACH2PG(c) (g_aiDmaMapChannel[c & 3])
225#endif
226
227/* Test the decrement bit of mode register. */
228#define IS_MODE_DEC(c) ((c) & 0x20)
229/* Test the auto-init bit of mode register. */
230#define IS_MODE_AI(c) ((c) & 0x10)
231/* Extract the transfer type bits of mode register. */
232#define GET_MODE_XTYP(c) (((c) & 0x0c) >> 2)
233
234
235/* Perform a master clear (reset) on a DMA controller. */
236static void dmaClear(DMAControl *dc)
237{
238 dc->u8Command = 0;
239 dc->u8Status = 0;
240 dc->u8Temp = 0;
241 dc->u8ModeCtr = 0;
242 dc->fHiByte = false;
243 dc->u8Mask = UINT8_MAX;
244}
245
246
247/** Read the byte pointer and flip it. */
248DECLINLINE(bool) dmaReadBytePtr(DMAControl *dc)
249{
250 bool fHighByte = !!dc->fHiByte;
251 dc->fHiByte ^= 1;
252 return fHighByte;
253}
254
255
256/* DMA address registers writes and reads. */
257
258/**
259 * @callback_method_impl{FNIOMIOPORTOUT, Ports 0-7 & 0xc0-0xcf}
260 */
261static DECLCALLBACK(VBOXSTRICTRC) dmaWriteAddr(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
262{
263 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
264 RT_NOREF(pDevIns);
265 if (cb == 1)
266 {
267 unsigned const reg = (offPort >> dc->is16bit) & 0x0f;
268 unsigned const chidx = reg >> 1;
269 unsigned const is_count = reg & 1;
270 PDMACHANNEL ch = &RT_SAFE_SUBSCRIPT(dc->ChState, chidx);
271 Assert(!(u32 & ~0xff)); /* Check for garbage in high bits. */
272
273 if (dmaReadBytePtr(dc))
274 {
275 /* Write the high byte. */
276 if (is_count)
277 ch->u16BaseCount = RT_MAKE_U16(ch->u16BaseCount, u32);
278 else
279 ch->u16BaseAddr = RT_MAKE_U16(ch->u16BaseAddr, u32);
280
281 ch->u16CurCount = 0;
282 ch->u16CurAddr = ch->u16BaseAddr;
283 }
284 else
285 {
286 /* Write the low byte. */
287 if (is_count)
288 ch->u16BaseCount = RT_MAKE_U16(u32, RT_HIBYTE(ch->u16BaseCount));
289 else
290 ch->u16BaseAddr = RT_MAKE_U16(u32, RT_HIBYTE(ch->u16BaseAddr));
291 }
292 Log2(("dmaWriteAddr/%u: offPort %#06x, chidx %d, data %#02x\n", dc->is16bit, offPort, chidx, u32));
293 }
294 else
295 {
296 /* Likely a guest bug. */
297 Log(("dmaWriteAddr/%u: Bad size write to count register %#x (size %d, data %#x)\n", dc->is16bit, offPort, cb, u32));
298 }
299 return VINF_SUCCESS;
300}
301
302
303/**
304 * @callback_method_impl{FNIOMIOPORTIN, Ports 0-7 & 0xc0-0xcf}
305 */
306static DECLCALLBACK(VBOXSTRICTRC) dmaReadAddr(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
307{
308 RT_NOREF(pDevIns);
309 if (cb == 1)
310 {
311 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
312 unsigned const reg = (offPort >> dc->is16bit) & 0x0f;
313 unsigned const chidx = reg >> 1;
314 PDMACHANNEL ch = &RT_SAFE_SUBSCRIPT(dc->ChState, chidx);
315 int const dir = IS_MODE_DEC(ch->u8Mode) ? -1 : 1;
316 int val;
317 int bptr;
318
319 if (reg & 1)
320 val = ch->u16BaseCount - ch->u16CurCount;
321 else
322 val = ch->u16CurAddr + ch->u16CurCount * dir;
323
324 bptr = dmaReadBytePtr(dc);
325 *pu32 = RT_LOBYTE(val >> (bptr * 8));
326
327 Log(("dmaReadAddr/%u: Count read: offPort %#06x, reg %#04x, data %#x\n", dc->is16bit, offPort, reg, val));
328 return VINF_SUCCESS;
329 }
330 return VERR_IOM_IOPORT_UNUSED;
331}
332
333/* DMA control registers writes and reads. */
334
335/**
336 * @callback_method_impl{FNIOMIOPORTOUT, Ports 0x8-0xf & 0xd0-0xdf}
337 */
338static DECLCALLBACK(VBOXSTRICTRC) dmaWriteCtl(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
339{
340 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
341 RT_NOREF(pDevIns);
342 if (cb == 1)
343 {
344 unsigned chidx = 0;
345 unsigned const reg = (offPort >> dc->is16bit) & 0x0f;
346 Assert((int)reg >= CTL_W_CMD && reg <= CTL_W_MASK);
347 Assert(!(u32 & ~0xff)); /* Check for garbage in high bits. */
348
349 switch (reg) {
350 case CTL_W_CMD:
351 /* Unsupported commands are entirely ignored. */
352 if (u32 & CMD_UNSUPPORTED)
353 {
354 Log(("dmaWriteCtl/%u: DMA command %#x is not supported, ignoring!\n", dc->is16bit, u32));
355 break;
356 }
357 dc->u8Command = u32;
358 break;
359 case CTL_W_DMAREQ:
360 chidx = u32 & 3;
361 if (u32 & 4)
362 dc->u8Status |= 1 << (chidx + 4);
363 else
364 dc->u8Status &= ~(1 << (chidx + 4));
365 dc->u8Status &= ~(1 << chidx); /* Clear TC for channel. */
366 break;
367 case CTL_W_MASKONE:
368 chidx = u32 & 3;
369 if (u32 & 4)
370 dc->u8Mask |= 1 << chidx;
371 else
372 dc->u8Mask &= ~(1 << chidx);
373 break;
374 case CTL_W_MODE:
375 chidx = u32 & 3;
376 dc->ChState[chidx].u8Mode = u32;
377 Log2(("dmaWriteCtl/%u: chidx %d, op %d, %sauto-init, %screment, opmode %d\n", dc->is16bit,
378 chidx, (u32 >> 2) & 3, IS_MODE_AI(u32) ? "" : "no ", IS_MODE_DEC(u32) ? "de" : "in", (u32 >> 6) & 3));
379 break;
380 case CTL_W_CLRBPTR:
381 dc->fHiByte = false;
382 break;
383 case CTL_W_MASTRCLR:
384 dmaClear(dc);
385 break;
386 case CTL_W_CLRMASK:
387 dc->u8Mask = 0;
388 break;
389 case CTL_W_MASK:
390 dc->u8Mask = u32;
391 break;
392 default:
393 ASSERT_GUEST_MSG_FAILED(("reg=%u\n", reg));
394 break;
395 }
396 Log(("dmaWriteCtl/%u: offPort %#06x, chidx %d, data %#02x\n", dc->is16bit, offPort, chidx, u32));
397 }
398 else
399 {
400 /* Likely a guest bug. */
401 Log(("dmaWriteCtl/%u: Bad size write to controller register %#x (size %d, data %#x)\n", dc->is16bit, offPort, cb, u32));
402 }
403 return VINF_SUCCESS;
404}
405
406
407/**
408 * @callback_method_impl{FNIOMIOPORTIN, Ports 0x8-0xf & 0xd0-0xdf}
409 */
410static DECLCALLBACK(VBOXSTRICTRC) dmaReadCtl(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
411{
412 RT_NOREF(pDevIns);
413 if (cb == 1)
414 {
415 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
416 uint8_t val = 0;
417
418 unsigned const reg = (offPort >> dc->is16bit) & 0x0f;
419 Assert((int)reg >= CTL_R_STAT && reg <= CTL_R_MASK);
420
421 switch (reg)
422 {
423 case CTL_R_STAT:
424 val = dc->u8Status;
425 dc->u8Status &= 0xf0; /* A read clears all TCs. */
426 break;
427 case CTL_R_DMAREQ:
428 val = (dc->u8Status >> 4) | 0xf0;
429 break;
430 case CTL_R_CMD:
431 val = dc->u8Command;
432 break;
433 case CTL_R_MODE:
434 val = RT_SAFE_SUBSCRIPT(dc->ChState, dc->u8ModeCtr).u8Mode | 3;
435 dc->u8ModeCtr = (dc->u8ModeCtr + 1) & 3;
436 break;
437 case CTL_R_SETBPTR:
438 dc->fHiByte = true;
439 break;
440 case CTL_R_TEMP:
441 val = dc->u8Temp;
442 break;
443 case CTL_R_CLRMODE:
444 dc->u8ModeCtr = 0;
445 break;
446 case CTL_R_MASK:
447 val = dc->u8Mask;
448 break;
449 default:
450 Assert(0);
451 break;
452 }
453
454 Log(("dmaReadCtl/%u: Ctrl read: offPort %#06x, reg %#04x, data %#x\n", dc->is16bit, offPort, reg, val));
455 *pu32 = val;
456
457 return VINF_SUCCESS;
458 }
459 return VERR_IOM_IOPORT_UNUSED;
460}
461
462
463
464/**
465 * @callback_method_impl{FNIOMIOPORTIN,
466 * DMA page registers - Ports 0x80-0x87 & 0x88-0x8f}
467 *
468 * There are 16 R/W page registers for compatibility with the IBM PC/AT; only
469 * some of those registers are used for DMA. The page register accessible via
470 * port 80h may be read to insert small delays or used as a scratch register by
471 * a BIOS.
472 */
473static DECLCALLBACK(VBOXSTRICTRC) dmaReadPage(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
474{
475 RT_NOREF(pDevIns);
476 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
477 int reg;
478
479 if (cb == 1)
480 {
481 reg = offPort & 7;
482 *pu32 = dc->au8Page[reg];
483 Log2(("dmaReadPage/%u: Read %#x (byte) from page register %#x (channel %d)\n", dc->is16bit, *pu32, offPort, DMAPG2CX(reg)));
484 return VINF_SUCCESS;
485 }
486
487 if (cb == 2)
488 {
489 reg = offPort & 7;
490 *pu32 = dc->au8Page[reg] | (dc->au8Page[(reg + 1) & 7] << 8);
491 Log2(("dmaReadPage/%u: Read %#x (word) from page register %#x (channel %d)\n", dc->is16bit, *pu32, offPort, DMAPG2CX(reg)));
492 return VINF_SUCCESS;
493 }
494
495 return VERR_IOM_IOPORT_UNUSED;
496}
497
498
499/**
500 * @callback_method_impl{FNIOMIOPORTOUT,
501 * DMA page registers - Ports 0x80-0x87 & 0x88-0x8f}
502 */
503static DECLCALLBACK(VBOXSTRICTRC) dmaWritePage(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
504{
505 RT_NOREF(pDevIns);
506 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
507 unsigned reg;
508
509 if (cb == 1)
510 {
511 Assert(!(u32 & ~0xff)); /* Check for garbage in high bits. */
512 reg = offPort & 7;
513 dc->au8Page[reg] = u32;
514 dc->au8PageHi[reg] = 0; /* Corresponding high page cleared. */
515 Log2(("dmaWritePage/%u: Wrote %#x to page register %#x (channel %d)\n", dc->is16bit, u32, offPort, DMAPG2CX(reg)));
516 }
517 else if (cb == 2)
518 {
519 Assert(!(u32 & ~0xffff)); /* Check for garbage in high bits. */
520 reg = offPort & 7;
521 dc->au8Page[reg] = u32;
522 dc->au8PageHi[reg] = 0; /* Corresponding high page cleared. */
523 reg = (offPort + 1) & 7;
524 dc->au8Page[reg] = u32 >> 8;
525 dc->au8PageHi[reg] = 0; /* Corresponding high page cleared. */
526 }
527 else
528 {
529 /* Likely a guest bug. */
530 Log(("dmaWritePage/%u: Bad size write to page register %#x (size %d, data %#x)\n", dc->is16bit, offPort, cb, u32));
531 }
532 return VINF_SUCCESS;
533}
534
535
536/**
537 * @callback_method_impl{FNIOMIOPORTIN,
538 * EISA style high page registers for extending the DMA addresses to cover
539 * the entire 32-bit address space. Ports 0x480-0x487 & 0x488-0x48f}
540 */
541static DECLCALLBACK(VBOXSTRICTRC) dmaReadHiPage(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
542{
543 RT_NOREF(pDevIns);
544 if (cb == 1)
545 {
546 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
547 unsigned const reg = offPort & 7;
548
549 *pu32 = dc->au8PageHi[reg];
550 Log2(("dmaReadHiPage/%u: Read %#x to from high page register %#x (channel %d)\n", dc->is16bit, *pu32, offPort, DMAPG2CX(reg)));
551 return VINF_SUCCESS;
552 }
553 return VERR_IOM_IOPORT_UNUSED;
554}
555
556
557/**
558 * @callback_method_impl{FNIOMIOPORTOUT, Ports 0x480-0x487 & 0x488-0x48f}
559 */
560static DECLCALLBACK(VBOXSTRICTRC) dmaWriteHiPage(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
561{
562 RT_NOREF(pDevIns);
563 PDMACONTROLLER dc = (PDMACONTROLLER)pvUser;
564 if (cb == 1)
565 {
566 unsigned const reg = offPort & 7;
567
568 Assert(!(u32 & ~0xff)); /* Check for garbage in high bits. */
569 dc->au8PageHi[reg] = u32;
570 Log2(("dmaWriteHiPage/%u: Wrote %#x to high page register %#x (channel %d)\n", dc->is16bit, u32, offPort, DMAPG2CX(reg)));
571 }
572 else
573 {
574 /* Likely a guest bug. */
575 Log(("dmaWriteHiPage/%u: Bad size write to high page register %#x (size %d, data %#x)\n", dc->is16bit, offPort, cb, u32));
576 }
577 return VINF_SUCCESS;
578}
579
580
581#ifdef IN_RING3
582
583/** Perform any pending transfers on a single DMA channel. */
584static void dmaR3RunChannel(DMAState *pThis, int ctlidx, int chidx)
585{
586 DMAControl *dc = &pThis->DMAC[ctlidx];
587 DMAChannel *ch = &dc->ChState[chidx];
588 uint32_t start_cnt, end_cnt;
589 int opmode;
590
591 opmode = (ch->u8Mode >> 6) & 3;
592
593 Log3(("DMA address %screment, mode %d\n", IS_MODE_DEC(ch->u8Mode) ? "de" : "in", ch->u8Mode >> 6));
594 AssertReturnVoid(ch->pfnXferHandler);
595
596 /* Addresses and counts are shifted for 16-bit channels. */
597 start_cnt = ch->u16CurCount << dc->is16bit;
598 /* NB: The device is responsible for examining the DMA mode and not
599 * transferring more than it should if auto-init is not in use.
600 */
601 end_cnt = ch->pfnXferHandler(ch->pDevInsHandler, ch->pvUser, (ctlidx * 4) + chidx,
602 start_cnt, (ch->u16BaseCount + 1) << dc->is16bit);
603 ch->u16CurCount = end_cnt >> dc->is16bit;
604 /* Set the TC (Terminal Count) bit if transfer was completed. */
605 if (ch->u16CurCount == ch->u16BaseCount + 1)
606 switch (opmode)
607 {
608 case DMODE_DEMAND:
609 case DMODE_SINGLE:
610 case DMODE_BLOCK:
611 dc->u8Status |= RT_BIT(chidx);
612 Log3(("TC set for DMA channel %d\n", (ctlidx * 4) + chidx));
613 break;
614 default:
615 break;
616 }
617 Log3(("DMA position %d, size %d\n", end_cnt, (ch->u16BaseCount + 1) << dc->is16bit));
618}
619
620/**
621 * @interface_method_impl{PDMDMAREG,pfnRun}
622 */
623static DECLCALLBACK(bool) dmaR3Run(PPDMDEVINS pDevIns)
624{
625 DMAState *pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
626 DMAControl *dc;
627 int chidx, mask;
628
629 STAM_PROFILE_START(&pThis->StatRun, a);
630
631 /* We must first lock all the devices then the DMAC or we end up with a
632 lock order validation when the callback helpers (PDMDMACREG) are being
633 invoked from I/O port and MMIO callbacks in channel devices. While this
634 may sound a little brutish, it's actually in line with the bus locking
635 the original DMAC did back in the days. Besides, we've only got the FDC
636 and SB16 as potential customers here at present, so hardly a problem. */
637 for (unsigned idxCtl = 0; idxCtl < RT_ELEMENTS(pThis->DMAC); idxCtl++)
638 for (unsigned idxCh = 0; idxCh < RT_ELEMENTS(pThis->DMAC[idxCtl].ChState); idxCh++)
639 if (pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler)
640 PDMDevHlpCritSectEnter(pDevIns, pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler->pCritSectRoR3, VERR_IGNORED);
641 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
642
643 /* Run all controllers and channels. */
644 for (unsigned ctlidx = 0; ctlidx < RT_ELEMENTS(pThis->DMAC); ++ctlidx)
645 {
646 dc = &pThis->DMAC[ctlidx];
647
648 /* If controller is disabled, don't even bother. */
649 if (dc->u8Command & CMD_DISABLE)
650 continue;
651
652 for (chidx = 0; chidx < 4; ++chidx)
653 {
654 mask = 1 << chidx;
655 if (!(dc->u8Mask & mask) && (dc->u8Status & (mask << 4)))
656 dmaR3RunChannel(pThis, ctlidx, chidx);
657 }
658 }
659
660 /* Unlock everything (order is mostly irrelevant). */
661 for (unsigned idxCtl = 0; idxCtl < RT_ELEMENTS(pThis->DMAC); idxCtl++)
662 for (unsigned idxCh = 0; idxCh < RT_ELEMENTS(pThis->DMAC[idxCtl].ChState); idxCh++)
663 if (pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler)
664 PDMDevHlpCritSectLeave(pDevIns, pThis->DMAC[idxCtl].ChState[idxCh].pDevInsHandler->pCritSectRoR3);
665 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
666
667 STAM_PROFILE_STOP(&pThis->StatRun, a);
668 return 0;
669}
670
671/**
672 * @interface_method_impl{PDMDMAREG,pfnRegister}
673 */
674static DECLCALLBACK(void) dmaR3Register(PPDMDEVINS pDevIns, unsigned uChannel, PPDMDEVINS pDevInsHandler,
675 PFNDMATRANSFERHANDLER pfnTransferHandler, void *pvUser)
676{
677 DMAState *pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
678 DMAChannel *ch = &pThis->DMAC[DMACH2C(uChannel)].ChState[uChannel & 3];
679
680 LogFlow(("dmaR3Register: pThis=%p uChannel=%u pfnTransferHandler=%p pvUser=%p\n", pThis, uChannel, pfnTransferHandler, pvUser));
681
682 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
683 ch->pDevInsHandler = pDevInsHandler;
684 ch->pfnXferHandler = pfnTransferHandler;
685 ch->pvUser = pvUser;
686 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
687}
688
689/** Reverse the order of bytes in a memory buffer. */
690static void dmaReverseBuf8(void *buf, unsigned len)
691{
692 uint8_t *pBeg, *pEnd;
693 uint8_t temp;
694
695 pBeg = (uint8_t *)buf;
696 pEnd = pBeg + len - 1;
697 for (len = len / 2; len; --len)
698 {
699 temp = *pBeg;
700 *pBeg++ = *pEnd;
701 *pEnd-- = temp;
702 }
703}
704
705/** Reverse the order of words in a memory buffer. */
706static void dmaReverseBuf16(void *buf, unsigned len)
707{
708 uint16_t *pBeg, *pEnd;
709 uint16_t temp;
710
711 Assert(!(len & 1));
712 len /= 2; /* Convert to word count. */
713 pBeg = (uint16_t *)buf;
714 pEnd = pBeg + len - 1;
715 for (len = len / 2; len; --len)
716 {
717 temp = *pBeg;
718 *pBeg++ = *pEnd;
719 *pEnd-- = temp;
720 }
721}
722
723/**
724 * @interface_method_impl{PDMDMAREG,pfnReadMemory}
725 */
726static DECLCALLBACK(uint32_t) dmaR3ReadMemory(PPDMDEVINS pDevIns, unsigned uChannel,
727 void *pvBuffer, uint32_t off, uint32_t cbBlock)
728{
729 DMAState *pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
730 DMAControl *dc = &pThis->DMAC[DMACH2C(uChannel)];
731 DMAChannel *ch = &dc->ChState[uChannel & 3];
732 uint32_t page, pagehi;
733 uint32_t addr;
734
735 LogFlow(("dmaR3ReadMemory: pThis=%p uChannel=%u pvBuffer=%p off=%u cbBlock=%u\n", pThis, uChannel, pvBuffer, off, cbBlock));
736
737 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
738
739 /* Build the address for this transfer. */
740 page = dc->au8Page[DMACH2PG(uChannel)] & ~dc->is16bit;
741 pagehi = dc->au8PageHi[DMACH2PG(uChannel)];
742 addr = (pagehi << 24) | (page << 16) | (ch->u16CurAddr << dc->is16bit);
743
744 if (IS_MODE_DEC(ch->u8Mode))
745 {
746 PDMDevHlpPhysRead(pThis->pDevIns, addr - off - cbBlock, pvBuffer, cbBlock);
747 if (dc->is16bit)
748 dmaReverseBuf16(pvBuffer, cbBlock);
749 else
750 dmaReverseBuf8(pvBuffer, cbBlock);
751 }
752 else
753 PDMDevHlpPhysRead(pThis->pDevIns, addr + off, pvBuffer, cbBlock);
754
755 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
756 return cbBlock;
757}
758
759/**
760 * @interface_method_impl{PDMDMAREG,pfnWriteMemory}
761 */
762static DECLCALLBACK(uint32_t) dmaR3WriteMemory(PPDMDEVINS pDevIns, unsigned uChannel,
763 const void *pvBuffer, uint32_t off, uint32_t cbBlock)
764{
765 DMAState *pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
766 DMAControl *dc = &pThis->DMAC[DMACH2C(uChannel)];
767 DMAChannel *ch = &dc->ChState[uChannel & 3];
768 uint32_t page, pagehi;
769 uint32_t addr;
770
771 LogFlow(("dmaR3WriteMemory: pThis=%p uChannel=%u pvBuffer=%p off=%u cbBlock=%u\n", pThis, uChannel, pvBuffer, off, cbBlock));
772 if (GET_MODE_XTYP(ch->u8Mode) == DTYPE_VERIFY)
773 {
774 Log(("DMA verify transfer, ignoring write.\n"));
775 return cbBlock;
776 }
777
778 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
779
780 /* Build the address for this transfer. */
781 page = dc->au8Page[DMACH2PG(uChannel)] & ~dc->is16bit;
782 pagehi = dc->au8PageHi[DMACH2PG(uChannel)];
783 addr = (pagehi << 24) | (page << 16) | (ch->u16CurAddr << dc->is16bit);
784
785 if (IS_MODE_DEC(ch->u8Mode))
786 {
787 /// @todo This would need a temporary buffer.
788 Assert(0);
789#if 0
790 if (dc->is16bit)
791 dmaReverseBuf16(pvBuffer, cbBlock);
792 else
793 dmaReverseBuf8(pvBuffer, cbBlock);
794#endif
795 PDMDevHlpPhysWrite(pThis->pDevIns, addr - off - cbBlock, pvBuffer, cbBlock);
796 }
797 else
798 PDMDevHlpPhysWrite(pThis->pDevIns, addr + off, pvBuffer, cbBlock);
799
800 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
801 return cbBlock;
802}
803
804/**
805 * @interface_method_impl{PDMDMAREG,pfnSetDREQ}
806 */
807static DECLCALLBACK(void) dmaR3SetDREQ(PPDMDEVINS pDevIns, unsigned uChannel, unsigned uLevel)
808{
809 DMAState *pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
810 DMAControl *dc = &pThis->DMAC[DMACH2C(uChannel)];
811 int chidx;
812
813 LogFlow(("dmaR3SetDREQ: pThis=%p uChannel=%u uLevel=%u\n", pThis, uChannel, uLevel));
814
815 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
816 chidx = uChannel & 3;
817 if (uLevel)
818 dc->u8Status |= 1 << (chidx + 4);
819 else
820 dc->u8Status &= ~(1 << (chidx + 4));
821 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
822}
823
824/**
825 * @interface_method_impl{PDMDMAREG,pfnGetChannelMode}
826 */
827static DECLCALLBACK(uint8_t) dmaR3GetChannelMode(PPDMDEVINS pDevIns, unsigned uChannel)
828{
829 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
830
831 LogFlow(("dmaR3GetChannelMode: pThis=%p uChannel=%u\n", pThis, uChannel));
832
833 PDMDevHlpCritSectEnter(pDevIns, pDevIns->pCritSectRoR3, VERR_IGNORED);
834 uint8_t u8Mode = pThis->DMAC[DMACH2C(uChannel)].ChState[uChannel & 3].u8Mode;
835 PDMDevHlpCritSectLeave(pDevIns, pDevIns->pCritSectRoR3);
836 return u8Mode;
837}
838
839
840static void dmaR3SaveController(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, DMAControl *dc)
841{
842 /* Save controller state... */
843 pHlp->pfnSSMPutU8(pSSM, dc->u8Command);
844 pHlp->pfnSSMPutU8(pSSM, dc->u8Mask);
845 pHlp->pfnSSMPutU8(pSSM, dc->fHiByte);
846 pHlp->pfnSSMPutU32(pSSM, dc->is16bit);
847 pHlp->pfnSSMPutU8(pSSM, dc->u8Status);
848 pHlp->pfnSSMPutU8(pSSM, dc->u8Temp);
849 pHlp->pfnSSMPutU8(pSSM, dc->u8ModeCtr);
850 pHlp->pfnSSMPutMem(pSSM, &dc->au8Page, sizeof(dc->au8Page));
851 pHlp->pfnSSMPutMem(pSSM, &dc->au8PageHi, sizeof(dc->au8PageHi));
852
853 /* ...and all four of its channels. */
854 for (unsigned chidx = 0; chidx < RT_ELEMENTS(dc->ChState); ++chidx)
855 {
856 DMAChannel *ch = &dc->ChState[chidx];
857
858 pHlp->pfnSSMPutU16(pSSM, ch->u16CurAddr);
859 pHlp->pfnSSMPutU16(pSSM, ch->u16CurCount);
860 pHlp->pfnSSMPutU16(pSSM, ch->u16BaseAddr);
861 pHlp->pfnSSMPutU16(pSSM, ch->u16BaseCount);
862 pHlp->pfnSSMPutU8(pSSM, ch->u8Mode);
863 }
864}
865
866static int dmaR3LoadController(PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM, DMAControl *dc, int version)
867{
868 uint8_t u8val;
869 uint32_t u32val;
870
871 pHlp->pfnSSMGetU8(pSSM, &dc->u8Command);
872 pHlp->pfnSSMGetU8(pSSM, &dc->u8Mask);
873 pHlp->pfnSSMGetU8(pSSM, &u8val);
874 dc->fHiByte = !!u8val;
875 pHlp->pfnSSMGetU32(pSSM, &dc->is16bit);
876 if (version > DMA_SAVESTATE_OLD)
877 {
878 pHlp->pfnSSMGetU8(pSSM, &dc->u8Status);
879 pHlp->pfnSSMGetU8(pSSM, &dc->u8Temp);
880 pHlp->pfnSSMGetU8(pSSM, &dc->u8ModeCtr);
881 pHlp->pfnSSMGetMem(pSSM, &dc->au8Page, sizeof(dc->au8Page));
882 pHlp->pfnSSMGetMem(pSSM, &dc->au8PageHi, sizeof(dc->au8PageHi));
883 }
884
885 for (unsigned chidx = 0; chidx < RT_ELEMENTS(dc->ChState); ++chidx)
886 {
887 DMAChannel *ch = &dc->ChState[chidx];
888
889 if (version == DMA_SAVESTATE_OLD)
890 {
891 /* Convert from 17-bit to 16-bit format. */
892 pHlp->pfnSSMGetU32(pSSM, &u32val);
893 ch->u16CurAddr = u32val >> dc->is16bit;
894 pHlp->pfnSSMGetU32(pSSM, &u32val);
895 ch->u16CurCount = u32val >> dc->is16bit;
896 }
897 else
898 {
899 pHlp->pfnSSMGetU16(pSSM, &ch->u16CurAddr);
900 pHlp->pfnSSMGetU16(pSSM, &ch->u16CurCount);
901 }
902 pHlp->pfnSSMGetU16(pSSM, &ch->u16BaseAddr);
903 pHlp->pfnSSMGetU16(pSSM, &ch->u16BaseCount);
904 pHlp->pfnSSMGetU8(pSSM, &ch->u8Mode);
905 /* Convert from old save state. */
906 if (version == DMA_SAVESTATE_OLD)
907 {
908 /* Remap page register contents. */
909 pHlp->pfnSSMGetU8(pSSM, &u8val);
910 dc->au8Page[DMACX2PG(chidx)] = u8val;
911 pHlp->pfnSSMGetU8(pSSM, &u8val);
912 dc->au8PageHi[DMACX2PG(chidx)] = u8val;
913 /* Throw away dack, eop. */
914 pHlp->pfnSSMGetU8(pSSM, &u8val);
915 pHlp->pfnSSMGetU8(pSSM, &u8val);
916 }
917 }
918 return 0;
919}
920
921/** @callback_method_impl{FNSSMDEVSAVEEXEC} */
922static DECLCALLBACK(int) dmaR3SaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
923{
924 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
925 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
926
927 dmaR3SaveController(pHlp, pSSM, &pThis->DMAC[0]);
928 dmaR3SaveController(pHlp, pSSM, &pThis->DMAC[1]);
929 return VINF_SUCCESS;
930}
931
932/** @callback_method_impl{FNSSMDEVLOADEXEC} */
933static DECLCALLBACK(int) dmaR3LoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
934{
935 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
936 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
937
938 AssertMsgReturn(uVersion <= DMA_SAVESTATE_CURRENT, ("%d\n", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
939 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
940
941 dmaR3LoadController(pHlp, pSSM, &pThis->DMAC[0], uVersion);
942 return dmaR3LoadController(pHlp, pSSM, &pThis->DMAC[1], uVersion);
943}
944
945/** @callback_method_impl{FNDBGFHANDLERDEV} */
946static DECLCALLBACK(void) dmaR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
947{
948 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
949 NOREF(pszArgs);
950
951 /*
952 * Show info.
953 */
954 for (unsigned i = 0; i < RT_ELEMENTS(pThis->DMAC); i++)
955 {
956 PDMACONTROLLER pDmac = &pThis->DMAC[i];
957
958 pHlp->pfnPrintf(pHlp, "\nDMAC%d:\n", i);
959 pHlp->pfnPrintf(pHlp, " Status : %02X - DRQ 3210 TC 3210\n", pDmac->u8Status);
960 pHlp->pfnPrintf(pHlp, " %u%u%u%u %u%u%u%u\n",
961 !!(pDmac->u8Status & RT_BIT(7)), !!(pDmac->u8Status & RT_BIT(6)),
962 !!(pDmac->u8Status & RT_BIT(5)), !!(pDmac->u8Status & RT_BIT(4)),
963 !!(pDmac->u8Status & RT_BIT(3)), !!(pDmac->u8Status & RT_BIT(2)),
964 !!(pDmac->u8Status & RT_BIT(1)), !!(pDmac->u8Status & RT_BIT(0)));
965 pHlp->pfnPrintf(pHlp, " Mask : %02X - Chn 3210\n", pDmac->u8Mask);
966 pHlp->pfnPrintf(pHlp, " %u%u%u%u\n",
967 !!(pDmac->u8Mask & RT_BIT(3)), !!(pDmac->u8Mask & RT_BIT(2)),
968 !!(pDmac->u8Mask & RT_BIT(1)), !!(pDmac->u8Mask & RT_BIT(0)));
969 pHlp->pfnPrintf(pHlp, " Temp : %02x\n", pDmac->u8Temp);
970 pHlp->pfnPrintf(pHlp, " Command: %02X\n", pDmac->u8Command);
971 pHlp->pfnPrintf(pHlp, " DACK: active %s DREQ: active %s\n",
972 pDmac->u8Command & RT_BIT(7) ? "high" : "low ",
973 pDmac->u8Command & RT_BIT(6) ? "high" : "low ");
974 pHlp->pfnPrintf(pHlp, " Extended write: %s Priority: %s\n",
975 pDmac->u8Command & RT_BIT(5) ? "enabled " : "disabled",
976 pDmac->u8Command & RT_BIT(4) ? "rotating" : "fixed ");
977 pHlp->pfnPrintf(pHlp, " Timing: %s Controller: %s\n",
978 pDmac->u8Command & RT_BIT(3) ? "normal " : "compressed",
979 pDmac->u8Command & RT_BIT(2) ? "enabled " : "disabled");
980 pHlp->pfnPrintf(pHlp, " Adress Hold: %s Mem-to-Mem Ch 0/1: %s\n",
981 pDmac->u8Command & RT_BIT(1) ? "enabled " : "disabled",
982 pDmac->u8Command & RT_BIT(0) ? "enabled " : "disabled");
983
984 for (unsigned ch = 0; ch < RT_ELEMENTS(pDmac->ChState); ch++)
985 {
986 PDMACHANNEL pChan = &pDmac->ChState[ch];
987 const char *apszChanMode[] = { "demand ", "single ", "block ", "cascade" };
988 const char *apszChanType[] = { "verify ", "write ", "read ", "illegal" };
989
990 pHlp->pfnPrintf(pHlp, "\n DMA Channel %d: Page:%02X\n",
991 ch, pDmac->au8Page[DMACX2PG(ch)]);
992 pHlp->pfnPrintf(pHlp, " Mode : %02X Auto-init: %s %screment\n",
993 pChan->u8Mode, pChan->u8Mode & RT_BIT(4) ? "yes" : "no",
994 pChan->u8Mode & RT_BIT(5) ? "De" : "In" );
995 pHlp->pfnPrintf(pHlp, " Xfer Type: %s Mode: %s\n",
996 apszChanType[((pChan->u8Mode >> 2) & 3)],
997 apszChanMode[((pChan->u8Mode >> 6) & 3)]);
998 pHlp->pfnPrintf(pHlp, " Base address:%04X count:%04X\n",
999 pChan->u16BaseAddr, pChan->u16BaseCount);
1000 pHlp->pfnPrintf(pHlp, " Current address:%04X count:%04X\n",
1001 pChan->u16CurAddr, pChan->u16CurCount);
1002 }
1003 }
1004}
1005
1006/** @callback_method_impl{FNDBGFHANDLERDEV} */
1007static DECLCALLBACK(void) dmaR3InfoPageReg(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
1008{
1009 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
1010 NOREF(pszArgs);
1011
1012 /*
1013 * Show page register contents.
1014 */
1015 for (unsigned i = 0; i < RT_ELEMENTS(pThis->DMAC); i++)
1016 {
1017 PDMACONTROLLER pDmac = &pThis->DMAC[i];
1018
1019 pHlp->pfnPrintf(pHlp, "DMA page registers at %02X:", i == 0 ? 0x80 : 0x88);
1020 for (unsigned pg = 0; pg < RT_ELEMENTS(pDmac->au8Page); pg++)
1021 pHlp->pfnPrintf(pHlp, " %02X", pDmac->au8Page[pg]);
1022
1023 pHlp->pfnPrintf(pHlp, "\n");
1024 }
1025}
1026
1027/**
1028 * @interface_method_impl{PDMDEVREG,pfnReset}
1029 */
1030static DECLCALLBACK(void) dmaR3Reset(PPDMDEVINS pDevIns)
1031{
1032 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
1033
1034 LogFlow(("dmaR3Reset: pThis=%p\n", pThis));
1035
1036 /* NB: The page and address registers are unaffected by a reset
1037 * and in an undefined state after power-up.
1038 */
1039 dmaClear(&pThis->DMAC[0]);
1040 dmaClear(&pThis->DMAC[1]);
1041}
1042
1043/**
1044 * @interface_method_impl{PDMDEVREG,pfnConstruct}
1045 */
1046static DECLCALLBACK(int) dmaR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
1047{
1048 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
1049 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
1050 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1051 RT_NOREF(iInstance);
1052
1053 /*
1054 * Initialize data.
1055 */
1056 pThis->pDevIns = pDevIns;
1057
1058 DMAControl *pDC8 = &pThis->DMAC[0];
1059 DMAControl *pDC16 = &pThis->DMAC[1];
1060 pDC8->is16bit = false;
1061 pDC16->is16bit = true;
1062
1063 /*
1064 * Validate and read the configuration.
1065 */
1066 PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "HighPageEnable", "");
1067
1068 bool fHighPage = false;
1069 int rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "HighPageEnable", &fHighPage, false);
1070 AssertRCReturn(rc, rc);
1071
1072 /*
1073 * Register I/O callbacks.
1074 */
1075 /* Base and current address for each channel. */
1076 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x00, 8, dmaWriteAddr, dmaReadAddr, pDC8, "DMA8 Address", NULL, &pDC8->hIoPortBase);
1077 AssertLogRelRCReturn(rc, rc);
1078 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0xc0, 16, dmaWriteAddr, dmaReadAddr, pDC16, "DMA16 Address", NULL, &pDC16->hIoPortBase);
1079 AssertLogRelRCReturn(rc, rc);
1080
1081 /* Control registers for both DMA controllers. */
1082 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x08, 8, dmaWriteCtl, dmaReadCtl, pDC8, "DMA8 Control", NULL, &pDC8->hIoPortCtl);
1083 AssertLogRelRCReturn(rc, rc);
1084 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0xd0, 16, dmaWriteCtl, dmaReadCtl, pDC16, "DMA16 Control", NULL, &pDC16->hIoPortCtl);
1085 AssertLogRelRCReturn(rc, rc);
1086
1087 /* Page registers for each channel (plus a few unused ones). */
1088 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x80, 8, dmaWritePage, dmaReadPage, pDC8, "DMA8 Page", NULL, &pDC8->hIoPortPage);
1089 AssertLogRelRCReturn(rc, rc);
1090 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x88, 8, dmaWritePage, dmaReadPage, pDC16, "DMA16 Page", NULL, &pDC16->hIoPortPage);
1091 AssertLogRelRCReturn(rc, rc);
1092
1093 /* Optional EISA style high page registers (address bits 24-31). */
1094 if (fHighPage)
1095 {
1096 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x480, 8, dmaWriteHiPage, dmaReadHiPage, pDC8, "DMA8 Page High", NULL, &pDC8->hIoPortHi);
1097 AssertLogRelRCReturn(rc, rc);
1098 rc = PDMDevHlpIoPortCreateUAndMap(pDevIns, 0x488, 8, dmaWriteHiPage, dmaReadHiPage, pDC16, "DMA16 Page High", NULL, &pDC16->hIoPortHi);
1099 AssertLogRelRCReturn(rc, rc);
1100 }
1101 else
1102 {
1103 pDC8->hIoPortHi = NIL_IOMIOPORTHANDLE;
1104 pDC16->hIoPortHi = NIL_IOMIOPORTHANDLE;
1105 }
1106
1107 /*
1108 * Reset controller state.
1109 */
1110 dmaR3Reset(pDevIns);
1111
1112 /*
1113 * Register ourselves with PDM as the DMA controller.
1114 */
1115 PDMDMACREG Reg;
1116 Reg.u32Version = PDM_DMACREG_VERSION;
1117 Reg.pfnRun = dmaR3Run;
1118 Reg.pfnRegister = dmaR3Register;
1119 Reg.pfnReadMemory = dmaR3ReadMemory;
1120 Reg.pfnWriteMemory = dmaR3WriteMemory;
1121 Reg.pfnSetDREQ = dmaR3SetDREQ;
1122 Reg.pfnGetChannelMode = dmaR3GetChannelMode;
1123
1124 rc = PDMDevHlpDMACRegister(pDevIns, &Reg, &pThis->pHlp);
1125 AssertRCReturn(rc, rc);
1126
1127 /*
1128 * Register the saved state.
1129 */
1130 rc = PDMDevHlpSSMRegister(pDevIns, DMA_SAVESTATE_CURRENT, sizeof(*pThis), dmaR3SaveExec, dmaR3LoadExec);
1131 AssertRCReturn(rc, rc);
1132
1133 /*
1134 * Statistics.
1135 */
1136 PDMDevHlpSTAMRegister(pDevIns, &pThis->StatRun, STAMTYPE_PROFILE, "DmaRun", STAMUNIT_TICKS_PER_CALL, "Profiling dmaR3Run().");
1137
1138 /*
1139 * Register the info item.
1140 */
1141 PDMDevHlpDBGFInfoRegister(pDevIns, "dmac", "DMA controller info.", dmaR3Info);
1142 PDMDevHlpDBGFInfoRegister(pDevIns, "dmapage", "DMA page register info.", dmaR3InfoPageReg);
1143
1144 return VINF_SUCCESS;
1145}
1146
1147#else /* !IN_RING3 */
1148
1149/**
1150 * @callback_method_impl{PDMDEVREGR0,pfnConstruct}
1151 */
1152static DECLCALLBACK(int) dmaRZConstruct(PPDMDEVINS pDevIns)
1153{
1154 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
1155 PDMASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PDMASTATE);
1156 int rc;
1157
1158 for (unsigned i = 0; i < RT_ELEMENTS(pThis->DMAC); i++)
1159 {
1160 PDMACONTROLLER pCtl = &pThis->DMAC[i];
1161
1162 rc = PDMDevHlpIoPortSetUpContext(pDevIns, pCtl->hIoPortBase, dmaWriteAddr, dmaReadAddr, pCtl);
1163 AssertLogRelRCReturn(rc, rc);
1164
1165 rc = PDMDevHlpIoPortSetUpContext(pDevIns, pCtl->hIoPortCtl, dmaWriteCtl, dmaReadCtl, pCtl);
1166 AssertLogRelRCReturn(rc, rc);
1167
1168 rc = PDMDevHlpIoPortSetUpContext(pDevIns, pCtl->hIoPortPage, dmaWritePage, dmaReadPage, pCtl);
1169 AssertLogRelRCReturn(rc, rc);
1170
1171 if (pCtl->hIoPortHi != NIL_IOMIOPORTHANDLE)
1172 {
1173 rc = PDMDevHlpIoPortSetUpContext(pDevIns, pCtl->hIoPortHi, dmaWriteHiPage, dmaReadHiPage, pCtl);
1174 AssertLogRelRCReturn(rc, rc);
1175 }
1176 }
1177
1178 return VINF_SUCCESS;
1179}
1180
1181#endif /* !IN_RING3 */
1182
1183/**
1184 * The device registration structure.
1185 */
1186const PDMDEVREG g_DeviceDMA =
1187{
1188 /* .u32Version = */ PDM_DEVREG_VERSION,
1189 /* .uReserved0 = */ 0,
1190 /* .szName = */ "8237A",
1191 /* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ | PDM_DEVREG_FLAGS_NEW_STYLE,
1192 /* .fClass = */ PDM_DEVREG_CLASS_DMA,
1193 /* .cMaxInstances = */ 1,
1194 /* .uSharedVersion = */ 42,
1195 /* .cbInstanceShared = */ sizeof(DMAState),
1196 /* .cbInstanceCC = */ 0,
1197 /* .cbInstanceRC = */ 0,
1198 /* .cMaxPciDevices = */ 0,
1199 /* .cMaxMsixVectors = */ 0,
1200 /* .pszDescription = */ "DMA Controller Device",
1201#if defined(IN_RING3)
1202 /* .pszRCMod = */ "VBoxDDRC.rc",
1203 /* .pszR0Mod = */ "VBoxDDR0.r0",
1204 /* .pfnConstruct = */ dmaR3Construct,
1205 /* .pfnDestruct = */ NULL,
1206 /* .pfnRelocate = */ NULL,
1207 /* .pfnMemSetup = */ NULL,
1208 /* .pfnPowerOn = */ NULL,
1209 /* .pfnReset = */ dmaR3Reset,
1210 /* .pfnSuspend = */ NULL,
1211 /* .pfnResume = */ NULL,
1212 /* .pfnAttach = */ NULL,
1213 /* .pfnDetach = */ NULL,
1214 /* .pfnQueryInterface = */ NULL,
1215 /* .pfnInitComplete = */ NULL,
1216 /* .pfnPowerOff = */ NULL,
1217 /* .pfnSoftReset = */ NULL,
1218 /* .pfnReserved0 = */ NULL,
1219 /* .pfnReserved1 = */ NULL,
1220 /* .pfnReserved2 = */ NULL,
1221 /* .pfnReserved3 = */ NULL,
1222 /* .pfnReserved4 = */ NULL,
1223 /* .pfnReserved5 = */ NULL,
1224 /* .pfnReserved6 = */ NULL,
1225 /* .pfnReserved7 = */ NULL,
1226#elif defined(IN_RING0)
1227 /* .pfnEarlyConstruct = */ NULL,
1228 /* .pfnConstruct = */ dmaRZConstruct,
1229 /* .pfnDestruct = */ NULL,
1230 /* .pfnFinalDestruct = */ NULL,
1231 /* .pfnRequest = */ NULL,
1232 /* .pfnReserved0 = */ NULL,
1233 /* .pfnReserved1 = */ NULL,
1234 /* .pfnReserved2 = */ NULL,
1235 /* .pfnReserved3 = */ NULL,
1236 /* .pfnReserved4 = */ NULL,
1237 /* .pfnReserved5 = */ NULL,
1238 /* .pfnReserved6 = */ NULL,
1239 /* .pfnReserved7 = */ NULL,
1240#elif defined(IN_RC)
1241 /* .pfnConstruct = */ dmaRZConstruct,
1242 /* .pfnReserved0 = */ NULL,
1243 /* .pfnReserved1 = */ NULL,
1244 /* .pfnReserved2 = */ NULL,
1245 /* .pfnReserved3 = */ NULL,
1246 /* .pfnReserved4 = */ NULL,
1247 /* .pfnReserved5 = */ NULL,
1248 /* .pfnReserved6 = */ NULL,
1249 /* .pfnReserved7 = */ NULL,
1250#else
1251# error "Not in IN_RING3, IN_RING0 or IN_RC!"
1252#endif
1253 /* .u32VersionEnd = */ PDM_DEVREG_VERSION
1254};
1255
1256#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
1257
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette