VirtualBox

source: vbox/trunk/include/VBox/pdmifs.h@ 20663

Last change on this file since 20663 was 20374, checked in by vboxsync, 16 years ago

*: s/RT_\(BEGIN|END\)_DECLS/RT_C_DECLS_\1/g
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 94.5 KB
Line 
1/** @file
2 * PDM - Pluggable Device Manager, Interfaces.
3 */
4
5/*
6 * Copyright (C) 2006-2008 Sun Microsystems, Inc.
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 *
16 * The contents of this file may alternatively be used under the terms
17 * of the Common Development and Distribution License Version 1.0
18 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
19 * VirtualBox OSE distribution, in which case the provisions of the
20 * CDDL are applicable instead of those of the GPL.
21 *
22 * You may elect to license modified versions of this file under the
23 * terms and conditions of either the GPL or the CDDL or both.
24 *
25 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
26 * Clara, CA 95054 USA or visit http://www.sun.com if you need
27 * additional information or have any questions.
28 */
29
30#ifndef ___VBox_pdmifs_h
31#define ___VBox_pdmifs_h
32
33#include <VBox/types.h>
34#include <VBox/hgcmsvc.h>
35
36RT_C_DECLS_BEGIN
37
38/** @defgroup grp_pdm_interfaces The PDM Interface Definitions
39 * @ingroup grp_pdm
40 * @{
41 */
42
43/**
44 * Driver interface identficators.
45 *
46 * @remark All interfaces have to be declared here. There is no such thing as
47 * private interface identifiers since they must be unique.
48 *
49 * That said, interface structures and other stuff can be put elsewhere,
50 * actually, it is best if this file is not flooded with structures that
51 * could be put closer to home.
52 */
53typedef enum PDMINTERFACE
54{
55 /** PDMIBASE - The interface everyone supports. */
56 PDMINTERFACE_BASE = 1,
57 /** PDMIMOUSEPORT - The mouse port interface. (Down) Coupled with PDMINTERFACE_MOUSE_CONNECTOR. */
58 PDMINTERFACE_MOUSE_PORT,
59 /** PDMIMOUSECONNECTOR - The mouse connector interface. (Up) Coupled with PDMINTERFACE_MOUSE_PORT. */
60 PDMINTERFACE_MOUSE_CONNECTOR,
61 /** PDMIKEYBOARDPORT - The keyboard port interface. (Down) Coupled with PDMINTERFACE_KEYBOARD_CONNECTOR. */
62 PDMINTERFACE_KEYBOARD_PORT,
63 /** PDMIKEYBOARDCONNECTOR - The keyboard connector interface. (Up) Coupled with PDMINTERFACE_KEYBOARD_PORT. */
64 PDMINTERFACE_KEYBOARD_CONNECTOR,
65 /** PDMIDISPLAYPORT - The display port interface. (Down) Coupled with PDMINTERFACE_DISPLAY_CONNECTOR. */
66 PDMINTERFACE_DISPLAY_PORT,
67 /** PDMIDISPLAYCONNECTOR - The display connector interface. (Up) Coupled with PDMINTERFACE_DISPLAY_PORT. */
68 PDMINTERFACE_DISPLAY_CONNECTOR,
69 /** PDMICHARPORT - The char notify interface. (Down) Coupled with PDMINTERFACE_CHAR. */
70 PDMINTERFACE_CHAR_PORT,
71 /** PDMICHAR - The char driver interface. (Up) Coupled with PDMINTERFACE_CHAR_PORT. */
72 PDMINTERFACE_CHAR,
73 /** PDMISTREAM - The stream driver interface (Up) No coupling.
74 * Used by a char driver to implement PDMINTERFACE_CHAR. */
75 PDMINTERFACE_STREAM,
76 /** PDMIBLOCKPORT - The block notify interface (Down) Coupled with PDMINTERFACE_BLOCK. */
77 PDMINTERFACE_BLOCK_PORT,
78 /** PDMIBLOCK - The block driver interface (Up) Coupled with PDMINTERFACE_BLOCK_PORT. */
79 PDMINTERFACE_BLOCK,
80 /** PDMIBLOCKBIOS - The block bios interface. (External) */
81 PDMINTERFACE_BLOCK_BIOS,
82 /** PDMIMOUNTNOTIFY - The mountable notification interface. (Down) Coupled with PDMINTERFACE_MOUNT. */
83 PDMINTERFACE_MOUNT_NOTIFY,
84 /** PDMIMOUNT - The mountable interface. (Up) Coupled with PDMINTERFACE_MOUNT_NOTIFY. */
85 PDMINTERFACE_MOUNT,
86 /** PDMIMEDIA - The media interface. (Up) No coupling.
87 * Used by a block unit driver to implement PDMINTERFACE_BLOCK and PDMINTERFACE_BLOCK_BIOS. */
88 PDMINTERFACE_MEDIA,
89 /** PDMIISCSITRANSPORT - The iSCSI transport interface (Up) No coupling.
90 * used by the iSCSI media driver. */
91 PDMINTERFACE_ISCSITRANSPORT,
92 /** PDMIISCSITRANSPORTASYNC - The asynchronous iSCSI interface (Up) Couple with PDMINTERFACE_ISCSITRANSPORT.
93 * extension used by the iSCSI media driver. */
94 PDMINTERFACE_ISCSITRANSPORTASYNC,
95 /** PDMIISCSITRANSPORTASYNCPORT - The asynchronous iSCSI interface (Down) Couple with PDMINTERFACE_ISCSITRANSPORTASYNC.
96 * notify port used by the iSCSI media driver. */
97 PDMINTERFACE_ISCSITRANSPORTASYNCPORT,
98 /** PDMIMEDIAASYNC - Async version of the media interface (Down) Coupled with PDMINTERFACE_MEDIA_ASYNC_PORT. */
99 PDMINTERFACE_MEDIA_ASYNC,
100 /** PDMIMEDIAASYNCPORT - Async version of the media interface (Up) Coupled with PDMINTERFACE_MEDIA_ASYNC. */
101 PDMINTERFACE_MEDIA_ASYNC_PORT,
102 /** PDMIBLOCKASYNC - Async version of the block interface (Down) Coupled with PDMINTERFACE_BLOCK_ASYNC_PORT. */
103 PDMINTERFACE_BLOCK_ASYNC,
104 /** PDMIBLOCKASYNCPORT - Async version of the block interface (Up) Coupled with PDMINTERFACE_BLOCK_ASYNC. */
105 PDMINTERFACE_BLOCK_ASYNC_PORT,
106
107
108 /** PDMINETWORKPORT - The network port interface. (Down) Coupled with PDMINTERFACE_NETWORK_CONNECTOR. */
109 PDMINTERFACE_NETWORK_PORT,
110 /** PDMINETWORKPORT - The network connector interface. (Up) Coupled with PDMINTERFACE_NETWORK_PORT. */
111 PDMINTERFACE_NETWORK_CONNECTOR,
112 /** PDMINETWORKCONFIG - The network configuartion interface. (Main) Used by the managment api. */
113 PDMINTERFACE_NETWORK_CONFIG,
114
115 /** PDMIAUDIOCONNECTOR - The audio driver interface. (Up) No coupling. */
116 PDMINTERFACE_AUDIO_CONNECTOR,
117
118 /** PDMIAUDIOSNIFFERPORT - The Audio Sniffer Device port interface. */
119 PDMINTERFACE_AUDIO_SNIFFER_PORT,
120 /** PDMIAUDIOSNIFFERCONNECTOR - The Audio Sniffer Driver connector interface. */
121 PDMINTERFACE_AUDIO_SNIFFER_CONNECTOR,
122
123 /** PDMIVMMDEVPORT - The VMM Device port interface. */
124 PDMINTERFACE_VMMDEV_PORT,
125 /** PDMIVMMDEVCONNECTOR - The VMM Device connector interface. */
126 PDMINTERFACE_VMMDEV_CONNECTOR,
127
128 /** PDMILEDPORTS - The generic LED port interface. (Down) Coupled with PDMINTERFACE_LED_CONNECTORS. */
129 PDMINTERFACE_LED_PORTS,
130 /** PDMILEDCONNECTORS - The generic LED connector interface. (Up) Coupled with PDMINTERFACE_LED_PORTS. */
131 PDMINTERFACE_LED_CONNECTORS,
132
133 /** PDMIACPIPORT - ACPI port interface. (Down) Coupled with PDMINTERFACE_ACPI_CONNECTOR. */
134 PDMINTERFACE_ACPI_PORT,
135 /** PDMIACPICONNECTOR - ACPI connector interface. (Up) Coupled with PDMINTERFACE_ACPI_PORT. */
136 PDMINTERFACE_ACPI_CONNECTOR,
137
138 /** PDMIHGCMPORT - The Host-Guest communication manager port interface. Normally implemented by VMMDev. */
139 PDMINTERFACE_HGCM_PORT,
140 /** PDMIHGCMCONNECTOR - The Host-Guest communication manager connector interface. Normally implemented by Main::VMMDevInterface. */
141 PDMINTERFACE_HGCM_CONNECTOR,
142
143 /** VUSBIROOTHUBPORT - VUSB RootHub port interface. (Down) Coupled with PDMINTERFACE_USB_RH_CONNECTOR. */
144 PDMINTERFACE_VUSB_RH_PORT,
145 /** VUSBIROOTHUBCONNECTOR - VUSB RootHub connector interface. (Up) Coupled with PDMINTERFACE_USB_RH_PORT. */
146 PDMINTERFACE_VUSB_RH_CONNECTOR,
147 /** VUSBIRHCONFIG - VUSB RootHub configuration interface. (Main) Used by the managment api. */
148 PDMINTERFACE_VUSB_RH_CONFIG,
149
150 /** VUSBIDEVICE - VUSB Device interface. (Up) No coupling. */
151 PDMINTERFACE_VUSB_DEVICE,
152
153 /** PDMIHOSTPARALLELPORT - The Host Parallel port interface. (Down) Coupled with PDMINTERFACE_HOST_PARALLEL_CONNECTOR. */
154 PDMINTERFACE_HOST_PARALLEL_PORT,
155 /** PDMIHOSTPARALLELCONNECTOR - The Host Parallel connector interface (Up) Coupled with PDMINTERFACE_HOST_PARALLEL_PORT. */
156 PDMINTERFACE_HOST_PARALLEL_CONNECTOR,
157
158 /** PDMISCSIPORT - The SCSI command execution port interface (Down) Coupled with PDMINTERFACE_SCSI_CONNECTOR. */
159 PDMINTERFACE_SCSI_PORT,
160 /** PDMISCSICONNECTOR - The SCSI command execution connector interface (Up) Coupled with PDMINTERFACE_SCSI_PORT. */
161 PDMINTERFACE_SCSI_CONNECTOR,
162 /** PDMDDISPLAYVBVACALLBACKS - The Display VBVA callbacks. */
163 PDMINTERFACE_DISPLAY_VBVA_CALLBACKS,
164
165 /** Maximum interface number. */
166 PDMINTERFACE_MAX
167} PDMINTERFACE;
168
169
170/**
171 * PDM Driver Base Interface.
172 */
173typedef struct PDMIBASE
174{
175 /**
176 * Queries an interface to the driver.
177 *
178 * @returns Pointer to interface.
179 * @returns NULL if the interface was not supported by the driver.
180 * @param pInterface Pointer to this interface structure.
181 * @param enmInterface The requested interface identification.
182 * @thread Any thread.
183 */
184 DECLR3CALLBACKMEMBER(void *, pfnQueryInterface,(struct PDMIBASE *pInterface, PDMINTERFACE enmInterface));
185} PDMIBASE;
186
187
188/**
189 * Dummy interface.
190 *
191 * This is used to typedef other dummy interfaces. The purpose of a dummy
192 * interface is to validate the logical function of a driver/device and
193 * full a natural interface pair.
194 */
195typedef struct PDMIDUMMY
196{
197 RTHCPTR pvDummy;
198} PDMIDUMMY;
199
200
201/** Pointer to a mouse port interface. */
202typedef struct PDMIMOUSEPORT *PPDMIMOUSEPORT;
203/**
204 * Mouse port interface.
205 * Pair with PDMIMOUSECONNECTOR.
206 */
207typedef struct PDMIMOUSEPORT
208{
209 /**
210 * Puts a mouse event.
211 * This is called by the source of mouse events. The event will be passed up until the
212 * topmost driver, which then calls the registered event handler.
213 *
214 * @returns VBox status code.
215 * @param pInterface Pointer to this interface structure.
216 * @param i32DeltaX The X delta.
217 * @param i32DeltaY The Y delta.
218 * @param i32DeltaZ The Z delta.
219 * @param fButtonStates The button states, see the PDMIMOUSEPORT_BUTTON_* \#defines.
220 * @thread The emulation thread.
221 */
222 DECLR3CALLBACKMEMBER(int, pfnPutEvent,(PPDMIMOUSEPORT pInterface, int32_t i32DeltaX, int32_t i32DeltaY, int32_t i32DeltaZ, uint32_t fButtonStates));
223} PDMIMOUSEPORT;
224
225/** Mouse button defines for PDMIMOUSEPORT::pfnPutEvent.
226 * @{ */
227#define PDMIMOUSEPORT_BUTTON_LEFT RT_BIT(0)
228#define PDMIMOUSEPORT_BUTTON_RIGHT RT_BIT(1)
229#define PDMIMOUSEPORT_BUTTON_MIDDLE RT_BIT(2)
230/** @} */
231
232
233/**
234 * Mouse connector interface.
235 * Pair with PDMIMOUSEPORT.
236 */
237typedef PDMIDUMMY PDMIMOUSECONNECTOR;
238 /** Pointer to a mouse connector interface. */
239typedef PDMIMOUSECONNECTOR *PPDMIMOUSECONNECTOR;
240
241
242/** Pointer to a keyboard port interface. */
243typedef struct PDMIKEYBOARDPORT *PPDMIKEYBOARDPORT;
244/**
245 * Keyboard port interface.
246 * Pair with PDMIKEYBOARDCONNECTOR.
247 */
248typedef struct PDMIKEYBOARDPORT
249{
250 /**
251 * Puts a keyboard event.
252 * This is called by the source of keyboard events. The event will be passed up until the
253 * topmost driver, which then calls the registered event handler.
254 *
255 * @returns VBox status code.
256 * @param pInterface Pointer to this interface structure.
257 * @param u8KeyCode The keycode to queue.
258 * @thread The emulation thread.
259 */
260 DECLR3CALLBACKMEMBER(int, pfnPutEvent,(PPDMIKEYBOARDPORT pInterface, uint8_t u8KeyCode));
261} PDMIKEYBOARDPORT;
262
263/**
264 * Keyboard LEDs.
265 */
266typedef enum PDMKEYBLEDS
267{
268 /** No leds. */
269 PDMKEYBLEDS_NONE = 0x0000,
270 /** Num Lock */
271 PDMKEYBLEDS_NUMLOCK = 0x0001,
272 /** Caps Lock */
273 PDMKEYBLEDS_CAPSLOCK = 0x0002,
274 /** Scroll Lock */
275 PDMKEYBLEDS_SCROLLLOCK = 0x0004
276} PDMKEYBLEDS;
277
278/** Pointer to keyboard connector interface. */
279typedef struct PDMIKEYBOARDCONNECTOR *PPDMIKEYBOARDCONNECTOR;
280
281
282/**
283 * Keyboard connector interface.
284 * Pair with PDMIKEYBOARDPORT
285 */
286typedef struct PDMIKEYBOARDCONNECTOR
287{
288 /**
289 * Notifies the the downstream driver about an LED change initiated by the guest.
290 *
291 * @param pInterface Pointer to the this interface.
292 * @param enmLeds The new led mask.
293 */
294 DECLR3CALLBACKMEMBER(void, pfnLedStatusChange,(PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds));
295
296} PDMIKEYBOARDCONNECTOR;
297
298
299
300/** Pointer to a display port interface. */
301typedef struct PDMIDISPLAYPORT *PPDMIDISPLAYPORT;
302/**
303 * Display port interface.
304 * Pair with PDMIDISPLAYCONNECTOR.
305 */
306typedef struct PDMIDISPLAYPORT
307{
308 /**
309 * Update the display with any changed regions.
310 *
311 * Flushes any display changes to the memory pointed to by the
312 * PDMIDISPLAYCONNECTOR interface and calles PDMIDISPLAYCONNECTOR::pfnUpdateRect()
313 * while doing so.
314 *
315 * @returns VBox status code.
316 * @param pInterface Pointer to this interface.
317 * @thread The emulation thread.
318 */
319 DECLR3CALLBACKMEMBER(int, pfnUpdateDisplay,(PPDMIDISPLAYPORT pInterface));
320
321 /**
322 * Update the entire display.
323 *
324 * Flushes the entire display content to the memory pointed to by the
325 * PDMIDISPLAYCONNECTOR interface and calles PDMIDISPLAYCONNECTOR::pfnUpdateRect().
326 *
327 * @returns VBox status code.
328 * @param pInterface Pointer to this interface.
329 * @thread The emulation thread.
330 */
331 DECLR3CALLBACKMEMBER(int, pfnUpdateDisplayAll,(PPDMIDISPLAYPORT pInterface));
332
333 /**
334 * Return the current guest color depth in bits per pixel (bpp).
335 *
336 * As the graphics card is able to provide display updates with the bpp
337 * requested by the host, this method can be used to query the actual
338 * guest color depth.
339 *
340 * @returns VBox status code.
341 * @param pInterface Pointer to this interface.
342 * @param pcBits Where to store the current guest color depth.
343 * @thread Any thread.
344 */
345 DECLR3CALLBACKMEMBER(int, pfnQueryColorDepth,(PPDMIDISPLAYPORT pInterface, uint32_t *pcBits));
346
347 /**
348 * Sets the refresh rate and restart the timer.
349 * The rate is defined as the minimum interval between the return of
350 * one PDMIDISPLAYPORT::pfnRefresh() call to the next one.
351 *
352 * The interval timer will be restarted by this call. So at VM startup
353 * this function must be called to start the refresh cycle. The refresh
354 * rate is not saved, but have to be when resuming a loaded VM state.
355 *
356 * @returns VBox status code.
357 * @param pInterface Pointer to this interface.
358 * @param cMilliesInterval Number of millies between two refreshes.
359 * @thread Any thread.
360 */
361 DECLR3CALLBACKMEMBER(int, pfnSetRefreshRate,(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval));
362
363 /**
364 * Create a 32-bbp snapshot of the display.
365 *
366 * This will create a 32-bbp bitmap with dword aligned scanline length. Because
367 * of a wish for no locks in the graphics device, this must be called from the
368 * emulation thread.
369 *
370 * @param pInterface Pointer to this interface.
371 * @param pvData Pointer the buffer to copy the bits to.
372 * @param cbData Size of the buffer.
373 * @param pcx Where to store the width of the bitmap. (optional)
374 * @param pcy Where to store the height of the bitmap. (optional)
375 * @param pcbData Where to store the actual size of the bitmap. (optional)
376 * @thread The emulation thread.
377 */
378 DECLR3CALLBACKMEMBER(int, pfnSnapshot,(PPDMIDISPLAYPORT pInterface, void *pvData, size_t cbData, uint32_t *pcx, uint32_t *pcy, size_t *pcbData));
379
380 /**
381 * Copy bitmap to the display.
382 *
383 * This will convert and copy a 32-bbp bitmap (with dword aligned scanline length) to
384 * the memory pointed to by the PDMIDISPLAYCONNECTOR interface.
385 *
386 * @param pInterface Pointer to this interface.
387 * @param pvData Pointer to the bitmap bits.
388 * @param x The upper left corner x coordinate of the destination rectangle.
389 * @param y The upper left corner y coordinate of the destination rectangle.
390 * @param cx The width of the source and destination rectangles.
391 * @param cy The height of the source and destination rectangles.
392 * @thread The emulation thread.
393 * @remark This is just a convenience for using the bitmap conversions of the
394 * graphics device.
395 */
396 DECLR3CALLBACKMEMBER(int, pfnDisplayBlt,(PPDMIDISPLAYPORT pInterface, const void *pvData, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy));
397
398 /**
399 * Render a rectangle from guest VRAM to Framebuffer.
400 *
401 * @param pInterface Pointer to this interface.
402 * @param x The upper left corner x coordinate of the rectangle to be updated.
403 * @param y The upper left corner y coordinate of the rectangle to be updated.
404 * @param cx The width of the rectangle to be updated.
405 * @param cy The height of the rectangle to be updated.
406 * @thread The emulation thread.
407 */
408 DECLR3CALLBACKMEMBER(void, pfnUpdateDisplayRect,(PPDMIDISPLAYPORT pInterface, int32_t x, int32_t y, uint32_t cx, uint32_t cy));
409
410 /**
411 * Inform the VGA device whether the Display is directly using the guest VRAM and there is no need
412 * to render the VRAM to the framebuffer memory.
413 *
414 * @param pInterface Pointer to this interface.
415 * @param fRender Whether the VRAM content must be rendered to the framebuffer.
416 * @thread The emulation thread.
417 */
418 DECLR3CALLBACKMEMBER(void, pfnSetRenderVRAM,(PPDMIDISPLAYPORT pInterface, bool fRender));
419
420} PDMIDISPLAYPORT;
421
422
423typedef struct _VBOXVHWACMD *PVBOXVHWACMD; /**< @todo r=bird: _VBOXVHWACMD -> VBOXVHWACMD; avoid using 1 or 2 leading underscores. Also, a line what it is to make doxygen happy. */
424
425/** Pointer to a display connector interface. */
426typedef struct PDMIDISPLAYCONNECTOR *PPDMIDISPLAYCONNECTOR;
427/**
428 * Display connector interface.
429 * Pair with PDMIDISPLAYPORT.
430 */
431typedef struct PDMIDISPLAYCONNECTOR
432{
433 /**
434 * Resize the display.
435 * This is called when the resolution changes. This usually happens on
436 * request from the guest os, but may also happen as the result of a reset.
437 * If the callback returns VINF_VGA_RESIZE_IN_PROGRESS, the caller (VGA device)
438 * must not access the connector and return.
439 *
440 * @returns VINF_SUCCESS if the framebuffer resize was completed,
441 * VINF_VGA_RESIZE_IN_PROGRESS if resize takes time and not yet finished.
442 * @param pInterface Pointer to this interface.
443 * @param cBits Color depth (bits per pixel) of the new video mode.
444 * @param pvVRAM Address of the guest VRAM.
445 * @param cbLine Size in bytes of a single scan line.
446 * @param cx New display width.
447 * @param cy New display height.
448 * @thread The emulation thread.
449 */
450 DECLR3CALLBACKMEMBER(int, pfnResize,(PPDMIDISPLAYCONNECTOR pInterface, uint32_t cBits, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy));
451
452 /**
453 * Update a rectangle of the display.
454 * PDMIDISPLAYPORT::pfnUpdateDisplay is the caller.
455 *
456 * @param pInterface Pointer to this interface.
457 * @param x The upper left corner x coordinate of the rectangle.
458 * @param y The upper left corner y coordinate of the rectangle.
459 * @param cx The width of the rectangle.
460 * @param cy The height of the rectangle.
461 * @thread The emulation thread.
462 */
463 DECLR3CALLBACKMEMBER(void, pfnUpdateRect,(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy));
464
465 /**
466 * Refresh the display.
467 *
468 * The interval between these calls is set by
469 * PDMIDISPLAYPORT::pfnSetRefreshRate(). The driver should call
470 * PDMIDISPLAYPORT::pfnUpdateDisplay() if it wishes to refresh the
471 * display. PDMIDISPLAYPORT::pfnUpdateDisplay calls pfnUpdateRect with
472 * the changed rectangles.
473 *
474 * @param pInterface Pointer to this interface.
475 * @thread The emulation thread.
476 */
477 DECLR3CALLBACKMEMBER(void, pfnRefresh,(PPDMIDISPLAYCONNECTOR pInterface));
478
479 /**
480 * Reset the display.
481 *
482 * Notification message when the graphics card has been reset.
483 *
484 * @param pInterface Pointer to this interface.
485 * @thread The emulation thread.
486 */
487 DECLR3CALLBACKMEMBER(void, pfnReset,(PPDMIDISPLAYCONNECTOR pInterface));
488
489 /**
490 * LFB video mode enter/exit.
491 *
492 * Notification message when LinearFrameBuffer video mode is enabled/disabled.
493 *
494 * @param pInterface Pointer to this interface.
495 * @param fEnabled false - LFB mode was disabled,
496 * true - an LFB mode was disabled
497 * @thread The emulation thread.
498 */
499 DECLR3CALLBACKMEMBER(void, pfnLFBModeChange, (PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled));
500
501 /**
502 * Process the guest graphics adapter information.
503 *
504 * Direct notification from guest to the display connector.
505 *
506 * @param pInterface Pointer to this interface.
507 * @param pvVRAM Address of the guest VRAM.
508 * @param u32VRAMSize Size of the guest VRAM.
509 * @thread The emulation thread.
510 */
511 DECLR3CALLBACKMEMBER(void, pfnProcessAdapterData, (PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize));
512
513 /**
514 * Process the guest display information.
515 *
516 * Direct notification from guest to the display connector.
517 *
518 * @param pInterface Pointer to this interface.
519 * @param pvVRAM Address of the guest VRAM.
520 * @param uScreenId The index of the guest display to be processed.
521 * @thread The emulation thread.
522 */
523 DECLR3CALLBACKMEMBER(void, pfnProcessDisplayData, (PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId));
524
525 /**
526 * Process the guest Video HW Acceleration command.
527 *
528 * @param pInterface Pointer to this interface.
529 * @param pCmd Video HW Acceleration Command to be processed.
530 * @thread The emulation thread.
531 */
532 DECLR3CALLBACKMEMBER(void, pfnVHWACommandProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCmd));
533
534 /** Read-only attributes.
535 * For preformance reasons some readonly attributes are kept in the interface.
536 * We trust the interface users to respect the readonlyness of these.
537 * @{
538 */
539 /** Pointer to the display data buffer. */
540 uint8_t *pu8Data;
541 /** Size of a scanline in the data buffer. */
542 uint32_t cbScanline;
543 /** The color depth (in bits) the graphics card is supposed to provide. */
544 uint32_t cBits;
545 /** The display width. */
546 uint32_t cx;
547 /** The display height. */
548 uint32_t cy;
549 /** @} */
550} PDMIDISPLAYCONNECTOR;
551
552
553
554/**
555 * Block drive type.
556 */
557typedef enum PDMBLOCKTYPE
558{
559 /** Error (for the query function). */
560 PDMBLOCKTYPE_ERROR = 1,
561 /** 360KB 5 1/4" floppy drive. */
562 PDMBLOCKTYPE_FLOPPY_360,
563 /** 720KB 3 1/2" floppy drive. */
564 PDMBLOCKTYPE_FLOPPY_720,
565 /** 1.2MB 5 1/4" floppy drive. */
566 PDMBLOCKTYPE_FLOPPY_1_20,
567 /** 1.44MB 3 1/2" floppy drive. */
568 PDMBLOCKTYPE_FLOPPY_1_44,
569 /** 2.88MB 3 1/2" floppy drive. */
570 PDMBLOCKTYPE_FLOPPY_2_88,
571 /** CDROM drive. */
572 PDMBLOCKTYPE_CDROM,
573 /** DVD drive. */
574 PDMBLOCKTYPE_DVD,
575 /** Hard disk drive. */
576 PDMBLOCKTYPE_HARD_DISK
577} PDMBLOCKTYPE;
578
579
580/**
581 * Block raw command data transfer direction.
582 */
583typedef enum PDMBLOCKTXDIR
584{
585 PDMBLOCKTXDIR_NONE = 0,
586 PDMBLOCKTXDIR_FROM_DEVICE,
587 PDMBLOCKTXDIR_TO_DEVICE
588} PDMBLOCKTXDIR;
589
590/**
591 * Block notify interface.
592 * Pair with PDMIBLOCK.
593 */
594typedef PDMIDUMMY PDMIBLOCKPORT;
595/** Pointer to a block notify interface (dummy). */
596typedef PDMIBLOCKPORT *PPDMIBLOCKPORT;
597
598/** Pointer to a block interface. */
599typedef struct PDMIBLOCK *PPDMIBLOCK;
600/**
601 * Block interface.
602 * Pair with PDMIBLOCKPORT.
603 */
604typedef struct PDMIBLOCK
605{
606 /**
607 * Read bits.
608 *
609 * @returns VBox status code.
610 * @param pInterface Pointer to the interface structure containing the called function pointer.
611 * @param off Offset to start reading from. The offset must be aligned to a sector boundary.
612 * @param pvBuf Where to store the read bits.
613 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
614 * @thread Any thread.
615 */
616 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIBLOCK pInterface, uint64_t off, void *pvBuf, size_t cbRead));
617
618 /**
619 * Write bits.
620 *
621 * @returns VBox status code.
622 * @param pInterface Pointer to the interface structure containing the called function pointer.
623 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
624 * @param pvBuf Where to store the write bits.
625 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
626 * @thread Any thread.
627 */
628 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIBLOCK pInterface, uint64_t off, const void *pvBuf, size_t cbWrite));
629
630 /**
631 * Make sure that the bits written are actually on the storage medium.
632 *
633 * @returns VBox status code.
634 * @param pInterface Pointer to the interface structure containing the called function pointer.
635 * @thread Any thread.
636 */
637 DECLR3CALLBACKMEMBER(int, pfnFlush,(PPDMIBLOCK pInterface));
638
639 /**
640 * Send a raw command to the underlying device (CDROM).
641 * This method is optional (i.e. the function pointer may be NULL).
642 *
643 * @returns VBox status code.
644 * @param pInterface Pointer to the interface structure containing the called function pointer.
645 * @param pbCmd Offset to start reading from.
646 * @param enmTxDir Direction of transfer.
647 * @param pvBuf Pointer tp the transfer buffer.
648 * @param cbBuf Size of the transfer buffer.
649 * @param pbSenseKey Status of the command (when return value is VERR_DEV_IO_ERROR).
650 * @param cTimeoutMillies Command timeout in milliseconds.
651 * @thread Any thread.
652 */
653 DECLR3CALLBACKMEMBER(int, pfnSendCmd,(PPDMIBLOCK pInterface, const uint8_t *pbCmd, PDMBLOCKTXDIR enmTxDir, void *pvBuf, uint32_t *pcbBuf, uint8_t *pabSense, size_t cbSense, uint32_t cTimeoutMillies));
654
655 /**
656 * Check if the media is readonly or not.
657 *
658 * @returns true if readonly.
659 * @returns false if read/write.
660 * @param pInterface Pointer to the interface structure containing the called function pointer.
661 * @thread Any thread.
662 */
663 DECLR3CALLBACKMEMBER(bool, pfnIsReadOnly,(PPDMIBLOCK pInterface));
664
665 /**
666 * Gets the media size in bytes.
667 *
668 * @returns Media size in bytes.
669 * @param pInterface Pointer to the interface structure containing the called function pointer.
670 * @thread Any thread.
671 */
672 DECLR3CALLBACKMEMBER(uint64_t, pfnGetSize,(PPDMIBLOCK pInterface));
673
674 /**
675 * Gets the block drive type.
676 *
677 * @returns block drive type.
678 * @param pInterface Pointer to the interface structure containing the called function pointer.
679 * @thread Any thread.
680 */
681 DECLR3CALLBACKMEMBER(PDMBLOCKTYPE, pfnGetType,(PPDMIBLOCK pInterface));
682
683 /**
684 * Gets the UUID of the block drive.
685 * Don't return the media UUID if it's removable.
686 *
687 * @returns VBox status code.
688 * @param pInterface Pointer to the interface structure containing the called function pointer.
689 * @param pUuid Where to store the UUID on success.
690 * @thread Any thread.
691 */
692 DECLR3CALLBACKMEMBER(int, pfnGetUuid,(PPDMIBLOCK pInterface, PRTUUID pUuid));
693} PDMIBLOCK;
694
695
696/** Pointer to a mount interface. */
697typedef struct PDMIMOUNTNOTIFY *PPDMIMOUNTNOTIFY;
698/**
699 * Block interface.
700 * Pair with PDMIMOUNT.
701 */
702typedef struct PDMIMOUNTNOTIFY
703{
704 /**
705 * Called when a media is mounted.
706 *
707 * @param pInterface Pointer to the interface structure containing the called function pointer.
708 * @thread The emulation thread.
709 */
710 DECLR3CALLBACKMEMBER(void, pfnMountNotify,(PPDMIMOUNTNOTIFY pInterface));
711
712 /**
713 * Called when a media is unmounted
714 * @param pInterface Pointer to the interface structure containing the called function pointer.
715 * @thread The emulation thread.
716 */
717 DECLR3CALLBACKMEMBER(void, pfnUnmountNotify,(PPDMIMOUNTNOTIFY pInterface));
718} PDMIMOUNTNOTIFY;
719
720
721/* Pointer to mount interface. */
722typedef struct PDMIMOUNT *PPDMIMOUNT;
723/**
724 * Mount interface.
725 * Pair with PDMIMOUNTNOTIFY.
726 */
727typedef struct PDMIMOUNT
728{
729 /**
730 * Mount a media.
731 *
732 * This will not unmount any currently mounted media!
733 *
734 * @returns VBox status code.
735 * @param pInterface Pointer to the interface structure containing the called function pointer.
736 * @param pszFilename Pointer to filename. If this is NULL it assumed that the caller have
737 * constructed a configuration which can be attached to the bottom driver.
738 * @param pszCoreDriver Core driver name. NULL will cause autodetection. Ignored if pszFilanem is NULL.
739 * @thread The emulation thread.
740 */
741 DECLR3CALLBACKMEMBER(int, pfnMount,(PPDMIMOUNT pInterface, const char *pszFilename, const char *pszCoreDriver));
742
743 /**
744 * Unmount the media.
745 *
746 * The driver will validate and pass it on. On the rebounce it will decide whether or not to detach it self.
747 *
748 * @returns VBox status code.
749 * @param pInterface Pointer to the interface structure containing the called function pointer.
750 * @thread The emulation thread.
751 * @param fForce Force the unmount, even for locked media.
752 * @thread The emulation thread.
753 */
754 DECLR3CALLBACKMEMBER(int, pfnUnmount,(PPDMIMOUNT pInterface, bool fForce));
755
756 /**
757 * Checks if a media is mounted.
758 *
759 * @returns true if mounted.
760 * @returns false if not mounted.
761 * @param pInterface Pointer to the interface structure containing the called function pointer.
762 * @thread Any thread.
763 */
764 DECLR3CALLBACKMEMBER(bool, pfnIsMounted,(PPDMIMOUNT pInterface));
765
766 /**
767 * Locks the media, preventing any unmounting of it.
768 *
769 * @returns VBox status code.
770 * @param pInterface Pointer to the interface structure containing the called function pointer.
771 * @thread The emulation thread.
772 */
773 DECLR3CALLBACKMEMBER(int, pfnLock,(PPDMIMOUNT pInterface));
774
775 /**
776 * Unlocks the media, canceling previous calls to pfnLock().
777 *
778 * @returns VBox status code.
779 * @param pInterface Pointer to the interface structure containing the called function pointer.
780 * @thread The emulation thread.
781 */
782 DECLR3CALLBACKMEMBER(int, pfnUnlock,(PPDMIMOUNT pInterface));
783
784 /**
785 * Checks if a media is locked.
786 *
787 * @returns true if locked.
788 * @returns false if not locked.
789 * @param pInterface Pointer to the interface structure containing the called function pointer.
790 * @thread Any thread.
791 */
792 DECLR3CALLBACKMEMBER(bool, pfnIsLocked,(PPDMIMOUNT pInterface));
793} PDMIBLOCKMOUNT;
794
795/**
796 * Media geometry structure.
797 */
798typedef struct PDMMEDIAGEOMETRY
799{
800 /** Number of cylinders. */
801 uint32_t cCylinders;
802 /** Number of heads. */
803 uint32_t cHeads;
804 /** Number of sectors. */
805 uint32_t cSectors;
806} PDMMEDIAGEOMETRY;
807
808/** Pointer to media geometry structure. */
809typedef PDMMEDIAGEOMETRY *PPDMMEDIAGEOMETRY;
810/** Pointer to constant media geometry structure. */
811typedef const PDMMEDIAGEOMETRY *PCPDMMEDIAGEOMETRY;
812
813/** Pointer to a media interface. */
814typedef struct PDMIMEDIA *PPDMIMEDIA;
815/**
816 * Media interface.
817 * Makes up the foundation for PDMIBLOCK and PDMIBLOCKBIOS.
818 */
819typedef struct PDMIMEDIA
820{
821 /**
822 * Read bits.
823 *
824 * @returns VBox status code.
825 * @param pInterface Pointer to the interface structure containing the called function pointer.
826 * @param off Offset to start reading from. The offset must be aligned to a sector boundary.
827 * @param pvBuf Where to store the read bits.
828 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
829 * @thread Any thread.
830 */
831 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead));
832
833 /**
834 * Write bits.
835 *
836 * @returns VBox status code.
837 * @param pInterface Pointer to the interface structure containing the called function pointer.
838 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
839 * @param pvBuf Where to store the write bits.
840 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
841 * @thread Any thread.
842 */
843 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIMEDIA pInterface, uint64_t off, const void *pvBuf, size_t cbWrite));
844
845 /**
846 * Make sure that the bits written are actually on the storage medium.
847 *
848 * @returns VBox status code.
849 * @param pInterface Pointer to the interface structure containing the called function pointer.
850 * @thread Any thread.
851 */
852 DECLR3CALLBACKMEMBER(int, pfnFlush,(PPDMIMEDIA pInterface));
853
854 /**
855 * Get the media size in bytes.
856 *
857 * @returns Media size in bytes.
858 * @param pInterface Pointer to the interface structure containing the called function pointer.
859 * @thread Any thread.
860 */
861 DECLR3CALLBACKMEMBER(uint64_t, pfnGetSize,(PPDMIMEDIA pInterface));
862
863 /**
864 * Check if the media is readonly or not.
865 *
866 * @returns true if readonly.
867 * @returns false if read/write.
868 * @param pInterface Pointer to the interface structure containing the called function pointer.
869 * @thread Any thread.
870 */
871 DECLR3CALLBACKMEMBER(bool, pfnIsReadOnly,(PPDMIMEDIA pInterface));
872
873 /**
874 * Get stored media geometry (physical CHS, PCHS) - BIOS property.
875 * This is an optional feature of a media.
876 *
877 * @returns VBox status code.
878 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
879 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnBiosSetPCHSGeometry() yet.
880 * @param pInterface Pointer to the interface structure containing the called function pointer.
881 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
882 * @remark This has no influence on the read/write operations.
883 * @thread Any thread.
884 */
885 DECLR3CALLBACKMEMBER(int, pfnBiosGetPCHSGeometry,(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry));
886
887 /**
888 * Store the media geometry (physical CHS, PCHS) - BIOS property.
889 * This is an optional feature of a media.
890 *
891 * @returns VBox status code.
892 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
893 * @param pInterface Pointer to the interface structure containing the called function pointer.
894 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
895 * @remark This has no influence on the read/write operations.
896 * @thread The emulation thread.
897 */
898 DECLR3CALLBACKMEMBER(int, pfnBiosSetPCHSGeometry,(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry));
899
900 /**
901 * Get stored media geometry (logical CHS, LCHS) - BIOS property.
902 * This is an optional feature of a media.
903 *
904 * @returns VBox status code.
905 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
906 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnBiosSetLCHSGeometry() yet.
907 * @param pInterface Pointer to the interface structure containing the called function pointer.
908 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
909 * @remark This has no influence on the read/write operations.
910 * @thread Any thread.
911 */
912 DECLR3CALLBACKMEMBER(int, pfnBiosGetLCHSGeometry,(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry));
913
914 /**
915 * Store the media geometry (logical CHS, LCHS) - BIOS property.
916 * This is an optional feature of a media.
917 *
918 * @returns VBox status code.
919 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
920 * @param pInterface Pointer to the interface structure containing the called function pointer.
921 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
922 * @remark This has no influence on the read/write operations.
923 * @thread The emulation thread.
924 */
925 DECLR3CALLBACKMEMBER(int, pfnBiosSetLCHSGeometry,(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry));
926
927 /**
928 * Gets the UUID of the media drive.
929 *
930 * @returns VBox status code.
931 * @param pInterface Pointer to the interface structure containing the called function pointer.
932 * @param pUuid Where to store the UUID on success.
933 * @thread Any thread.
934 */
935 DECLR3CALLBACKMEMBER(int, pfnGetUuid,(PPDMIMEDIA pInterface, PRTUUID pUuid));
936
937} PDMIMEDIA;
938
939
940/** Pointer to a block BIOS interface. */
941typedef struct PDMIBLOCKBIOS *PPDMIBLOCKBIOS;
942/**
943 * Media BIOS interface.
944 * The interface the getting and setting properties which the BIOS/CMOS care about.
945 */
946typedef struct PDMIBLOCKBIOS
947{
948 /**
949 * Get stored media geometry (physical CHS, PCHS) - BIOS property.
950 * This is an optional feature of a media.
951 *
952 * @returns VBox status code.
953 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
954 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnSetPCHSGeometry() yet.
955 * @param pInterface Pointer to the interface structure containing the called function pointer.
956 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
957 * @remark This has no influence on the read/write operations.
958 * @thread Any thread.
959 */
960 DECLR3CALLBACKMEMBER(int, pfnGetPCHSGeometry,(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry));
961
962 /**
963 * Store the media geometry (physical CHS, PCHS) - BIOS property.
964 * This is an optional feature of a media.
965 *
966 * @returns VBox status code.
967 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
968 * @param pInterface Pointer to the interface structure containing the called function pointer.
969 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
970 * @remark This has no influence on the read/write operations.
971 * @thread The emulation thread.
972 */
973 DECLR3CALLBACKMEMBER(int, pfnSetPCHSGeometry,(PPDMIBLOCKBIOS pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry));
974
975 /**
976 * Get stored media geometry (logical CHS, LCHS) - BIOS property.
977 * This is an optional feature of a media.
978 *
979 * @returns VBox status code.
980 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
981 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnSetLCHSGeometry() yet.
982 * @param pInterface Pointer to the interface structure containing the called function pointer.
983 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
984 * @remark This has no influence on the read/write operations.
985 * @thread Any thread.
986 */
987 DECLR3CALLBACKMEMBER(int, pfnGetLCHSGeometry,(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry));
988
989 /**
990 * Store the media geometry (logical CHS, LCHS) - BIOS property.
991 * This is an optional feature of a media.
992 *
993 * @returns VBox status code.
994 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
995 * @param pInterface Pointer to the interface structure containing the called function pointer.
996 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
997 * @remark This has no influence on the read/write operations.
998 * @thread The emulation thread.
999 */
1000 DECLR3CALLBACKMEMBER(int, pfnSetLCHSGeometry,(PPDMIBLOCKBIOS pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry));
1001
1002 /**
1003 * Checks if the device should be visible to the BIOS or not.
1004 *
1005 * @returns true if the device is visible to the BIOS.
1006 * @returns false if the device is not visible to the BIOS.
1007 * @param pInterface Pointer to the interface structure containing the called function pointer.
1008 * @thread Any thread.
1009 */
1010 DECLR3CALLBACKMEMBER(bool, pfnIsVisible,(PPDMIBLOCKBIOS pInterface));
1011
1012 /**
1013 * Gets the block drive type.
1014 *
1015 * @returns block drive type.
1016 * @param pInterface Pointer to the interface structure containing the called function pointer.
1017 * @thread Any thread.
1018 */
1019 DECLR3CALLBACKMEMBER(PDMBLOCKTYPE, pfnGetType,(PPDMIBLOCKBIOS pInterface));
1020
1021} PDMIBLOCKBIOS;
1022
1023
1024/** Pointer to a static block core driver interface. */
1025typedef struct PDMIMEDIASTATIC *PPDMIMEDIASTATIC;
1026/**
1027 * Static block core driver interface.
1028 */
1029typedef struct PDMIMEDIASTATIC
1030{
1031 /**
1032 * Check if the specified file is a format which the core driver can handle.
1033 *
1034 * @returns true / false accordingly.
1035 * @param pInterface Pointer to the interface structure containing the called function pointer.
1036 * @param pszFilename Name of the file to probe.
1037 */
1038 DECLR3CALLBACKMEMBER(bool, pfnCanHandle,(PPDMIMEDIASTATIC pInterface, const char *pszFilename));
1039} PDMIMEDIASTATIC;
1040
1041
1042/**
1043 * iSCSI Request PDU buffer (gather).
1044 */
1045typedef struct ISCSIREQ
1046{
1047 /** Length of PDU segment in bytes. */
1048 size_t cbSeg;
1049 /** Pointer to PDU segment. */
1050 const void *pcvSeg;
1051} ISCSIREQ;
1052/** Pointer to an iSCSI Request PDU buffer. */
1053typedef ISCSIREQ *PISCSIREQ;
1054/** Pointer to a const iSCSI Request PDU buffer. */
1055typedef ISCSIREQ const *PCISCSIREQ;
1056
1057
1058/**
1059 * iSCSI Response PDU buffer (scatter).
1060 */
1061typedef struct ISCSIRES
1062{
1063 /** Length of PDU segment. */
1064 size_t cbSeg;
1065 /** Pointer to PDU segment. */
1066 void *pvSeg;
1067} ISCSIRES;
1068/** Pointer to an iSCSI Response PDU buffer. */
1069typedef ISCSIRES *PISCSIRES;
1070/** Pointer to a const iSCSI Response PDU buffer. */
1071typedef ISCSIRES const *PCISCSIRES;
1072
1073
1074/** Pointer to an iSCSI transport driver interface. */
1075typedef struct PDMIISCSITRANSPORT *PPDMIISCSITRANSPORT;
1076/**
1077 * iSCSI transport driver interface.
1078 */
1079typedef struct PDMIISCSITRANSPORT
1080{
1081 /**
1082 * Read bytes from an iSCSI transport stream. If the connection fails, it is automatically
1083 * reopened on the next call after the error is signalled. Error recovery in this case is
1084 * the duty of the caller.
1085 *
1086 * @returns VBox status code.
1087 * @param pTransport Pointer to the interface structure containing the called function pointer.
1088 * @param paResponses Array of scatter segments.
1089 * @param cResponses The number of segments.
1090 * @thread Any thread.
1091 * @todo Correct the docs.
1092 */
1093 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIISCSITRANSPORT pTransport, PISCSIRES paResponses, unsigned cResponses));
1094
1095 /**
1096 * Write bytes to an iSCSI transport stream. Padding is performed when necessary. If the connection
1097 * fails, it is automatically reopened on the next call after the error is signalled. Error recovery
1098 * in this case is the duty of the caller.
1099 *
1100 * @returns VBox status code.
1101 * @param pTransport Pointer to the interface structure containing the called function pointer.
1102 * @param paRequests Array of gather segments.
1103 * @param cRequests The number of segments.
1104 * @thread Any thread.
1105 * @todo Correct the docs.
1106 */
1107 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIISCSITRANSPORT pTransport, PISCSIREQ paRequests, unsigned cRequests));
1108
1109 /**
1110 * Open the iSCSI transport stream.
1111 *
1112 * @returns VBox status code.
1113 * @param pTransport Pointer to the interface structure containing the called function pointer.
1114 * @param pszTargetAddress Pointer to string of the format address:port.
1115 * @thread Any thread.
1116 */
1117 DECLR3CALLBACKMEMBER(int, pfnOpen,(PPDMIISCSITRANSPORT pTransport, const char *pszTargetAddress));
1118
1119 /**
1120 * Close the iSCSI transport stream.
1121 *
1122 * @returns VBox status code.
1123 * @param pTransport Pointer to the interface structure containing the called function pointer.
1124 * @thread Any thread.
1125 */
1126 DECLR3CALLBACKMEMBER(int, pfnClose,(PPDMIISCSITRANSPORT pTransport));
1127} PDMIISCSITRANSPORT;
1128
1129
1130/** Pointer to an asynchronous iSCSI transport driver interface. */
1131typedef struct PDMIISCSITRANSPORTASYNC *PPDMIISCSITRANSPORTASYNC;
1132/**
1133 * Asynchronous iSCSI transport driver interface.
1134 */
1135typedef struct PDMIISCSITRANSPORTASYNC
1136{
1137 /**
1138 * Start an asynchronous read request from an iSCSI transport stream. Padding is performed when necessary.
1139 *
1140 * @returns VBox status code.
1141 * @param pTransport Pointer to the interface structure containing the called function pointer.
1142 * @param paResponses Pointer to a array of scatter segments.
1143 * @param cResponses Number of segments in the array.
1144 * @param pvUser User argument which is returned in completion callback.
1145 * @thread EMT thread.
1146 */
1147 DECLR3CALLBACKMEMBER(int, pfnStartRead,(PPDMIISCSITRANSPORTASYNC pTransport, PISCSIRES paResponses, unsigned cResponses, void *pvUser));
1148
1149 /**
1150 * Start an asychronous write to an iSCSI transport stream. Padding is performed when necessary.
1151 *
1152 * @returns VBox status code.
1153 * @param pTransport Pointer to the interface structure containing the called function pointer.
1154 * @param paRequests Pointer to a array of gather segments.
1155 * @param cRequests Number of segments in the array.
1156 * @param pvUser User argument which is returned in completion callback.
1157 * @thread EMT thread.
1158 */
1159 DECLR3CALLBACKMEMBER(int, pfnStartWrite,(PPDMIISCSITRANSPORTASYNC pTransport, PISCSIREQ pRequests, unsigned cRequests, void *pvUser));
1160} PDMIISCSITRANSPORTASYNC;
1161
1162
1163/** Pointer to a asynchronous iSCSI transport notify interface. */
1164typedef struct PDMIISCSITRANSPORTASYNCPORT *PPDMIISCSITRANSPORTASYNCPORT;
1165/**
1166 * Asynchronous iSCSI transport notify interface.
1167 * Pair with PDMIISCSITRANSPORTASYNC.
1168 */
1169typedef struct PDMIISCSITRANSPORTASYNCPORT
1170{
1171 /**
1172 * Notify completion of a read task.
1173 *
1174 * @returns VBox status code.
1175 * @param pInterface Pointer to the interface structure containing the called function pointer.
1176 * @param paResponses Pointer to a array of scatter segments.
1177 * @param cResponses Number of segments in the array.
1178 * @param pvUser The user argument given in pfnStartRead.
1179 * @thread Any thread.
1180 */
1181 DECLR3CALLBACKMEMBER(int, pfnReadCompleteNotify, (PPDMIISCSITRANSPORTASYNCPORT pInterface, PISCSIRES paResponses, unsigned cResponse, void *pvUser));
1182
1183 /**
1184 * Notify completion of a write task.
1185 *
1186 * @returns VBox status code.
1187 * @param pInterface Pointer to the interface structure containing the called function pointer.
1188 * @param paRequests Pointer to a array of gather segments.
1189 * @param cRequests Number of segments in the array.
1190 * @param pvUser The user argument given in pfnStartWrite.
1191 * @thread Any thread.
1192 */
1193 DECLR3CALLBACKMEMBER(int, pfnWriteCompleteNotify, (PPDMIISCSITRANSPORTASYNCPORT pTransport, PISCSIREQ paRequests, unsigned cRequests, void *pvUser));
1194} PDMIISCSITRANSPORTASYNCPORT;
1195
1196
1197/** Pointer to a asynchronous block notify interface. */
1198typedef struct PDMIBLOCKASYNCPORT *PPDMIBLOCKASYNCPORT;
1199/**
1200 * Asynchronous block notify interface.
1201 * Pair with PDMIBLOCKASYNC.
1202 */
1203typedef struct PDMIBLOCKASYNCPORT
1204{
1205 /**
1206 * Notify completion of a asynchronous transfer.
1207 *
1208 * @returns VBox status code.
1209 * @param pInterface Pointer to the interface structure containing the called function pointer.
1210 * @param pvUser The user argument given in pfnStartWrite/Read.
1211 * @thread Any thread.
1212 */
1213 DECLR3CALLBACKMEMBER(int, pfnTransferCompleteNotify, (PPDMIBLOCKASYNCPORT pInterface, void *pvUser));
1214} PDMIBLOCKASYNCPORT;
1215
1216
1217/** Pointer to a asynchronous block interface. */
1218typedef struct PDMIBLOCKASYNC *PPDMIBLOCKASYNC;
1219/**
1220 * Asynchronous block interface.
1221 * Pair with PDMIBLOCKASYNCPORT.
1222 */
1223typedef struct PDMIBLOCKASYNC
1224{
1225 /**
1226 * Start reading task.
1227 *
1228 * @returns VBox status code.
1229 * @param pInterface Pointer to the interface structure containing the called function pointer.
1230 * @param off Offset to start reading from.c
1231 * @param pSeg Pointer to the first element in the scatter list.
1232 * @param cSeg Number of entries in the list.
1233 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
1234 * @param pvUser User argument which is returned in completion callback.
1235 * @thread Any thread.
1236 */
1237 DECLR3CALLBACKMEMBER(int, pfnStartRead,(PPDMIBLOCKASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbRead, void *pvUser));
1238
1239 /**
1240 * Write bits.
1241 *
1242 * @returns VBox status code.
1243 * @param pInterface Pointer to the interface structure containing the called function pointer.
1244 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
1245 * @param pSeg Pointer to the first element in the gather list.
1246 * @param cSeg Number of entries in the list.
1247 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
1248 * @param pvUser User argument which is returned in completion callback.
1249 * @thread Any thread.
1250 */
1251 DECLR3CALLBACKMEMBER(int, pfnStartWrite,(PPDMIBLOCKASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbWrite, void *pvUser));
1252
1253} PDMIBLOCKASYNC;
1254
1255
1256/** Pointer to a asynchronous notification interface. */
1257typedef struct PDMIMEDIAASYNCPORT *PPDMIMEDIAASYNCPORT;
1258/**
1259 * Asynchronous media interface.
1260 * Makes up the fundation for PDMIBLOCKASYNC and PDMIBLOCKBIOS.
1261 */
1262typedef struct PDMIMEDIAASYNCPORT
1263{
1264 /**
1265 * Notify completion of a task.
1266 *
1267 * @returns VBox status code.
1268 * @param pInterface Pointer to the interface structure containing the called function pointer.
1269 * @param pvUser The user argument given in pfnStartWrite.
1270 * @thread Any thread.
1271 */
1272 DECLR3CALLBACKMEMBER(int, pfnTransferCompleteNotify, (PPDMIMEDIAASYNCPORT pInterface, void *pvUser));
1273} PDMIMEDIAASYNCPORT;
1274
1275
1276/** Pointer to a asynchronous media interface. */
1277typedef struct PDMIMEDIAASYNC *PPDMIMEDIAASYNC;
1278/**
1279 * Asynchronous media interface.
1280 * Makes up the fundation for PDMIBLOCKASYNC and PDMIBLOCKBIOS.
1281 */
1282typedef struct PDMIMEDIAASYNC
1283{
1284 /**
1285 * Start reading task.
1286 *
1287 * @returns VBox status code.
1288 * @param pInterface Pointer to the interface structure containing the called function pointer.
1289 * @param off Offset to start reading from. Must be aligned to a sector boundary.
1290 * @param pSeg Pointer to the first element in the scatter list.
1291 * @param cSeg Number of entries in the list.
1292 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
1293 * @param pvUser User data.
1294 * @thread Any thread.
1295 */
1296 DECLR3CALLBACKMEMBER(int, pfnStartRead,(PPDMIMEDIAASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbRead, void *pvUser));
1297
1298 /**
1299 * Start writing task.
1300 *
1301 * @returns VBox status code.
1302 * @param pInterface Pointer to the interface structure containing the called function pointer.
1303 * @param off Offset to start writing at. Must be aligned to a sector boundary.
1304 * @param pSeg Pointer to the first element in the gather list.
1305 * @param cSeg Number of entries in the list.
1306 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
1307 * @param pvUser User data.
1308 * @thread Any thread.
1309 */
1310 DECLR3CALLBACKMEMBER(int, pfnStartWrite,(PPDMIMEDIAASYNC pInterface, uint64_t off, PPDMDATASEG pSeg, unsigned cSeg, size_t cbWrite, void *pvUser));
1311
1312} PDMIMEDIAASYNC;
1313
1314
1315/** @name Bit mask definitions for status line type
1316 * @{ */
1317#define PDM_ICHAR_STATUS_LINES_DCD RT_BIT(0)
1318#define PDM_ICHAR_STATUS_LINES_RI RT_BIT(1)
1319#define PDM_ICHAR_STATUS_LINES_DSR RT_BIT(2)
1320#define PDM_ICHAR_STATUS_LINES_CTS RT_BIT(3)
1321/** @} */
1322
1323/** Pointer to a char port interface. */
1324typedef struct PDMICHARPORT *PPDMICHARPORT;
1325/**
1326 * Char port interface.
1327 * Pair with PDMICHAR.
1328 */
1329typedef struct PDMICHARPORT
1330{
1331 /**
1332 * Deliver data read to the device/driver.
1333 *
1334 * @returns VBox status code.
1335 * @param pInterface Pointer to the interface structure containing the called function pointer.
1336 * @param pvBuf Where the read bits are stored.
1337 * @param pcbRead Number of bytes available for reading/having been read.
1338 * @thread Any thread.
1339 */
1340 DECLR3CALLBACKMEMBER(int, pfnNotifyRead,(PPDMICHARPORT pInterface, const void *pvBuf, size_t *pcbRead));
1341
1342 /**
1343 * Notify the device/driver when the status lines changed.
1344 *
1345 * @returns VBox status code.
1346 * @param pInterface Pointer to the interface structure containing the called function pointer.
1347 * @param fNewStatusLine New state of the status line pins.
1348 * @thread Any thread.
1349 */
1350 DECLR3CALLBACKMEMBER(int, pfnNotifyStatusLinesChanged,(PPDMICHARPORT pInterface, uint32_t fNewStatusLines));
1351} PDMICHARPORT;
1352
1353
1354/** Pointer to a char interface. */
1355typedef struct PDMICHAR *PPDMICHAR;
1356/**
1357 * Char interface.
1358 * Pair with PDMICHARPORT.
1359 */
1360typedef struct PDMICHAR
1361{
1362 /**
1363 * Write bits.
1364 *
1365 * @returns VBox status code.
1366 * @param pInterface Pointer to the interface structure containing the called function pointer.
1367 * @param pvBuf Where to store the write bits.
1368 * @param cbWrite Number of bytes to write.
1369 * @thread Any thread.
1370 */
1371 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMICHAR pInterface, const void *pvBuf, size_t cbWrite));
1372
1373 /**
1374 * Set device parameters.
1375 *
1376 * @returns VBox status code.
1377 * @param pInterface Pointer to the interface structure containing the called function pointer.
1378 * @param Bps Speed of the serial connection. (bits per second)
1379 * @param chParity Parity method: 'E' - even, 'O' - odd, 'N' - none.
1380 * @param cDataBits Number of data bits.
1381 * @param cStopBits Number of stop bits.
1382 * @thread Any thread.
1383 */
1384 DECLR3CALLBACKMEMBER(int, pfnSetParameters,(PPDMICHAR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits));
1385
1386 /**
1387 * Set the state of the modem lines.
1388 *
1389 * @returns VBox status code.
1390 * @param pInterface Pointer to the interface structure containing the called function pointer.
1391 * @param fRequestToSend Set to true to make the Request to Send line active otherwise to 0.
1392 * @param fDataTerminalReady Set to true to make the Data Terminal Ready line active otherwise 0.
1393 * @thread Any thread.
1394 */
1395 DECLR3CALLBACKMEMBER(int, pfnSetModemLines,(PPDMICHAR pInterface, bool fRequestToSend, bool fDataTerminalReady));
1396
1397} PDMICHAR;
1398
1399
1400/** Pointer to a stream interface. */
1401typedef struct PDMISTREAM *PPDMISTREAM;
1402/**
1403 * Stream interface.
1404 * Makes up the foundation for PDMICHAR.
1405 */
1406typedef struct PDMISTREAM
1407{
1408 /**
1409 * Read bits.
1410 *
1411 * @returns VBox status code.
1412 * @param pInterface Pointer to the interface structure containing the called function pointer.
1413 * @param pvBuf Where to store the read bits.
1414 * @param cbRead Number of bytes to read/bytes actually read.
1415 * @thread Any thread.
1416 */
1417 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMISTREAM pInterface, void *pvBuf, size_t *cbRead));
1418
1419 /**
1420 * Write bits.
1421 *
1422 * @returns VBox status code.
1423 * @param pInterface Pointer to the interface structure containing the called function pointer.
1424 * @param pvBuf Where to store the write bits.
1425 * @param cbWrite Number of bytes to write/bytes actually written.
1426 * @thread Any thread.
1427 */
1428 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMISTREAM pInterface, const void *pvBuf, size_t *cbWrite));
1429} PDMISTREAM;
1430
1431
1432/** Mode of the parallel port */
1433typedef enum PDMPARALLELPORTMODE
1434{
1435 PDM_PARALLEL_PORT_MODE_COMPAT,
1436 PDM_PARALLEL_PORT_MODE_EPP,
1437 PDM_PARALLEL_PORT_MODE_ECP
1438} PDMPARALLELPORTMODE;
1439
1440/** Pointer to a host parallel port interface. */
1441typedef struct PDMIHOSTPARALLELPORT *PPDMIHOSTPARALLELPORT;
1442/**
1443 * Host parallel port interface.
1444 * Pair with PDMIHOSTPARALLELCONNECTOR.
1445 */
1446typedef struct PDMIHOSTPARALLELPORT
1447{
1448 /**
1449 * Deliver data read to the device/driver.
1450 *
1451 * @returns VBox status code.
1452 * @param pInterface Pointer to the interface structure containing the called function pointer.
1453 * @param pvBuf Where the read bits are stored.
1454 * @param pcbRead Number of bytes available for reading/having been read.
1455 * @thread Any thread.
1456 */
1457 DECLR3CALLBACKMEMBER(int, pfnNotifyRead,(PPDMIHOSTPARALLELPORT pInterface, const void *pvBuf, size_t *pcbRead));
1458
1459 /**
1460 * Notify device/driver that an interrupt has occured.
1461 *
1462 * @returns VBox status code.
1463 * @param pInterface Pointer to the interface structure containing the called function pointer.
1464 * @thread Any thread.
1465 */
1466 DECLR3CALLBACKMEMBER(int, pfnNotifyInterrupt,(PPDMIHOSTPARALLELPORT pInterface));
1467} PDMIHOSTPARALLELPORT;
1468
1469
1470
1471/** Pointer to a Host Parallel connector interface. */
1472typedef struct PDMIHOSTPARALLELCONNECTOR *PPDMIHOSTPARALLELCONNECTOR;
1473/**
1474 * Host parallel connector interface
1475 * Pair with PDMIHOSTPARALLELPORT.
1476 */
1477typedef struct PDMIHOSTPARALLELCONNECTOR
1478{
1479 /**
1480 * Write bits.
1481 *
1482 * @returns VBox status code.
1483 * @param pInterface Pointer to the interface structure containing the called function pointer.
1484 * @param pvBuf Where to store the write bits.
1485 * @param pcbWrite Number of bytes to write/bytes actually written.
1486 * @thread Any thread.
1487 */
1488 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIHOSTPARALLELCONNECTOR pInterface, const void *pvBuf, size_t *pcbWrite));
1489
1490 /**
1491 * Read bits.
1492 *
1493 * @returns VBox status code.
1494 * @param pInterface Pointer to the interface structure containing the called function pointer.
1495 * @param pvBuf Where to store the read bits.
1496 * @param pcbRead Number of bytes to read/bytes actually read.
1497 * @thread Any thread.
1498 */
1499 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIHOSTPARALLELCONNECTOR pInterface, void *pvBuf, size_t *pcbRead));
1500
1501 /**
1502 * Write control register bits.
1503 *
1504 * @returns VBox status code.
1505 * @param pInterface Pointer to the interface structure containing the called function pointer.
1506 * @param fReg The new control register value.
1507 * @thread Any thread.
1508 */
1509 DECLR3CALLBACKMEMBER(int, pfnWriteControl,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t fReg));
1510
1511 /**
1512 * Read control register bits.
1513 *
1514 * @returns VBox status code.
1515 * @param pInterface Pointer to the interface structure containing the called function pointer.
1516 * @param pfReg Where to store the control register bits.
1517 * @thread Any thread.
1518 */
1519 DECLR3CALLBACKMEMBER(int, pfnReadControl,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg));
1520
1521 /**
1522 * Read status register bits.
1523 *
1524 * @returns VBox status code.
1525 * @param pInterface Pointer to the interface structure containing the called function pointer.
1526 * @param pfReg Where to store the status register bits.
1527 * @thread Any thread.
1528 */
1529 DECLR3CALLBACKMEMBER(int, pfnReadStatus,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg));
1530
1531 /**
1532 * Set mode of the host parallel port.
1533 *
1534 * @returns VBox status code.
1535 * @param pInterface Pointer to the interface structure containing the called function pointer.
1536 * @param enmMode The mode of the host parallel port.
1537 * @thread Any thread.
1538 */
1539 DECLR3CALLBACKMEMBER(int, pfnSetMode,(PPDMIHOSTPARALLELCONNECTOR pInterface, PDMPARALLELPORTMODE enmMode));
1540} PDMIHOSTPARALLELCONNECTOR;
1541
1542
1543/** ACPI power source identifier */
1544typedef enum PDMACPIPOWERSOURCE
1545{
1546 PDM_ACPI_POWER_SOURCE_UNKNOWN = 0,
1547 PDM_ACPI_POWER_SOURCE_OUTLET,
1548 PDM_ACPI_POWER_SOURCE_BATTERY
1549} PDMACPIPOWERSOURCE;
1550/** Pointer to ACPI battery state. */
1551typedef PDMACPIPOWERSOURCE *PPDMACPIPOWERSOURCE;
1552
1553/** ACPI battey capacity */
1554typedef enum PDMACPIBATCAPACITY
1555{
1556 PDM_ACPI_BAT_CAPACITY_MIN = 0,
1557 PDM_ACPI_BAT_CAPACITY_MAX = 100,
1558 PDM_ACPI_BAT_CAPACITY_UNKNOWN = 255
1559} PDMACPIBATCAPACITY;
1560/** Pointer to ACPI battery capacity. */
1561typedef PDMACPIBATCAPACITY *PPDMACPIBATCAPACITY;
1562
1563/** ACPI battery state. See ACPI 3.0 spec '_BST (Battery Status)' */
1564typedef enum PDMACPIBATSTATE
1565{
1566 PDM_ACPI_BAT_STATE_CHARGED = 0x00,
1567 PDM_ACPI_BAT_STATE_DISCHARGING = 0x01,
1568 PDM_ACPI_BAT_STATE_CHARGING = 0x02,
1569 PDM_ACPI_BAT_STATE_CRITICAL = 0x04
1570} PDMACPIBATSTATE;
1571/** Pointer to ACPI battery state. */
1572typedef PDMACPIBATSTATE *PPDMACPIBATSTATE;
1573
1574/** Pointer to an ACPI port interface. */
1575typedef struct PDMIACPIPORT *PPDMIACPIPORT;
1576/**
1577 * ACPI port interface.
1578 */
1579typedef struct PDMIACPIPORT
1580{
1581 /**
1582 * Send an ACPI power off event.
1583 *
1584 * @returns VBox status code
1585 * @param pInterface Pointer to the interface structure containing the called function pointer.
1586 */
1587 DECLR3CALLBACKMEMBER(int, pfnPowerButtonPress,(PPDMIACPIPORT pInterface));
1588
1589 /**
1590 * Send an ACPI sleep button event.
1591 *
1592 * @returns VBox status code
1593 * @param pInterface Pointer to the interface structure containing the called function pointer.
1594 */
1595 DECLR3CALLBACKMEMBER(int, pfnSleepButtonPress,(PPDMIACPIPORT pInterface));
1596
1597 /**
1598 * Check if the last power button event was handled by the guest.
1599 *
1600 * @returns VBox status code
1601 * @param pInterface Pointer to the interface structure containing the called function pointer.
1602 * @param pfHandled Is set to true if the last power button event was handled, false otherwise.
1603 */
1604 DECLR3CALLBACKMEMBER(int, pfnGetPowerButtonHandled,(PPDMIACPIPORT pInterface, bool *pfHandled));
1605
1606 /**
1607 * Check if the guest entered the ACPI mode.
1608 *
1609 * @returns VBox status code
1610 * @param pInterface Pointer to the interface structure containing the called function pointer.
1611 * @param pfEnabled Is set to true if the guest entered the ACPI mode, false otherwise.
1612 */
1613 DECLR3CALLBACKMEMBER(int, pfnGetGuestEnteredACPIMode,(PPDMIACPIPORT pInterface, bool *pfEntered));
1614} PDMIACPIPORT;
1615
1616/** Pointer to an ACPI connector interface. */
1617typedef struct PDMIACPICONNECTOR *PPDMIACPICONNECTOR;
1618/**
1619 * ACPI connector interface.
1620 */
1621typedef struct PDMIACPICONNECTOR
1622{
1623 /**
1624 * Get the current power source of the host system.
1625 *
1626 * @returns VBox status code
1627 * @param pInterface Pointer to the interface structure containing the called function pointer.
1628 * @param penmPowerSource Pointer to the power source result variable.
1629 */
1630 DECLR3CALLBACKMEMBER(int, pfnQueryPowerSource,(PPDMIACPICONNECTOR, PPDMACPIPOWERSOURCE penmPowerSource));
1631
1632 /**
1633 * Query the current battery status of the host system.
1634 *
1635 * @returns VBox status code?
1636 * @param pInterface Pointer to the interface structure containing the called function pointer.
1637 * @param pfPresent Is set to true if battery is present, false otherwise.
1638 * @param penmRemainingCapacity Pointer to the battery remaining capacity (0 - 100 or 255 for unknown).
1639 * @param penmBatteryState Pointer to the battery status.
1640 * @param pu32PresentRate Pointer to the present rate (0..1000 of the total capacity).
1641 */
1642 DECLR3CALLBACKMEMBER(int, pfnQueryBatteryStatus,(PPDMIACPICONNECTOR, bool *pfPresent, PPDMACPIBATCAPACITY penmRemainingCapacity,
1643 PPDMACPIBATSTATE penmBatteryState, uint32_t *pu32PresentRate));
1644} PDMIACPICONNECTOR;
1645
1646
1647/** Pointer to a VMMDevice port interface. */
1648typedef struct PDMIVMMDEVPORT *PPDMIVMMDEVPORT;
1649/**
1650 * VMMDevice port interface.
1651 */
1652typedef struct PDMIVMMDEVPORT
1653{
1654 /**
1655 * Return the current absolute mouse position in pixels
1656 *
1657 * @returns VBox status code
1658 * @param pAbsX Pointer of result value, can be NULL
1659 * @param pAbsY Pointer of result value, can be NULL
1660 */
1661 DECLR3CALLBACKMEMBER(int, pfnQueryAbsoluteMouse,(PPDMIVMMDEVPORT pInterface, uint32_t *pAbsX, uint32_t *pAbsY));
1662
1663 /**
1664 * Set the new absolute mouse position in pixels
1665 *
1666 * @returns VBox status code
1667 * @param absX New absolute X position
1668 * @param absY New absolute Y position
1669 */
1670 DECLR3CALLBACKMEMBER(int, pfnSetAbsoluteMouse,(PPDMIVMMDEVPORT pInterface, uint32_t absX, uint32_t absY));
1671
1672 /**
1673 * Return the current mouse capability flags
1674 *
1675 * @returns VBox status code
1676 * @param pCapabilities Pointer of result value
1677 */
1678 DECLR3CALLBACKMEMBER(int, pfnQueryMouseCapabilities,(PPDMIVMMDEVPORT pInterface, uint32_t *pCapabilities));
1679
1680 /**
1681 * Set the current mouse capability flag (host side)
1682 *
1683 * @returns VBox status code
1684 * @param capabilities Capability mask
1685 */
1686 DECLR3CALLBACKMEMBER(int, pfnSetMouseCapabilities,(PPDMIVMMDEVPORT pInterface, uint32_t capabilities));
1687
1688 /**
1689 * Issue a display resolution change request.
1690 *
1691 * Note that there can only one request in the queue and that in case the guest does
1692 * not process it, issuing another request will overwrite the previous.
1693 *
1694 * @returns VBox status code
1695 * @param cx Horizontal pixel resolution (0 = do not change).
1696 * @param cy Vertical pixel resolution (0 = do not change).
1697 * @param cBits Bits per pixel (0 = do not change).
1698 * @param display The display index.
1699 */
1700 DECLR3CALLBACKMEMBER(int, pfnRequestDisplayChange,(PPDMIVMMDEVPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, uint32_t display));
1701
1702 /**
1703 * Pass credentials to guest.
1704 *
1705 * Note that there can only be one set of credentials and the guest may or may not
1706 * query them and may do whatever it wants with them.
1707 *
1708 * @returns VBox status code
1709 * @param pszUsername User name, may be empty (UTF-8)
1710 * @param pszPassword Password, may be empty (UTF-8)
1711 * @param pszDomain Domain name, may be empty (UTF-8)
1712 * @param fFlags Bitflags
1713 */
1714 DECLR3CALLBACKMEMBER(int, pfnSetCredentials,(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
1715 const char *pszPassword, const char *pszDomain,
1716 uint32_t fFlags));
1717
1718 /**
1719 * Notify the driver about a VBVA status change.
1720 *
1721 * @returns Nothing. Because it is informational callback.
1722 * @param fEnabled Current VBVA status.
1723 */
1724 DECLR3CALLBACKMEMBER(void, pfnVBVAChange, (PPDMIVMMDEVPORT pInterface, bool fEnabled));
1725
1726 /**
1727 * Issue a seamless mode change request.
1728 *
1729 * Note that there can only one request in the queue and that in case the guest does
1730 * not process it, issuing another request will overwrite the previous.
1731 *
1732 * @returns VBox status code
1733 * @param fEnabled Seamless mode enabled or not
1734 */
1735 DECLR3CALLBACKMEMBER(int, pfnRequestSeamlessChange,(PPDMIVMMDEVPORT pInterface, bool fEnabled));
1736
1737 /**
1738 * Issue a memory balloon change request.
1739 *
1740 * Note that there can only one request in the queue and that in case the guest does
1741 * not process it, issuing another request will overwrite the previous.
1742 *
1743 * @returns VBox status code
1744 * @param ulBalloonSize Balloon size in megabytes
1745 */
1746 DECLR3CALLBACKMEMBER(int, pfnSetMemoryBalloon,(PPDMIVMMDEVPORT pInterface, uint32_t ulBalloonSize));
1747
1748 /**
1749 * Issue a statistcs interval change request.
1750 *
1751 * Note that there can only one request in the queue and that in case the guest does
1752 * not process it, issuing another request will overwrite the previous.
1753 *
1754 * @returns VBox status code
1755 * @param ulStatInterval Statistics query interval in seconds (0=disable)
1756 */
1757 DECLR3CALLBACKMEMBER(int, pfnSetStatisticsInterval,(PPDMIVMMDEVPORT pInterface, uint32_t ulStatInterval));
1758
1759 /**
1760 * Notify the guest about a VRDP status change.
1761 *
1762 * @returns VBox status code
1763 * @param fVRDPEnabled Current VRDP status.
1764 * @param u32VRDPExperienceLevel Which visual effects to be disabled in the guest.
1765 */
1766 DECLR3CALLBACKMEMBER(int, pfnVRDPChange, (PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t u32VRDPExperienceLevel));
1767
1768} PDMIVMMDEVPORT;
1769
1770/** Forward declaration of the video accelerator command memory. */
1771struct _VBVAMEMORY;
1772/** Forward declaration of the guest information structure. */
1773struct VBoxGuestInfo;
1774/** Forward declaration of the guest statistics structure */
1775struct VBoxGuestStatistics;
1776/** Pointer to video accelerator command memory. */
1777typedef struct _VBVAMEMORY *PVBVAMEMORY;
1778
1779/** Pointer to a VMMDev connector interface. */
1780typedef struct PDMIVMMDEVCONNECTOR *PPDMIVMMDEVCONNECTOR;
1781/**
1782 * VMMDev connector interface.
1783 * Pair with PDMIVMMDEVPORT.
1784 */
1785typedef struct PDMIVMMDEVCONNECTOR
1786{
1787 /**
1788 * Report guest OS version.
1789 * Called whenever the Additions issue a guest version report request.
1790 *
1791 * @param pInterface Pointer to this interface.
1792 * @param pGuestInfo Pointer to guest information structure
1793 * @thread The emulation thread.
1794 */
1795 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestVersion,(PPDMIVMMDEVCONNECTOR pInterface, struct VBoxGuestInfo *pGuestInfo));
1796
1797 /**
1798 * Update the guest additions capabilities.
1799 * This is called when the guest additions capabilities change. The new capabilities
1800 * are given and the connector should update its internal state.
1801 *
1802 * @param pInterface Pointer to this interface.
1803 * @param newCapabilities New capabilities.
1804 * @thread The emulation thread.
1805 */
1806 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestCapabilities,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t newCapabilities));
1807
1808 /**
1809 * Update the mouse capabilities.
1810 * This is called when the mouse capabilities change. The new capabilities
1811 * are given and the connector should update its internal state.
1812 *
1813 * @param pInterface Pointer to this interface.
1814 * @param newCapabilities New capabilities.
1815 * @thread The emulation thread.
1816 */
1817 DECLR3CALLBACKMEMBER(void, pfnUpdateMouseCapabilities,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t newCapabilities));
1818
1819 /**
1820 * Update the pointer shape.
1821 * This is called when the mouse pointer shape changes. The new shape
1822 * is passed as a caller allocated buffer that will be freed after returning
1823 *
1824 * @param pInterface Pointer to this interface.
1825 * @param fVisible Visibility indicator (if false, the other parameters are undefined).
1826 * @param fAlpha Flag whether alpha channel is being passed.
1827 * @param xHot Pointer hot spot x coordinate.
1828 * @param yHot Pointer hot spot y coordinate.
1829 * @param x Pointer new x coordinate on screen.
1830 * @param y Pointer new y coordinate on screen.
1831 * @param cx Pointer width in pixels.
1832 * @param cy Pointer height in pixels.
1833 * @param cbScanline Size of one scanline in bytes.
1834 * @param pvShape New shape buffer.
1835 * @thread The emulation thread.
1836 */
1837 DECLR3CALLBACKMEMBER(void, pfnUpdatePointerShape,(PPDMIVMMDEVCONNECTOR pInterface, bool fVisible, bool fAlpha,
1838 uint32_t xHot, uint32_t yHot,
1839 uint32_t cx, uint32_t cy,
1840 void *pvShape));
1841
1842 /**
1843 * Enable or disable video acceleration on behalf of guest.
1844 *
1845 * @param pInterface Pointer to this interface.
1846 * @param fEnable Whether to enable acceleration.
1847 * @param pVbvaMemory Video accelerator memory.
1848
1849 * @return VBox rc. VINF_SUCCESS if VBVA was enabled.
1850 * @thread The emulation thread.
1851 */
1852 DECLR3CALLBACKMEMBER(int, pfnVideoAccelEnable,(PPDMIVMMDEVCONNECTOR pInterface, bool fEnable, PVBVAMEMORY pVbvaMemory));
1853
1854 /**
1855 * Force video queue processing.
1856 *
1857 * @param pInterface Pointer to this interface.
1858 * @thread The emulation thread.
1859 */
1860 DECLR3CALLBACKMEMBER(void, pfnVideoAccelFlush,(PPDMIVMMDEVCONNECTOR pInterface));
1861
1862 /**
1863 * Return whether the given video mode is supported/wanted by the host.
1864 *
1865 * @returns VBox status code
1866 * @param pInterface Pointer to this interface.
1867 * @param cy Video mode horizontal resolution in pixels.
1868 * @param cx Video mode vertical resolution in pixels.
1869 * @param cBits Video mode bits per pixel.
1870 * @param pfSupported Where to put the indicator for whether this mode is supported. (output)
1871 * @thread The emulation thread.
1872 */
1873 DECLR3CALLBACKMEMBER(int, pfnVideoModeSupported,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, bool *pfSupported));
1874
1875 /**
1876 * Queries by how many pixels the height should be reduced when calculating video modes
1877 *
1878 * @returns VBox status code
1879 * @param pInterface Pointer to this interface.
1880 * @param pcyReduction Pointer to the result value.
1881 * @thread The emulation thread.
1882 */
1883 DECLR3CALLBACKMEMBER(int, pfnGetHeightReduction,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcyReduction));
1884
1885 /**
1886 * Informs about a credentials judgement result from the guest.
1887 *
1888 * @returns VBox status code
1889 * @param pInterface Pointer to this interface.
1890 * @param fFlags Judgement result flags.
1891 * @thread The emulation thread.
1892 */
1893 DECLR3CALLBACKMEMBER(int, pfnSetCredentialsJudgementResult,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t fFlags));
1894
1895 /**
1896 * Set the visible region of the display
1897 *
1898 * @returns VBox status code.
1899 * @param pInterface Pointer to this interface.
1900 * @param cRect Number of rectangles in pRect
1901 * @param pRect Rectangle array
1902 * @thread The emulation thread.
1903 */
1904 DECLR3CALLBACKMEMBER(int, pfnSetVisibleRegion,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t cRect, PRTRECT pRect));
1905
1906 /**
1907 * Query the visible region of the display
1908 *
1909 * @returns VBox status code.
1910 * @param pInterface Pointer to this interface.
1911 * @param pcRect Number of rectangles in pRect
1912 * @param pRect Rectangle array (set to NULL to query the number of rectangles)
1913 * @thread The emulation thread.
1914 */
1915 DECLR3CALLBACKMEMBER(int, pfnQueryVisibleRegion,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcRect, PRTRECT pRect));
1916
1917 /**
1918 * Request the statistics interval
1919 *
1920 * @returns VBox status code.
1921 * @param pInterface Pointer to this interface.
1922 * @param pulInterval Pointer to interval in seconds
1923 * @thread The emulation thread.
1924 */
1925 DECLR3CALLBACKMEMBER(int, pfnQueryStatisticsInterval,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pulInterval));
1926
1927 /**
1928 * Report new guest statistics
1929 *
1930 * @returns VBox status code.
1931 * @param pInterface Pointer to this interface.
1932 * @param pGuestStats Guest statistics
1933 * @thread The emulation thread.
1934 */
1935 DECLR3CALLBACKMEMBER(int, pfnReportStatistics,(PPDMIVMMDEVCONNECTOR pInterface, struct VBoxGuestStatistics *pGuestStats));
1936
1937 /**
1938 * Inflate or deflate the memory balloon
1939 *
1940 * @returns VBox status code.
1941 * @param pInterface Pointer to this interface.
1942 * @param fInflate Inflate or deflate
1943 * @param cPages Number of physical pages (must be 256 as we allocate in 1 MB chunks)
1944 * @param aPhysPage Array of physical page addresses
1945 * @thread The emulation thread.
1946 */
1947 DECLR3CALLBACKMEMBER(int, pfnChangeMemoryBalloon, (PPDMIVMMDEVCONNECTOR pInterface, bool fInflate, uint32_t cPages, RTGCPHYS *aPhysPage));
1948
1949} PDMIVMMDEVCONNECTOR;
1950
1951
1952/** Pointer to a network port interface */
1953typedef struct PDMINETWORKPORT *PPDMINETWORKPORT;
1954/**
1955 * Network port interface.
1956 */
1957typedef struct PDMINETWORKPORT
1958{
1959 /**
1960 * Wait until there is space for receiving data. We do not care how much space is available
1961 * because pfnReceive() will re-check and notify the guest if necessary.
1962 *
1963 * This function must be called before the pfnRecieve() method is called.
1964 *
1965 * @returns VBox status code. VINF_SUCCESS means there is at least one receive descriptor available.
1966 * @param pInterface Pointer to the interface structure containing the called function pointer.
1967 * @param cMillies Number of milliseconds to wait. 0 means return immediately.
1968 */
1969 DECLR3CALLBACKMEMBER(int, pfnWaitReceiveAvail,(PPDMINETWORKPORT pInterface, unsigned cMillies));
1970
1971 /**
1972 * Receive data from the network.
1973 *
1974 * @returns VBox status code.
1975 * @param pInterface Pointer to the interface structure containing the called function pointer.
1976 * @param pvBuf The available data.
1977 * @param cb Number of bytes available in the buffer.
1978 * @thread EMT
1979 */
1980 DECLR3CALLBACKMEMBER(int, pfnReceive,(PPDMINETWORKPORT pInterface, const void *pvBuf, size_t cb));
1981
1982} PDMINETWORKPORT;
1983
1984
1985/**
1986 * Network link state.
1987 */
1988typedef enum PDMNETWORKLINKSTATE
1989{
1990 /** Invalid state. */
1991 PDMNETWORKLINKSTATE_INVALID = 0,
1992 /** The link is up. */
1993 PDMNETWORKLINKSTATE_UP,
1994 /** The link is down. */
1995 PDMNETWORKLINKSTATE_DOWN,
1996 /** The link is temporarily down while resuming. */
1997 PDMNETWORKLINKSTATE_DOWN_RESUME
1998} PDMNETWORKLINKSTATE;
1999
2000
2001/** Pointer to a network connector interface */
2002typedef struct PDMINETWORKCONNECTOR *PPDMINETWORKCONNECTOR;
2003/**
2004 * Network connector interface.
2005 */
2006typedef struct PDMINETWORKCONNECTOR
2007{
2008 /**
2009 * Send data to the network.
2010 *
2011 * @returns VBox status code.
2012 * @param pInterface Pointer to the interface structure containing the called function pointer.
2013 * @param pvBuf Data to send.
2014 * @param cb Number of bytes to send.
2015 * @thread EMT
2016 */
2017 DECLR3CALLBACKMEMBER(int, pfnSend,(PPDMINETWORKCONNECTOR pInterface, const void *pvBuf, size_t cb));
2018
2019 /**
2020 * Set promiscuous mode.
2021 *
2022 * This is called when the promiscuous mode is set. This means that there doesn't have
2023 * to be a mode change when it's called.
2024 *
2025 * @param pInterface Pointer to the interface structure containing the called function pointer.
2026 * @param fPromiscuous Set if the adaptor is now in promiscuous mode. Clear if it is not.
2027 * @thread EMT
2028 */
2029 DECLR3CALLBACKMEMBER(void, pfnSetPromiscuousMode,(PPDMINETWORKCONNECTOR pInterface, bool fPromiscuous));
2030
2031 /**
2032 * Notification on link status changes.
2033 *
2034 * @param pInterface Pointer to the interface structure containing the called function pointer.
2035 * @param enmLinkState The new link state.
2036 * @thread EMT
2037 */
2038 DECLR3CALLBACKMEMBER(void, pfnNotifyLinkChanged,(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState));
2039
2040 /** @todo Add a callback that informs the driver chain about MAC address changes if we ever implement that. */
2041
2042} PDMINETWORKCONNECTOR;
2043
2044
2045/** Pointer to a network config port interface */
2046typedef struct PDMINETWORKCONFIG *PPDMINETWORKCONFIG;
2047/**
2048 * Network config port interface.
2049 */
2050typedef struct PDMINETWORKCONFIG
2051{
2052 /**
2053 * Gets the current Media Access Control (MAC) address.
2054 *
2055 * @returns VBox status code.
2056 * @param pInterface Pointer to the interface structure containing the called function pointer.
2057 * @param pMac Where to store the MAC address.
2058 * @thread EMT
2059 */
2060 DECLR3CALLBACKMEMBER(int, pfnGetMac,(PPDMINETWORKCONFIG pInterface, PRTMAC pMac));
2061
2062 /**
2063 * Gets the new link state.
2064 *
2065 * @returns The current link state.
2066 * @param pInterface Pointer to the interface structure containing the called function pointer.
2067 * @thread EMT
2068 */
2069 DECLR3CALLBACKMEMBER(PDMNETWORKLINKSTATE, pfnGetLinkState,(PPDMINETWORKCONFIG pInterface));
2070
2071 /**
2072 * Sets the new link state.
2073 *
2074 * @returns VBox status code.
2075 * @param pInterface Pointer to the interface structure containing the called function pointer.
2076 * @param enmState The new link state
2077 * @thread EMT
2078 */
2079 DECLR3CALLBACKMEMBER(int, pfnSetLinkState,(PPDMINETWORKCONFIG pInterface, PDMNETWORKLINKSTATE enmState));
2080
2081} PDMINETWORKCONFIG;
2082
2083
2084/** Pointer to a network connector interface */
2085typedef struct PDMIAUDIOCONNECTOR *PPDMIAUDIOCONNECTOR;
2086/**
2087 * Audio connector interface.
2088 */
2089typedef struct PDMIAUDIOCONNECTOR
2090{
2091 DECLR3CALLBACKMEMBER(void, pfnRun,(PPDMIAUDIOCONNECTOR pInterface));
2092
2093/* DECLR3CALLBACKMEMBER(int, pfnSetRecordSource,(PPDMIAUDIOINCONNECTOR pInterface, AUDIORECSOURCE)); */
2094
2095} PDMIAUDIOCONNECTOR;
2096
2097
2098/** @todo r=bird: the two following interfaces are hacks to work around the missing audio driver
2099 * interface. This should be addressed rather than making more temporary hacks. */
2100
2101/** Pointer to a Audio Sniffer Device port interface. */
2102typedef struct PDMIAUDIOSNIFFERPORT *PPDMIAUDIOSNIFFERPORT;
2103
2104/**
2105 * Audio Sniffer port interface.
2106 */
2107typedef struct PDMIAUDIOSNIFFERPORT
2108{
2109 /**
2110 * Enables or disables sniffing. If sniffing is being enabled also sets a flag
2111 * whether the audio must be also left on the host.
2112 *
2113 * @returns VBox status code
2114 * @param pInterface Pointer to this interface.
2115 * @param fEnable 'true' for enable sniffing, 'false' to disable.
2116 * @param fKeepHostAudio Indicates whether host audio should also present
2117 * 'true' means that sound should not be played
2118 * by the audio device.
2119 */
2120 DECLR3CALLBACKMEMBER(int, pfnSetup,(PPDMIAUDIOSNIFFERPORT pInterface, bool fEnable, bool fKeepHostAudio));
2121
2122} PDMIAUDIOSNIFFERPORT;
2123
2124/** Pointer to a Audio Sniffer connector interface. */
2125typedef struct PDMIAUDIOSNIFFERCONNECTOR *PPDMIAUDIOSNIFFERCONNECTOR;
2126
2127/**
2128 * Audio Sniffer connector interface.
2129 * Pair with PDMIAUDIOSNIFFERPORT.
2130 */
2131typedef struct PDMIAUDIOSNIFFERCONNECTOR
2132{
2133 /**
2134 * AudioSniffer device calls this method when audio samples
2135 * are about to be played and sniffing is enabled.
2136 *
2137 * @param pInterface Pointer to this interface.
2138 * @param pvSamples Audio samples buffer.
2139 * @param cSamples How many complete samples are in the buffer.
2140 * @param iSampleHz The sample frequency in Hz.
2141 * @param cChannels Number of channels. 1 for mono, 2 for stereo.
2142 * @param cBits How many bits a sample for a single channel has. Normally 8 or 16.
2143 * @param fUnsigned Whether samples are unsigned values.
2144 * @thread The emulation thread.
2145 */
2146 DECLR3CALLBACKMEMBER(void, pfnAudioSamplesOut,(PPDMIAUDIOSNIFFERCONNECTOR pInterface, void *pvSamples, uint32_t cSamples,
2147 int iSampleHz, int cChannels, int cBits, bool fUnsigned));
2148
2149 /**
2150 * AudioSniffer device calls this method when output volume is changed.
2151 *
2152 * @param pInterface Pointer to this interface.
2153 * @param u16LeftVolume 0..0xFFFF volume level for left channel.
2154 * @param u16RightVolume 0..0xFFFF volume level for right channel.
2155 * @thread The emulation thread.
2156 */
2157 DECLR3CALLBACKMEMBER(void, pfnAudioVolumeOut,(PPDMIAUDIOSNIFFERCONNECTOR pInterface, uint16_t u16LeftVolume, uint16_t u16RightVolume));
2158
2159} PDMIAUDIOSNIFFERCONNECTOR;
2160
2161
2162/**
2163 * Generic status LED core.
2164 * Note that a unit doesn't have to support all the indicators.
2165 */
2166typedef union PDMLEDCORE
2167{
2168 /** 32-bit view. */
2169 uint32_t volatile u32;
2170 /** Bit view. */
2171 struct
2172 {
2173 /** Reading/Receiving indicator. */
2174 uint32_t fReading : 1;
2175 /** Writing/Sending indicator. */
2176 uint32_t fWriting : 1;
2177 /** Busy indicator. */
2178 uint32_t fBusy : 1;
2179 /** Error indicator. */
2180 uint32_t fError : 1;
2181 } s;
2182} PDMLEDCORE;
2183
2184/** LED bit masks for the u32 view.
2185 * @{ */
2186/** Reading/Receiving indicator. */
2187#define PDMLED_READING RT_BIT(0)
2188/** Writing/Sending indicator. */
2189#define PDMLED_WRITING RT_BIT(1)
2190/** Busy indicator. */
2191#define PDMLED_BUSY RT_BIT(2)
2192/** Error indicator. */
2193#define PDMLED_ERROR RT_BIT(3)
2194/** @} */
2195
2196
2197/**
2198 * Generic status LED.
2199 * Note that a unit doesn't have to support all the indicators.
2200 */
2201typedef struct PDMLED
2202{
2203 /** Just a magic for sanity checking. */
2204 uint32_t u32Magic;
2205 uint32_t u32Alignment; /**< structure size alignment. */
2206 /** The actual LED status.
2207 * Only the device is allowed to change this. */
2208 PDMLEDCORE Actual;
2209 /** The asserted LED status which is cleared by the reader.
2210 * The device will assert the bits but never clear them.
2211 * The driver clears them as it sees fit. */
2212 PDMLEDCORE Asserted;
2213} PDMLED;
2214
2215/** Pointer to an LED. */
2216typedef PDMLED *PPDMLED;
2217/** Pointer to a const LED. */
2218typedef const PDMLED *PCPDMLED;
2219
2220#define PDMLED_MAGIC ( 0x11335577 )
2221
2222/** Pointer to an LED ports interface. */
2223typedef struct PDMILEDPORTS *PPDMILEDPORTS;
2224/**
2225 * Interface for exporting LEDs.
2226 */
2227typedef struct PDMILEDPORTS
2228{
2229 /**
2230 * Gets the pointer to the status LED of a unit.
2231 *
2232 * @returns VBox status code.
2233 * @param pInterface Pointer to the interface structure containing the called function pointer.
2234 * @param iLUN The unit which status LED we desire.
2235 * @param ppLed Where to store the LED pointer.
2236 */
2237 DECLR3CALLBACKMEMBER(int, pfnQueryStatusLed,(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed));
2238
2239} PDMILEDPORTS;
2240
2241
2242/** Pointer to an LED connectors interface. */
2243typedef struct PDMILEDCONNECTORS *PPDMILEDCONNECTORS;
2244/**
2245 * Interface for reading LEDs.
2246 */
2247typedef struct PDMILEDCONNECTORS
2248{
2249 /**
2250 * Notification about a unit which have been changed.
2251 *
2252 * The driver must discard any pointers to data owned by
2253 * the unit and requery it.
2254 *
2255 * @param pInterface Pointer to the interface structure containing the called function pointer.
2256 * @param iLUN The unit number.
2257 */
2258 DECLR3CALLBACKMEMBER(void, pfnUnitChanged,(PPDMILEDCONNECTORS pInterface, unsigned iLUN));
2259} PDMILEDCONNECTORS;
2260
2261
2262/** The special status unit number */
2263#define PDM_STATUS_LUN 999
2264
2265
2266#ifdef VBOX_WITH_HGCM
2267
2268/** Abstract HGCM command structure. Used only to define a typed pointer. */
2269struct VBOXHGCMCMD;
2270
2271/** Pointer to HGCM command structure. This pointer is unique and identifies
2272 * the command being processed. The pointer is passed to HGCM connector methods,
2273 * and must be passed back to HGCM port when command is completed.
2274 */
2275typedef struct VBOXHGCMCMD *PVBOXHGCMCMD;
2276
2277/** Pointer to a HGCM port interface. */
2278typedef struct PDMIHGCMPORT *PPDMIHGCMPORT;
2279
2280/**
2281 * HGCM port interface. Normally implemented by VMMDev.
2282 */
2283typedef struct PDMIHGCMPORT
2284{
2285 /**
2286 * Notify the guest on a command completion.
2287 *
2288 * @param pInterface Pointer to this interface.
2289 * @param rc The return code (VBox error code).
2290 * @param pCmd A pointer that identifies the completed command.
2291 *
2292 * @returns VBox status code
2293 */
2294 DECLR3CALLBACKMEMBER(void, pfnCompleted,(PPDMIHGCMPORT pInterface, int32_t rc, PVBOXHGCMCMD pCmd));
2295
2296} PDMIHGCMPORT;
2297
2298
2299/** Pointer to a HGCM connector interface. */
2300typedef struct PDMIHGCMCONNECTOR *PPDMIHGCMCONNECTOR;
2301
2302/** Pointer to a HGCM service location structure. */
2303typedef struct HGCMSERVICELOCATION *PHGCMSERVICELOCATION;
2304
2305/**
2306 * HGCM connector interface.
2307 * Pair with PDMIHGCMPORT.
2308 */
2309typedef struct PDMIHGCMCONNECTOR
2310{
2311 /**
2312 * Locate a service and inform it about a client connection.
2313 *
2314 * @param pInterface Pointer to this interface.
2315 * @param pCmd A pointer that identifies the command.
2316 * @param pServiceLocation Pointer to the service location structure.
2317 * @param pu32ClientID Where to store the client id for the connection.
2318 * @return VBox status code.
2319 * @thread The emulation thread.
2320 */
2321 DECLR3CALLBACKMEMBER(int, pfnConnect,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, PHGCMSERVICELOCATION pServiceLocation, uint32_t *pu32ClientID));
2322
2323 /**
2324 * Disconnect from service.
2325 *
2326 * @param pInterface Pointer to this interface.
2327 * @param pCmd A pointer that identifies the command.
2328 * @param u32ClientID The client id returned by the pfnConnect call.
2329 * @return VBox status code.
2330 * @thread The emulation thread.
2331 */
2332 DECLR3CALLBACKMEMBER(int, pfnDisconnect,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID));
2333
2334 /**
2335 * Process a guest issued command.
2336 *
2337 * @param pInterface Pointer to this interface.
2338 * @param pCmd A pointer that identifies the command.
2339 * @param u32ClientID The client id returned by the pfnConnect call.
2340 * @param u32Function Function to be performed by the service.
2341 * @param cParms Number of parameters in the array pointed to by paParams.
2342 * @param paParms Pointer to an array of parameters.
2343 * @return VBox status code.
2344 * @thread The emulation thread.
2345 */
2346 DECLR3CALLBACKMEMBER(int, pfnCall,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID, uint32_t u32Function,
2347 uint32_t cParms, PVBOXHGCMSVCPARM paParms));
2348
2349} PDMIHGCMCONNECTOR;
2350
2351#endif
2352
2353/**
2354 * Data direction.
2355 */
2356typedef enum PDMSCSIREQUESTTXDIR
2357{
2358 PDMSCSIREQUESTTXDIR_UNKNOWN = 0x00,
2359 PDMSCSIREQUESTTXDIR_FROM_DEVICE = 0x01,
2360 PDMSCSIREQUESTTXDIR_TO_DEVICE = 0x02,
2361 PDMSCSIREQUESTTXDIR_NONE = 0x03,
2362 PDMSCSIREQUESTTXDIR_32BIT_HACK = 0x7fffffff
2363} PDMSCSIREQUESTTXDIR;
2364
2365/**
2366 * SCSI request structure.
2367 */
2368typedef struct PDMSCSIREQUEST
2369{
2370 /** The logical unit. */
2371 uint32_t uLogicalUnit;
2372 /** Direction of the data flow. */
2373 PDMSCSIREQUESTTXDIR uDataDirection;
2374 /** Size of the SCSI CDB. */
2375 uint32_t cbCDB;
2376 /** Pointer to the SCSI CDB. */
2377 uint8_t *pbCDB;
2378 /** Overall size of all scatter gather list elements
2379 * for data transfer if any. */
2380 uint32_t cbScatterGather;
2381 /** Number of elements in the scatter gather list. */
2382 uint32_t cScatterGatherEntries;
2383 /** Pointer to the head of the scatter gather list. */
2384 PPDMDATASEG paScatterGatherHead;
2385 /** Size of the sense buffer. */
2386 uint32_t cbSenseBuffer;
2387 /** Pointer to the sense buffer. *
2388 * Current assumption that the sense buffer is not scattered. */
2389 uint8_t *pbSenseBuffer;
2390 /** Opaque user data for use by the device. Left untouched by everything else! */
2391 void *pvUser;
2392} PDMSCSIREQUEST, *PPDMSCSIREQUEST;
2393/** Pointer to a const SCSI request structure. */
2394typedef const PDMSCSIREQUEST *PCSCSIREQUEST;
2395
2396/** Pointer to a SCSI port interface. */
2397typedef struct PDMISCSIPORT *PPDMISCSIPORT;
2398
2399/**
2400 * SCSI port interface.
2401 * Pair with PDMISCSICONNECTOR.
2402 */
2403typedef struct PDMISCSIPORT
2404{
2405
2406 /**
2407 * Notify the device on request completion.
2408 *
2409 * @returns VBox status code.
2410 * @param pInterface Pointer to this interface.
2411 * @param pSCSIRequest Pointer to the finished SCSI request.
2412 * @param rcCompletion SCSI_STATUS_* code for the completed request.
2413 */
2414 DECLR3CALLBACKMEMBER(int, pfnSCSIRequestCompleted, (PPDMISCSIPORT pInterface, PPDMSCSIREQUEST pSCSIRequest, int rcCompletion));
2415
2416} PDMISCSIPORT;
2417
2418/** Pointer to a SCSI connector interface. */
2419typedef struct PDMISCSICONNECTOR *PPDMISCSICONNECTOR;
2420
2421/**
2422 * SCSI connector interface.
2423 * Pair with PDMISCSIPORT.
2424 */
2425typedef struct PDMISCSICONNECTOR
2426{
2427
2428 /**
2429 * Submits a SCSI request for execution.
2430 *
2431 * @returns VBox status code.
2432 * @param pInterface Pointer to this interface.
2433 * @param pSCSIRequest Pointer to the SCSI request to execute.
2434 */
2435 DECLR3CALLBACKMEMBER(int, pfnSCSIRequestSend, (PPDMISCSICONNECTOR pInterface, PPDMSCSIREQUEST pSCSIRequest));
2436
2437} PDMISCSICONNECTOR;
2438
2439typedef struct PDMDDISPLAYVBVACALLBACKS *PPDMDDISPLAYVBVACALLBACKS;
2440/**
2441 * Display VBVA callbacks.
2442 */
2443typedef struct PDMDDISPLAYVBVACALLBACKS
2444{
2445
2446 /**
2447 * Informs guest about completion of processing the given Video HW Acceleration
2448 * command, does not wait for the guest to process the command.
2449 *
2450 * @returns ???
2451 * @param pInterface Pointer to this interface.
2452 * @param pCmd The Video HW Acceleration Command that was
2453 * completed.
2454 * @todo r=bird: if asynch mean asyncronous; then
2455 * s/pfnVHWACommandCompleteAsynch/pfnVHWACommandCompleteAsync/;
2456 * fi
2457 */
2458 DECLR3CALLBACKMEMBER(int, pfnVHWACommandCompleteAsynch, (PPDMDDISPLAYVBVACALLBACKS pInterface, PVBOXVHWACMD pCmd));
2459
2460} PDMDDISPLAYVBVACALLBACKS;
2461
2462/** @} */
2463
2464RT_C_DECLS_END
2465
2466#endif
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