VirtualBox

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

Last change on this file since 35020 was 34906, checked in by vboxsync, 14 years ago

Initial audio filter implementation, which is used for audio input via remote desktop server.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 115.8 KB
Line 
1/** @file
2 * PDM - Pluggable Device Manager, Interfaces. (VMM)
3 */
4
5/*
6 * Copyright (C) 2006-2010 Oracle Corporation
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
26#ifndef ___VBox_pdmifs_h
27#define ___VBox_pdmifs_h
28
29#include <iprt/sg.h>
30#include <VBox/types.h>
31#include <VBox/hgcmsvc.h>
32
33RT_C_DECLS_BEGIN
34
35/** @defgroup grp_pdm_interfaces The PDM Interface Definitions
36 * @ingroup grp_pdm
37 *
38 * For historical reasons (the PDMINTERFACE enum) a lot of interface was stuffed
39 * together in this group instead, dragging stuff into global space that didn't
40 * need to be there and making this file huge (>2500 lines). Since we're using
41 * UUIDs as interface identifiers (IIDs) now, no only generic PDM interface will
42 * be added to this file. Component specific interface should be defined in the
43 * header file of that component.
44 *
45 * Interfaces consists of a method table (typedef'ed struct) and an interface
46 * ID. The typename of the method table should have an 'I' in it, be all
47 * capitals and according to the rules, no underscores. The interface ID is a
48 * \#define constructed by appending '_IID' to the typename. The IID value is a
49 * UUID string on the form "a2299c0d-b709-4551-aa5a-73f59ffbed74". If you stick
50 * to these rules, you can make use of the PDMIBASE_QUERY_INTERFACE and
51 * PDMIBASE_RETURN_INTERFACE when querying interface and implementing
52 * PDMIBASE::pfnQueryInterface respectively.
53 *
54 * In most interface descriptions the orientation of the interface is given as
55 * 'down' or 'up'. This refers to a model with the device on the top and the
56 * drivers stacked below it. Sometimes there is mention of 'main' or 'external'
57 * which normally means the same, i.e. the Main or VBoxBFE API. Picture the
58 * orientation of 'main' as horizontal.
59 *
60 * @{
61 */
62
63
64/** @name PDMIBASE
65 * @{
66 */
67
68/**
69 * PDM Base Interface.
70 *
71 * Everyone implements this.
72 */
73typedef struct PDMIBASE
74{
75 /**
76 * Queries an interface to the driver.
77 *
78 * @returns Pointer to interface.
79 * @returns NULL if the interface was not supported by the driver.
80 * @param pInterface Pointer to this interface structure.
81 * @param pszIID The interface ID, a UUID string.
82 * @thread Any thread.
83 */
84 DECLR3CALLBACKMEMBER(void *, pfnQueryInterface,(struct PDMIBASE *pInterface, const char *pszIID));
85} PDMIBASE;
86/** PDMIBASE interface ID. */
87#define PDMIBASE_IID "a2299c0d-b709-4551-aa5a-73f59ffbed74"
88
89/**
90 * Helper macro for querying an interface from PDMIBASE.
91 *
92 * @returns Correctly typed PDMIBASE::pfnQueryInterface return value.
93 *
94 * @param pIBase Pointer to the base interface.
95 * @param InterfaceType The interface type name. The interface ID is
96 * derived from this by appending _IID.
97 */
98#define PDMIBASE_QUERY_INTERFACE(pIBase, InterfaceType) \
99 ( (InterfaceType *)(pIBase)->pfnQueryInterface(pIBase, InterfaceType##_IID ) )
100
101/**
102 * Helper macro for implementing PDMIBASE::pfnQueryInterface.
103 *
104 * Return @a pInterface if @a pszIID matches the @a InterfaceType. This will
105 * perform basic type checking.
106 *
107 * @param pszIID The ID of the interface that is being queried.
108 * @param InterfaceType The interface type name. The interface ID is
109 * derived from this by appending _IID.
110 * @param pInterface The interface address expression.
111 */
112#define PDMIBASE_RETURN_INTERFACE(pszIID, InterfaceType, pInterface) \
113 do { \
114 if (RTUuidCompare2Strs((pszIID), InterfaceType##_IID) == 0) \
115 { \
116 P##InterfaceType pReturnInterfaceTypeCheck = (pInterface); \
117 return pReturnInterfaceTypeCheck; \
118 } \
119 } while (0)
120
121/** @} */
122
123
124/** @name PDMIBASERC
125 * @{
126 */
127
128/**
129 * PDM Base Interface for querying ring-mode context interfaces in
130 * ring-3.
131 *
132 * This is mandatory for drivers present in raw-mode context.
133 */
134typedef struct PDMIBASERC
135{
136 /**
137 * Queries an ring-mode context interface to the driver.
138 *
139 * @returns Pointer to interface.
140 * @returns NULL if the interface was not supported by the driver.
141 * @param pInterface Pointer to this interface structure.
142 * @param pszIID The interface ID, a UUID string.
143 * @thread Any thread.
144 */
145 DECLR3CALLBACKMEMBER(RTRCPTR, pfnQueryInterface,(struct PDMIBASERC *pInterface, const char *pszIID));
146} PDMIBASERC;
147/** Pointer to a PDM Base Interface for query ring-mode context interfaces. */
148typedef PDMIBASERC *PPDMIBASERC;
149/** PDMIBASERC interface ID. */
150#define PDMIBASERC_IID "f6a6c649-6cb3-493f-9737-4653f221aeca"
151
152/**
153 * Helper macro for querying an interface from PDMIBASERC.
154 *
155 * @returns PDMIBASERC::pfnQueryInterface return value.
156 *
157 * @param pIBaseRC Pointer to the base raw-mode context interface. Can
158 * be NULL.
159 * @param InterfaceType The interface type base name, no trailing RC. The
160 * interface ID is derived from this by appending _IID.
161 *
162 * @remarks Unlike PDMIBASE_QUERY_INTERFACE, this macro is not able to do any
163 * implicit type checking for you.
164 */
165#define PDMIBASERC_QUERY_INTERFACE(pIBaseRC, InterfaceType) \
166 ( (P##InterfaceType##RC)((pIBaseRC) ? (pIBaseRC)->pfnQueryInterface(pIBaseRC, InterfaceType##_IID) : NIL_RTRCPTR) )
167
168/**
169 * Helper macro for implementing PDMIBASERC::pfnQueryInterface.
170 *
171 * Return @a pInterface if @a pszIID matches the @a InterfaceType. This will
172 * perform basic type checking.
173 *
174 * @param pIns Pointer to the instance data.
175 * @param pszIID The ID of the interface that is being queried.
176 * @param InterfaceType The interface type base name, no trailing RC. The
177 * interface ID is derived from this by appending _IID.
178 * @param pInterface The interface address expression. This must resolve
179 * to some address within the instance data.
180 * @remarks Don't use with PDMIBASE.
181 */
182#define PDMIBASERC_RETURN_INTERFACE(pIns, pszIID, InterfaceType, pInterface) \
183 do { \
184 Assert((uintptr_t)pInterface - PDMINS_2_DATA(pIns, uintptr_t) < _4M); \
185 if (RTUuidCompare2Strs((pszIID), InterfaceType##_IID) == 0) \
186 { \
187 InterfaceType##RC *pReturnInterfaceTypeCheck = (pInterface); \
188 return (uintptr_t)pReturnInterfaceTypeCheck \
189 - PDMINS_2_DATA(pIns, uintptr_t) \
190 + PDMINS_2_DATA_RCPTR(pIns); \
191 } \
192 } while (0)
193
194/** @} */
195
196
197/** @name PDMIBASER0
198 * @{
199 */
200
201/**
202 * PDM Base Interface for querying ring-0 interfaces in ring-3.
203 *
204 * This is mandatory for drivers present in ring-0 context.
205 */
206typedef struct PDMIBASER0
207{
208 /**
209 * Queries an ring-0 interface to the driver.
210 *
211 * @returns Pointer to interface.
212 * @returns NULL if the interface was not supported by the driver.
213 * @param pInterface Pointer to this interface structure.
214 * @param pszIID The interface ID, a UUID string.
215 * @thread Any thread.
216 */
217 DECLR3CALLBACKMEMBER(RTR0PTR, pfnQueryInterface,(struct PDMIBASER0 *pInterface, const char *pszIID));
218} PDMIBASER0;
219/** Pointer to a PDM Base Interface for query ring-0 context interfaces. */
220typedef PDMIBASER0 *PPDMIBASER0;
221/** PDMIBASER0 interface ID. */
222#define PDMIBASER0_IID "9c9b99b8-7f53-4f59-a3c2-5bc9659c7944"
223
224/**
225 * Helper macro for querying an interface from PDMIBASER0.
226 *
227 * @returns PDMIBASER0::pfnQueryInterface return value.
228 *
229 * @param pIBaseR0 Pointer to the base ring-0 interface. Can be NULL.
230 * @param InterfaceType The interface type base name, no trailing R0. The
231 * interface ID is derived from this by appending _IID.
232 *
233 * @remarks Unlike PDMIBASE_QUERY_INTERFACE, this macro is not able to do any
234 * implicit type checking for you.
235 */
236#define PDMIBASER0_QUERY_INTERFACE(pIBaseR0, InterfaceType) \
237 ( (P##InterfaceType##R0)((pIBaseR0) ? (pIBaseR0)->pfnQueryInterface(pIBaseR0, InterfaceType##_IID) : NIL_RTR0PTR) )
238
239/**
240 * Helper macro for implementing PDMIBASER0::pfnQueryInterface.
241 *
242 * Return @a pInterface if @a pszIID matches the @a InterfaceType. This will
243 * perform basic type checking.
244 *
245 * @param pIns Pointer to the instance data.
246 * @param pszIID The ID of the interface that is being queried.
247 * @param InterfaceType The interface type base name, no trailing R0. The
248 * interface ID is derived from this by appending _IID.
249 * @param pInterface The interface address expression. This must resolve
250 * to some address within the instance data.
251 * @remarks Don't use with PDMIBASE.
252 */
253#define PDMIBASER0_RETURN_INTERFACE(pIns, pszIID, InterfaceType, pInterface) \
254 do { \
255 Assert((uintptr_t)pInterface - PDMINS_2_DATA(pIns, uintptr_t) < _4M); \
256 if (RTUuidCompare2Strs((pszIID), InterfaceType##_IID) == 0) \
257 { \
258 InterfaceType##R0 *pReturnInterfaceTypeCheck = (pInterface); \
259 return (uintptr_t)pReturnInterfaceTypeCheck \
260 - PDMINS_2_DATA(pIns, uintptr_t) \
261 + PDMINS_2_DATA_R0PTR(pIns); \
262 } \
263 } while (0)
264
265/** @} */
266
267
268/**
269 * Dummy interface.
270 *
271 * This is used to typedef other dummy interfaces. The purpose of a dummy
272 * interface is to validate the logical function of a driver/device and
273 * full a natural interface pair.
274 */
275typedef struct PDMIDUMMY
276{
277 RTHCPTR pvDummy;
278} PDMIDUMMY;
279
280
281/** Pointer to a mouse port interface. */
282typedef struct PDMIMOUSEPORT *PPDMIMOUSEPORT;
283/**
284 * Mouse port interface (down).
285 * Pair with PDMIMOUSECONNECTOR.
286 */
287typedef struct PDMIMOUSEPORT
288{
289 /**
290 * Puts a mouse event.
291 *
292 * This is called by the source of mouse events. The event will be passed up
293 * until the topmost driver, which then calls the registered event handler.
294 *
295 * @returns VBox status code. Return VERR_TRY_AGAIN if you cannot process the
296 * event now and want it to be repeated at a later point.
297 *
298 * @param pInterface Pointer to this interface structure.
299 * @param iDeltaX The X delta.
300 * @param iDeltaY The Y delta.
301 * @param iDeltaZ The Z delta.
302 * @param iDeltaW The W (horizontal scroll button) delta.
303 * @param fButtonStates The button states, see the PDMIMOUSEPORT_BUTTON_* \#defines.
304 */
305 DECLR3CALLBACKMEMBER(int, pfnPutEvent,(PPDMIMOUSEPORT pInterface, int32_t iDeltaX, int32_t iDeltaY, int32_t iDeltaZ, int32_t iDeltaW, uint32_t fButtonStates));
306 /**
307 * Puts an absolute mouse event.
308 *
309 * This is called by the source of mouse events. The event will be passed up
310 * until the topmost driver, which then calls the registered event handler.
311 *
312 * @returns VBox status code. Return VERR_TRY_AGAIN if you cannot process the
313 * event now and want it to be repeated at a later point.
314 *
315 * @param pInterface Pointer to this interface structure.
316 * @param uX The X value, in the range 0 to 0xffff.
317 * @param uY The Y value, in the range 0 to 0xffff.
318 * @param iDeltaZ The Z delta.
319 * @param iDeltaW The W (horizontal scroll button) delta.
320 * @param fButtonStates The button states, see the PDMIMOUSEPORT_BUTTON_* \#defines.
321 */
322 DECLR3CALLBACKMEMBER(int, pfnPutEventAbs,(PPDMIMOUSEPORT pInterface, uint32_t uX, uint32_t uY, int32_t iDeltaZ, int32_t iDeltaW, uint32_t fButtonStates));
323} PDMIMOUSEPORT;
324/** PDMIMOUSEPORT interface ID. */
325#define PDMIMOUSEPORT_IID "442136fe-6f3c-49ec-9964-259b378ffa64"
326
327/** Mouse button defines for PDMIMOUSEPORT::pfnPutEvent.
328 * @{ */
329#define PDMIMOUSEPORT_BUTTON_LEFT RT_BIT(0)
330#define PDMIMOUSEPORT_BUTTON_RIGHT RT_BIT(1)
331#define PDMIMOUSEPORT_BUTTON_MIDDLE RT_BIT(2)
332#define PDMIMOUSEPORT_BUTTON_X1 RT_BIT(3)
333#define PDMIMOUSEPORT_BUTTON_X2 RT_BIT(4)
334/** @} */
335
336
337/** Pointer to a mouse connector interface. */
338typedef struct PDMIMOUSECONNECTOR *PPDMIMOUSECONNECTOR;
339/**
340 * Mouse connector interface (up).
341 * Pair with PDMIMOUSEPORT.
342 */
343typedef struct PDMIMOUSECONNECTOR
344{
345 /**
346 * Notifies the the downstream driver of changes to the reporting modes
347 * supported by the driver
348 *
349 * @param pInterface Pointer to the this interface.
350 * @param fRelative Whether relative mode is currently supported.
351 * @param fAbsolute Whether absolute mode is currently supported.
352 */
353 DECLR3CALLBACKMEMBER(void, pfnReportModes,(PPDMIMOUSECONNECTOR pInterface, bool fRelative, bool fAbsolute));
354
355} PDMIMOUSECONNECTOR;
356/** PDMIMOUSECONNECTOR interface ID. */
357#define PDMIMOUSECONNECTOR_IID "ce64d7bd-fa8f-41d1-a6fb-d102a2d6bffe"
358
359
360/** Pointer to a keyboard port interface. */
361typedef struct PDMIKEYBOARDPORT *PPDMIKEYBOARDPORT;
362/**
363 * Keyboard port interface (down).
364 * Pair with PDMIKEYBOARDCONNECTOR.
365 */
366typedef struct PDMIKEYBOARDPORT
367{
368 /**
369 * Puts a keyboard event.
370 *
371 * This is called by the source of keyboard events. The event will be passed up
372 * until the topmost driver, which then calls the registered event handler.
373 *
374 * @returns VBox status code. Return VERR_TRY_AGAIN if you cannot process the
375 * event now and want it to be repeated at a later point.
376 *
377 * @param pInterface Pointer to this interface structure.
378 * @param u8KeyCode The keycode to queue.
379 */
380 DECLR3CALLBACKMEMBER(int, pfnPutEvent,(PPDMIKEYBOARDPORT pInterface, uint8_t u8KeyCode));
381} PDMIKEYBOARDPORT;
382/** PDMIKEYBOARDPORT interface ID. */
383#define PDMIKEYBOARDPORT_IID "2a0844f0-410b-40ab-a6ed-6575f3aa3e29"
384
385
386/**
387 * Keyboard LEDs.
388 */
389typedef enum PDMKEYBLEDS
390{
391 /** No leds. */
392 PDMKEYBLEDS_NONE = 0x0000,
393 /** Num Lock */
394 PDMKEYBLEDS_NUMLOCK = 0x0001,
395 /** Caps Lock */
396 PDMKEYBLEDS_CAPSLOCK = 0x0002,
397 /** Scroll Lock */
398 PDMKEYBLEDS_SCROLLLOCK = 0x0004
399} PDMKEYBLEDS;
400
401/** Pointer to keyboard connector interface. */
402typedef struct PDMIKEYBOARDCONNECTOR *PPDMIKEYBOARDCONNECTOR;
403/**
404 * Keyboard connector interface (up).
405 * Pair with PDMIKEYBOARDPORT
406 */
407typedef struct PDMIKEYBOARDCONNECTOR
408{
409 /**
410 * Notifies the the downstream driver about an LED change initiated by the guest.
411 *
412 * @param pInterface Pointer to the this interface.
413 * @param enmLeds The new led mask.
414 */
415 DECLR3CALLBACKMEMBER(void, pfnLedStatusChange,(PPDMIKEYBOARDCONNECTOR pInterface, PDMKEYBLEDS enmLeds));
416
417 /**
418 * Notifies the the downstream driver of changes in driver state.
419 *
420 * @param pInterface Pointer to the this interface.
421 * @param fActive Whether interface wishes to get "focus".
422 */
423 DECLR3CALLBACKMEMBER(void, pfnSetActive,(PPDMIKEYBOARDCONNECTOR pInterface, bool fActive));
424
425} PDMIKEYBOARDCONNECTOR;
426/** PDMIKEYBOARDCONNECTOR interface ID. */
427#define PDMIKEYBOARDCONNECTOR_IID "db3f7bd5-953e-436f-9f8e-077905a92d82"
428
429
430
431/** Pointer to a display port interface. */
432typedef struct PDMIDISPLAYPORT *PPDMIDISPLAYPORT;
433/**
434 * Display port interface (down).
435 * Pair with PDMIDISPLAYCONNECTOR.
436 */
437typedef struct PDMIDISPLAYPORT
438{
439 /**
440 * Update the display with any changed regions.
441 *
442 * Flushes any display changes to the memory pointed to by the
443 * PDMIDISPLAYCONNECTOR interface and calles PDMIDISPLAYCONNECTOR::pfnUpdateRect()
444 * while doing so.
445 *
446 * @returns VBox status code.
447 * @param pInterface Pointer to this interface.
448 * @thread The emulation thread.
449 */
450 DECLR3CALLBACKMEMBER(int, pfnUpdateDisplay,(PPDMIDISPLAYPORT pInterface));
451
452 /**
453 * Update the entire display.
454 *
455 * Flushes the entire display content to the memory pointed to by the
456 * PDMIDISPLAYCONNECTOR interface and calles PDMIDISPLAYCONNECTOR::pfnUpdateRect().
457 *
458 * @returns VBox status code.
459 * @param pInterface Pointer to this interface.
460 * @thread The emulation thread.
461 */
462 DECLR3CALLBACKMEMBER(int, pfnUpdateDisplayAll,(PPDMIDISPLAYPORT pInterface));
463
464 /**
465 * Return the current guest color depth in bits per pixel (bpp).
466 *
467 * As the graphics card is able to provide display updates with the bpp
468 * requested by the host, this method can be used to query the actual
469 * guest color depth.
470 *
471 * @returns VBox status code.
472 * @param pInterface Pointer to this interface.
473 * @param pcBits Where to store the current guest color depth.
474 * @thread Any thread.
475 */
476 DECLR3CALLBACKMEMBER(int, pfnQueryColorDepth,(PPDMIDISPLAYPORT pInterface, uint32_t *pcBits));
477
478 /**
479 * Sets the refresh rate and restart the timer.
480 * The rate is defined as the minimum interval between the return of
481 * one PDMIDISPLAYPORT::pfnRefresh() call to the next one.
482 *
483 * The interval timer will be restarted by this call. So at VM startup
484 * this function must be called to start the refresh cycle. The refresh
485 * rate is not saved, but have to be when resuming a loaded VM state.
486 *
487 * @returns VBox status code.
488 * @param pInterface Pointer to this interface.
489 * @param cMilliesInterval Number of millis between two refreshes.
490 * @thread Any thread.
491 */
492 DECLR3CALLBACKMEMBER(int, pfnSetRefreshRate,(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval));
493
494 /**
495 * Create a 32-bbp screenshot of the display.
496 *
497 * This will allocate and return a 32-bbp bitmap. Size of the bitmap scanline in bytes is 4*width.
498 *
499 * The allocated bitmap buffer must be freed with pfnFreeScreenshot.
500 *
501 * @param pInterface Pointer to this interface.
502 * @param ppu8Data Where to store the pointer to the allocated buffer.
503 * @param pcbData Where to store the actual size of the bitmap.
504 * @param pcx Where to store the width of the bitmap.
505 * @param pcy Where to store the height of the bitmap.
506 * @thread The emulation thread.
507 */
508 DECLR3CALLBACKMEMBER(int, pfnTakeScreenshot,(PPDMIDISPLAYPORT pInterface, uint8_t **ppu8Data, size_t *pcbData, uint32_t *pcx, uint32_t *pcy));
509
510 /**
511 * Free screenshot buffer.
512 *
513 * This will free the memory buffer allocated by pfnTakeScreenshot.
514 *
515 * @param pInterface Pointer to this interface.
516 * @param ppu8Data Pointer to the buffer returned by pfnTakeScreenshot.
517 * @thread Any.
518 */
519 DECLR3CALLBACKMEMBER(void, pfnFreeScreenshot,(PPDMIDISPLAYPORT pInterface, uint8_t *pu8Data));
520
521 /**
522 * Copy bitmap to the display.
523 *
524 * This will convert and copy a 32-bbp bitmap (with dword aligned scanline length) to
525 * the memory pointed to by the PDMIDISPLAYCONNECTOR interface.
526 *
527 * @param pInterface Pointer to this interface.
528 * @param pvData Pointer to the bitmap bits.
529 * @param x The upper left corner x coordinate of the destination rectangle.
530 * @param y The upper left corner y coordinate of the destination rectangle.
531 * @param cx The width of the source and destination rectangles.
532 * @param cy The height of the source and destination rectangles.
533 * @thread The emulation thread.
534 * @remark This is just a convenience for using the bitmap conversions of the
535 * graphics device.
536 */
537 DECLR3CALLBACKMEMBER(int, pfnDisplayBlt,(PPDMIDISPLAYPORT pInterface, const void *pvData, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy));
538
539 /**
540 * Render a rectangle from guest VRAM to Framebuffer.
541 *
542 * @param pInterface Pointer to this interface.
543 * @param x The upper left corner x coordinate of the rectangle to be updated.
544 * @param y The upper left corner y coordinate of the rectangle to be updated.
545 * @param cx The width of the rectangle to be updated.
546 * @param cy The height of the rectangle to be updated.
547 * @thread The emulation thread.
548 */
549 DECLR3CALLBACKMEMBER(void, pfnUpdateDisplayRect,(PPDMIDISPLAYPORT pInterface, int32_t x, int32_t y, uint32_t cx, uint32_t cy));
550
551 /**
552 * Inform the VGA device whether the Display is directly using the guest VRAM and there is no need
553 * to render the VRAM to the framebuffer memory.
554 *
555 * @param pInterface Pointer to this interface.
556 * @param fRender Whether the VRAM content must be rendered to the framebuffer.
557 * @thread The emulation thread.
558 */
559 DECLR3CALLBACKMEMBER(void, pfnSetRenderVRAM,(PPDMIDISPLAYPORT pInterface, bool fRender));
560
561 /**
562 * Render a bitmap rectangle from source to target buffer.
563 *
564 * @param pInterface Pointer to this interface.
565 * @param cx The width of the rectangle to be copied.
566 * @param cy The height of the rectangle to be copied.
567 * @param pbSrc Source frame buffer 0,0.
568 * @param xSrc The upper left corner x coordinate of the source rectangle.
569 * @param ySrc The upper left corner y coordinate of the source rectangle.
570 * @param cxSrc The width of the source frame buffer.
571 * @param cySrc The height of the source frame buffer.
572 * @param cbSrcLine The line length of the source frame buffer.
573 * @param cSrcBitsPerPixel The pixel depth of the source.
574 * @param pbDst Destination frame buffer 0,0.
575 * @param xDst The upper left corner x coordinate of the destination rectangle.
576 * @param yDst The upper left corner y coordinate of the destination rectangle.
577 * @param cxDst The width of the destination frame buffer.
578 * @param cyDst The height of the destination frame buffer.
579 * @param cbDstLine The line length of the destination frame buffer.
580 * @param cDstBitsPerPixel The pixel depth of the destination.
581 * @thread The emulation thread.
582 */
583 DECLR3CALLBACKMEMBER(int, pfnCopyRect,(PPDMIDISPLAYPORT pInterface, uint32_t cx, uint32_t cy,
584 const uint8_t *pbSrc, int32_t xSrc, int32_t ySrc, uint32_t cxSrc, uint32_t cySrc, uint32_t cbSrcLine, uint32_t cSrcBitsPerPixel,
585 uint8_t *pbDst, int32_t xDst, int32_t yDst, uint32_t cxDst, uint32_t cyDst, uint32_t cbDstLine, uint32_t cDstBitsPerPixel));
586
587} PDMIDISPLAYPORT;
588/** PDMIDISPLAYPORT interface ID. */
589#define PDMIDISPLAYPORT_IID "22d3d93d-3407-487a-8308-85367eae00bb"
590
591
592typedef struct VBOXVHWACMD *PVBOXVHWACMD; /**< @todo r=bird: A line what it is to make doxygen happy. */
593typedef struct VBVACMDHDR *PVBVACMDHDR;
594typedef struct VBVAINFOSCREEN *PVBVAINFOSCREEN;
595typedef struct VBVAINFOVIEW *PVBVAINFOVIEW;
596typedef struct VBVAHOSTFLAGS *PVBVAHOSTFLAGS;
597typedef struct VBOXVDMACMD_CHROMIUM_CMD *PVBOXVDMACMD_CHROMIUM_CMD; /* <- chromium [hgsmi] command */
598typedef struct VBOXVDMACMD_CHROMIUM_CTL *PVBOXVDMACMD_CHROMIUM_CTL; /* <- chromium [hgsmi] command */
599
600/** Pointer to a display connector interface. */
601typedef struct PDMIDISPLAYCONNECTOR *PPDMIDISPLAYCONNECTOR;
602/**
603 * Display connector interface (up).
604 * Pair with PDMIDISPLAYPORT.
605 */
606typedef struct PDMIDISPLAYCONNECTOR
607{
608 /**
609 * Resize the display.
610 * This is called when the resolution changes. This usually happens on
611 * request from the guest os, but may also happen as the result of a reset.
612 * If the callback returns VINF_VGA_RESIZE_IN_PROGRESS, the caller (VGA device)
613 * must not access the connector and return.
614 *
615 * @returns VINF_SUCCESS if the framebuffer resize was completed,
616 * VINF_VGA_RESIZE_IN_PROGRESS if resize takes time and not yet finished.
617 * @param pInterface Pointer to this interface.
618 * @param cBits Color depth (bits per pixel) of the new video mode.
619 * @param pvVRAM Address of the guest VRAM.
620 * @param cbLine Size in bytes of a single scan line.
621 * @param cx New display width.
622 * @param cy New display height.
623 * @thread The emulation thread.
624 */
625 DECLR3CALLBACKMEMBER(int, pfnResize,(PPDMIDISPLAYCONNECTOR pInterface, uint32_t cBits, void *pvVRAM, uint32_t cbLine, uint32_t cx, uint32_t cy));
626
627 /**
628 * Update a rectangle of the display.
629 * PDMIDISPLAYPORT::pfnUpdateDisplay is the caller.
630 *
631 * @param pInterface Pointer to this interface.
632 * @param x The upper left corner x coordinate of the rectangle.
633 * @param y The upper left corner y coordinate of the rectangle.
634 * @param cx The width of the rectangle.
635 * @param cy The height of the rectangle.
636 * @thread The emulation thread.
637 */
638 DECLR3CALLBACKMEMBER(void, pfnUpdateRect,(PPDMIDISPLAYCONNECTOR pInterface, uint32_t x, uint32_t y, uint32_t cx, uint32_t cy));
639
640 /**
641 * Refresh the display.
642 *
643 * The interval between these calls is set by
644 * PDMIDISPLAYPORT::pfnSetRefreshRate(). The driver should call
645 * PDMIDISPLAYPORT::pfnUpdateDisplay() if it wishes to refresh the
646 * display. PDMIDISPLAYPORT::pfnUpdateDisplay calls pfnUpdateRect with
647 * the changed rectangles.
648 *
649 * @param pInterface Pointer to this interface.
650 * @thread The emulation thread.
651 */
652 DECLR3CALLBACKMEMBER(void, pfnRefresh,(PPDMIDISPLAYCONNECTOR pInterface));
653
654 /**
655 * Reset the display.
656 *
657 * Notification message when the graphics card has been reset.
658 *
659 * @param pInterface Pointer to this interface.
660 * @thread The emulation thread.
661 */
662 DECLR3CALLBACKMEMBER(void, pfnReset,(PPDMIDISPLAYCONNECTOR pInterface));
663
664 /**
665 * LFB video mode enter/exit.
666 *
667 * Notification message when LinearFrameBuffer video mode is enabled/disabled.
668 *
669 * @param pInterface Pointer to this interface.
670 * @param fEnabled false - LFB mode was disabled,
671 * true - an LFB mode was disabled
672 * @thread The emulation thread.
673 */
674 DECLR3CALLBACKMEMBER(void, pfnLFBModeChange, (PPDMIDISPLAYCONNECTOR pInterface, bool fEnabled));
675
676 /**
677 * Process the guest graphics adapter information.
678 *
679 * Direct notification from guest to the display connector.
680 *
681 * @param pInterface Pointer to this interface.
682 * @param pvVRAM Address of the guest VRAM.
683 * @param u32VRAMSize Size of the guest VRAM.
684 * @thread The emulation thread.
685 */
686 DECLR3CALLBACKMEMBER(void, pfnProcessAdapterData, (PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, uint32_t u32VRAMSize));
687
688 /**
689 * Process the guest display information.
690 *
691 * Direct notification from guest to the display connector.
692 *
693 * @param pInterface Pointer to this interface.
694 * @param pvVRAM Address of the guest VRAM.
695 * @param uScreenId The index of the guest display to be processed.
696 * @thread The emulation thread.
697 */
698 DECLR3CALLBACKMEMBER(void, pfnProcessDisplayData, (PPDMIDISPLAYCONNECTOR pInterface, void *pvVRAM, unsigned uScreenId));
699
700 /**
701 * Process the guest Video HW Acceleration command.
702 *
703 * @param pInterface Pointer to this interface.
704 * @param pCmd Video HW Acceleration Command to be processed.
705 * @thread The emulation thread.
706 */
707 DECLR3CALLBACKMEMBER(void, pfnVHWACommandProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVHWACMD pCmd));
708
709 /**
710 * Process the guest chromium command.
711 *
712 * @param pInterface Pointer to this interface.
713 * @param pCmd Video HW Acceleration Command to be processed.
714 * @thread The emulation thread.
715 */
716 DECLR3CALLBACKMEMBER(void, pfnCrHgsmiCommandProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd));
717
718 /**
719 * Process the guest chromium control command.
720 *
721 * @param pInterface Pointer to this interface.
722 * @param pCmd Video HW Acceleration Command to be processed.
723 * @thread The emulation thread.
724 */
725 DECLR3CALLBACKMEMBER(void, pfnCrHgsmiControlProcess, (PPDMIDISPLAYCONNECTOR pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCtl));
726
727
728 /**
729 * The specified screen enters VBVA mode.
730 *
731 * @param pInterface Pointer to this interface.
732 * @param uScreenId The screen updates are for.
733 * @thread The emulation thread.
734 */
735 DECLR3CALLBACKMEMBER(int, pfnVBVAEnable,(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, PVBVAHOSTFLAGS pHostFlags));
736
737 /**
738 * The specified screen leaves VBVA mode.
739 *
740 * @param pInterface Pointer to this interface.
741 * @param uScreenId The screen updates are for.
742 * @thread The emulation thread.
743 */
744 DECLR3CALLBACKMEMBER(void, pfnVBVADisable,(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId));
745
746 /**
747 * A sequence of pfnVBVAUpdateProcess calls begins.
748 *
749 * @param pInterface Pointer to this interface.
750 * @param uScreenId The screen updates are for.
751 * @thread The emulation thread.
752 */
753 DECLR3CALLBACKMEMBER(void, pfnVBVAUpdateBegin,(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId));
754
755 /**
756 * Process the guest VBVA command.
757 *
758 * @param pInterface Pointer to this interface.
759 * @param pCmd Video HW Acceleration Command to be processed.
760 * @thread The emulation thread.
761 */
762 DECLR3CALLBACKMEMBER(void, pfnVBVAUpdateProcess,(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, const PVBVACMDHDR pCmd, size_t cbCmd));
763
764 /**
765 * A sequence of pfnVBVAUpdateProcess calls ends.
766 *
767 * @param pInterface Pointer to this interface.
768 * @param uScreenId The screen updates are for.
769 * @param x The upper left corner x coordinate of the combined rectangle of all VBVA updates.
770 * @param y The upper left corner y coordinate of the rectangle.
771 * @param cx The width of the rectangle.
772 * @param cy The height of the rectangle.
773 * @thread The emulation thread.
774 */
775 DECLR3CALLBACKMEMBER(void, pfnVBVAUpdateEnd,(PPDMIDISPLAYCONNECTOR pInterface, unsigned uScreenId, int32_t x, int32_t y, uint32_t cx, uint32_t cy));
776
777 /**
778 * Resize the display.
779 * This is called when the resolution changes. This usually happens on
780 * request from the guest os, but may also happen as the result of a reset.
781 * If the callback returns VINF_VGA_RESIZE_IN_PROGRESS, the caller (VGA device)
782 * must not access the connector and return.
783 *
784 * @todo Merge with pfnResize.
785 *
786 * @returns VINF_SUCCESS if the framebuffer resize was completed,
787 * VINF_VGA_RESIZE_IN_PROGRESS if resize takes time and not yet finished.
788 * @param pInterface Pointer to this interface.
789 * @param pView The description of VRAM block for this screen.
790 * @param pScreen The data of screen being resized.
791 * @param pvVRAM Address of the guest VRAM.
792 * @thread The emulation thread.
793 */
794 DECLR3CALLBACKMEMBER(int, pfnVBVAResize,(PPDMIDISPLAYCONNECTOR pInterface, const PVBVAINFOVIEW pView, const PVBVAINFOSCREEN pScreen, void *pvVRAM));
795
796 /**
797 * Update the pointer shape.
798 * This is called when the mouse pointer shape changes. The new shape
799 * is passed as a caller allocated buffer that will be freed after returning
800 *
801 * @param pInterface Pointer to this interface.
802 * @param fVisible Visibility indicator (if false, the other parameters are undefined).
803 * @param fAlpha Flag whether alpha channel is being passed.
804 * @param xHot Pointer hot spot x coordinate.
805 * @param yHot Pointer hot spot y coordinate.
806 * @param x Pointer new x coordinate on screen.
807 * @param y Pointer new y coordinate on screen.
808 * @param cx Pointer width in pixels.
809 * @param cy Pointer height in pixels.
810 * @param cbScanline Size of one scanline in bytes.
811 * @param pvShape New shape buffer.
812 * @thread The emulation thread.
813 */
814 DECLR3CALLBACKMEMBER(int, pfnVBVAMousePointerShape,(PPDMIDISPLAYCONNECTOR pInterface, bool fVisible, bool fAlpha,
815 uint32_t xHot, uint32_t yHot,
816 uint32_t cx, uint32_t cy,
817 const void *pvShape));
818
819 /** Read-only attributes.
820 * For preformance reasons some readonly attributes are kept in the interface.
821 * We trust the interface users to respect the readonlyness of these.
822 * @{
823 */
824 /** Pointer to the display data buffer. */
825 uint8_t *pu8Data;
826 /** Size of a scanline in the data buffer. */
827 uint32_t cbScanline;
828 /** The color depth (in bits) the graphics card is supposed to provide. */
829 uint32_t cBits;
830 /** The display width. */
831 uint32_t cx;
832 /** The display height. */
833 uint32_t cy;
834 /** @} */
835} PDMIDISPLAYCONNECTOR;
836/** PDMIDISPLAYCONNECTOR interface ID. */
837#define PDMIDISPLAYCONNECTOR_IID "c7a1b36d-8dfc-421d-b71f-3a0eeaf733e6"
838
839
840/** Pointer to a block port interface. */
841typedef struct PDMIBLOCKPORT *PPDMIBLOCKPORT;
842/**
843 * Block notify interface (down).
844 * Pair with PDMIBLOCK.
845 */
846typedef struct PDMIBLOCKPORT
847{
848 /**
849 * Returns the storage controller name, instance and LUN of the attached medium.
850 *
851 * @returns VBox status.
852 * @param pInterface Pointer to this interface.
853 * @param ppcszController Where to store the name of the storage controller.
854 * @param piInstance Where to store the instance number of the controller.
855 * @param piLUN Where to store the LUN of the attached device.
856 */
857 DECLR3CALLBACKMEMBER(int, pfnQueryDeviceLocation, (PPDMIBLOCKPORT pInterface, const char **ppcszController,
858 uint32_t *piInstance, uint32_t *piLUN));
859
860} PDMIBLOCKPORT;
861/** PDMIBLOCKPORT interface ID. */
862#define PDMIBLOCKPORT_IID "bbbed4cf-0862-4ffd-b60c-f7a65ef8e8ff"
863
864
865/**
866 * Callback which provides progress information.
867 *
868 * @return VBox status code.
869 * @param pvUser Opaque user data.
870 * @param uPercent Completion percentage.
871 */
872typedef DECLCALLBACK(int) FNSIMPLEPROGRESS(void *pvUser, unsigned uPercentage);
873/** Pointer to FNSIMPLEPROGRESS() */
874typedef FNSIMPLEPROGRESS *PFNSIMPLEPROGRESS;
875
876
877/**
878 * Block drive type.
879 */
880typedef enum PDMBLOCKTYPE
881{
882 /** Error (for the query function). */
883 PDMBLOCKTYPE_ERROR = 1,
884 /** 360KB 5 1/4" floppy drive. */
885 PDMBLOCKTYPE_FLOPPY_360,
886 /** 720KB 3 1/2" floppy drive. */
887 PDMBLOCKTYPE_FLOPPY_720,
888 /** 1.2MB 5 1/4" floppy drive. */
889 PDMBLOCKTYPE_FLOPPY_1_20,
890 /** 1.44MB 3 1/2" floppy drive. */
891 PDMBLOCKTYPE_FLOPPY_1_44,
892 /** 2.88MB 3 1/2" floppy drive. */
893 PDMBLOCKTYPE_FLOPPY_2_88,
894 /** CDROM drive. */
895 PDMBLOCKTYPE_CDROM,
896 /** DVD drive. */
897 PDMBLOCKTYPE_DVD,
898 /** Hard disk drive. */
899 PDMBLOCKTYPE_HARD_DISK
900} PDMBLOCKTYPE;
901
902
903/**
904 * Block raw command data transfer direction.
905 */
906typedef enum PDMBLOCKTXDIR
907{
908 PDMBLOCKTXDIR_NONE = 0,
909 PDMBLOCKTXDIR_FROM_DEVICE,
910 PDMBLOCKTXDIR_TO_DEVICE
911} PDMBLOCKTXDIR;
912
913
914/** Pointer to a block interface. */
915typedef struct PDMIBLOCK *PPDMIBLOCK;
916/**
917 * Block interface (up).
918 * Pair with PDMIBLOCKPORT.
919 */
920typedef struct PDMIBLOCK
921{
922 /**
923 * Read bits.
924 *
925 * @returns VBox status code.
926 * @param pInterface Pointer to the interface structure containing the called function pointer.
927 * @param off Offset to start reading from. The offset must be aligned to a sector boundary.
928 * @param pvBuf Where to store the read bits.
929 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
930 * @thread Any thread.
931 */
932 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIBLOCK pInterface, uint64_t off, void *pvBuf, size_t cbRead));
933
934 /**
935 * Write bits.
936 *
937 * @returns VBox status code.
938 * @param pInterface Pointer to the interface structure containing the called function pointer.
939 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
940 * @param pvBuf Where to store the write bits.
941 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
942 * @thread Any thread.
943 */
944 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIBLOCK pInterface, uint64_t off, const void *pvBuf, size_t cbWrite));
945
946 /**
947 * Make sure that the bits written are actually on the storage medium.
948 *
949 * @returns VBox status code.
950 * @param pInterface Pointer to the interface structure containing the called function pointer.
951 * @thread Any thread.
952 */
953 DECLR3CALLBACKMEMBER(int, pfnFlush,(PPDMIBLOCK pInterface));
954
955 /**
956 * Send a raw command to the underlying device (CDROM).
957 * This method is optional (i.e. the function pointer may be NULL).
958 *
959 * @returns VBox status code.
960 * @param pInterface Pointer to the interface structure containing the called function pointer.
961 * @param pbCmd Offset to start reading from.
962 * @param enmTxDir Direction of transfer.
963 * @param pvBuf Pointer tp the transfer buffer.
964 * @param cbBuf Size of the transfer buffer.
965 * @param pbSenseKey Status of the command (when return value is VERR_DEV_IO_ERROR).
966 * @param cTimeoutMillies Command timeout in milliseconds.
967 * @thread Any thread.
968 */
969 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));
970
971 /**
972 * Merge medium contents during a live snapshot deletion.
973 *
974 * @returns VBox status code.
975 * @param pInterface Pointer to the interface structure containing the called function pointer.
976 * @param pfnProgress Function pointer for progress notification.
977 * @param pvUser Opaque user data for progress notification.
978 * @thread Any thread.
979 */
980 DECLR3CALLBACKMEMBER(int, pfnMerge,(PPDMIBLOCK pInterface, PFNSIMPLEPROGRESS pfnProgress, void *pvUser));
981
982 /**
983 * Check if the media is readonly or not.
984 *
985 * @returns true if readonly.
986 * @returns false if read/write.
987 * @param pInterface Pointer to the interface structure containing the called function pointer.
988 * @thread Any thread.
989 */
990 DECLR3CALLBACKMEMBER(bool, pfnIsReadOnly,(PPDMIBLOCK pInterface));
991
992 /**
993 * Gets the media size in bytes.
994 *
995 * @returns Media size in bytes.
996 * @param pInterface Pointer to the interface structure containing the called function pointer.
997 * @thread Any thread.
998 */
999 DECLR3CALLBACKMEMBER(uint64_t, pfnGetSize,(PPDMIBLOCK pInterface));
1000
1001 /**
1002 * Gets the block drive type.
1003 *
1004 * @returns block drive type.
1005 * @param pInterface Pointer to the interface structure containing the called function pointer.
1006 * @thread Any thread.
1007 */
1008 DECLR3CALLBACKMEMBER(PDMBLOCKTYPE, pfnGetType,(PPDMIBLOCK pInterface));
1009
1010 /**
1011 * Gets the UUID of the block drive.
1012 * Don't return the media UUID if it's removable.
1013 *
1014 * @returns VBox status code.
1015 * @param pInterface Pointer to the interface structure containing the called function pointer.
1016 * @param pUuid Where to store the UUID on success.
1017 * @thread Any thread.
1018 */
1019 DECLR3CALLBACKMEMBER(int, pfnGetUuid,(PPDMIBLOCK pInterface, PRTUUID pUuid));
1020} PDMIBLOCK;
1021/** PDMIBLOCK interface ID. */
1022#define PDMIBLOCK_IID "0a5f3156-8b21-4cf5-83fd-e097281d2900"
1023
1024
1025/** Pointer to a mount interface. */
1026typedef struct PDMIMOUNTNOTIFY *PPDMIMOUNTNOTIFY;
1027/**
1028 * Block interface (up).
1029 * Pair with PDMIMOUNT.
1030 */
1031typedef struct PDMIMOUNTNOTIFY
1032{
1033 /**
1034 * Called when a media is mounted.
1035 *
1036 * @param pInterface Pointer to the interface structure containing the called function pointer.
1037 * @thread The emulation thread.
1038 */
1039 DECLR3CALLBACKMEMBER(void, pfnMountNotify,(PPDMIMOUNTNOTIFY pInterface));
1040
1041 /**
1042 * Called when a media is unmounted
1043 * @param pInterface Pointer to the interface structure containing the called function pointer.
1044 * @thread The emulation thread.
1045 */
1046 DECLR3CALLBACKMEMBER(void, pfnUnmountNotify,(PPDMIMOUNTNOTIFY pInterface));
1047} PDMIMOUNTNOTIFY;
1048/** PDMIMOUNTNOTIFY interface ID. */
1049#define PDMIMOUNTNOTIFY_IID "fa143ac9-9fc6-498e-997f-945380a558f9"
1050
1051
1052/** Pointer to mount interface. */
1053typedef struct PDMIMOUNT *PPDMIMOUNT;
1054/**
1055 * Mount interface (down).
1056 * Pair with PDMIMOUNTNOTIFY.
1057 */
1058typedef struct PDMIMOUNT
1059{
1060 /**
1061 * Mount a media.
1062 *
1063 * This will not unmount any currently mounted media!
1064 *
1065 * @returns VBox status code.
1066 * @param pInterface Pointer to the interface structure containing the called function pointer.
1067 * @param pszFilename Pointer to filename. If this is NULL it assumed that the caller have
1068 * constructed a configuration which can be attached to the bottom driver.
1069 * @param pszCoreDriver Core driver name. NULL will cause autodetection. Ignored if pszFilanem is NULL.
1070 * @thread The emulation thread.
1071 */
1072 DECLR3CALLBACKMEMBER(int, pfnMount,(PPDMIMOUNT pInterface, const char *pszFilename, const char *pszCoreDriver));
1073
1074 /**
1075 * Unmount the media.
1076 *
1077 * The driver will validate and pass it on. On the rebounce it will decide whether or not to detach it self.
1078 *
1079 * @returns VBox status code.
1080 * @param pInterface Pointer to the interface structure containing the called function pointer.
1081 * @thread The emulation thread.
1082 * @param fForce Force the unmount, even for locked media.
1083 * @thread The emulation thread.
1084 */
1085 DECLR3CALLBACKMEMBER(int, pfnUnmount,(PPDMIMOUNT pInterface, bool fForce));
1086
1087 /**
1088 * Checks if a media is mounted.
1089 *
1090 * @returns true if mounted.
1091 * @returns false if not mounted.
1092 * @param pInterface Pointer to the interface structure containing the called function pointer.
1093 * @thread Any thread.
1094 */
1095 DECLR3CALLBACKMEMBER(bool, pfnIsMounted,(PPDMIMOUNT pInterface));
1096
1097 /**
1098 * Locks the media, preventing any unmounting of it.
1099 *
1100 * @returns VBox status code.
1101 * @param pInterface Pointer to the interface structure containing the called function pointer.
1102 * @thread The emulation thread.
1103 */
1104 DECLR3CALLBACKMEMBER(int, pfnLock,(PPDMIMOUNT pInterface));
1105
1106 /**
1107 * Unlocks the media, canceling previous calls to pfnLock().
1108 *
1109 * @returns VBox status code.
1110 * @param pInterface Pointer to the interface structure containing the called function pointer.
1111 * @thread The emulation thread.
1112 */
1113 DECLR3CALLBACKMEMBER(int, pfnUnlock,(PPDMIMOUNT pInterface));
1114
1115 /**
1116 * Checks if a media is locked.
1117 *
1118 * @returns true if locked.
1119 * @returns false if not locked.
1120 * @param pInterface Pointer to the interface structure containing the called function pointer.
1121 * @thread Any thread.
1122 */
1123 DECLR3CALLBACKMEMBER(bool, pfnIsLocked,(PPDMIMOUNT pInterface));
1124} PDMIMOUNT;
1125/** PDMIMOUNT interface ID. */
1126#define PDMIMOUNT_IID "8e5a009a-6032-4ca1-9d86-a388d8eaf926"
1127
1128
1129/**
1130 * Media geometry structure.
1131 */
1132typedef struct PDMMEDIAGEOMETRY
1133{
1134 /** Number of cylinders. */
1135 uint32_t cCylinders;
1136 /** Number of heads. */
1137 uint32_t cHeads;
1138 /** Number of sectors. */
1139 uint32_t cSectors;
1140} PDMMEDIAGEOMETRY;
1141
1142/** Pointer to media geometry structure. */
1143typedef PDMMEDIAGEOMETRY *PPDMMEDIAGEOMETRY;
1144/** Pointer to constant media geometry structure. */
1145typedef const PDMMEDIAGEOMETRY *PCPDMMEDIAGEOMETRY;
1146
1147/** Pointer to a media port interface. */
1148typedef struct PDMIMEDIAPORT *PPDMIMEDIAPORT;
1149/**
1150 * Media port interface (down).
1151 */
1152typedef struct PDMIMEDIAPORT
1153{
1154 /**
1155 * Returns the storage controller name, instance and LUN of the attached medium.
1156 *
1157 * @returns VBox status.
1158 * @param pInterface Pointer to this interface.
1159 * @param ppcszController Where to store the name of the storage controller.
1160 * @param piInstance Where to store the instance number of the controller.
1161 * @param piLUN Where to store the LUN of the attached device.
1162 */
1163 DECLR3CALLBACKMEMBER(int, pfnQueryDeviceLocation, (PPDMIMEDIAPORT pInterface, const char **ppcszController,
1164 uint32_t *piInstance, uint32_t *piLUN));
1165
1166} PDMIMEDIAPORT;
1167/** PDMIMEDIAPORT interface ID. */
1168#define PDMIMEDIAPORT_IID "9f7e8c9e-6d35-4453-bbef-1f78033174d6"
1169
1170/** Pointer to a media interface. */
1171typedef struct PDMIMEDIA *PPDMIMEDIA;
1172/**
1173 * Media interface (up).
1174 * Makes up the foundation for PDMIBLOCK and PDMIBLOCKBIOS. No interface pair.
1175 */
1176typedef struct PDMIMEDIA
1177{
1178 /**
1179 * Read bits.
1180 *
1181 * @returns VBox status code.
1182 * @param pInterface Pointer to the interface structure containing the called function pointer.
1183 * @param off Offset to start reading from. The offset must be aligned to a sector boundary.
1184 * @param pvBuf Where to store the read bits.
1185 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
1186 * @thread Any thread.
1187 */
1188 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIMEDIA pInterface, uint64_t off, void *pvBuf, size_t cbRead));
1189
1190 /**
1191 * Write bits.
1192 *
1193 * @returns VBox status code.
1194 * @param pInterface Pointer to the interface structure containing the called function pointer.
1195 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
1196 * @param pvBuf Where to store the write bits.
1197 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
1198 * @thread Any thread.
1199 */
1200 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIMEDIA pInterface, uint64_t off, const void *pvBuf, size_t cbWrite));
1201
1202 /**
1203 * Make sure that the bits written are actually on the storage medium.
1204 *
1205 * @returns VBox status code.
1206 * @param pInterface Pointer to the interface structure containing the called function pointer.
1207 * @thread Any thread.
1208 */
1209 DECLR3CALLBACKMEMBER(int, pfnFlush,(PPDMIMEDIA pInterface));
1210
1211 /**
1212 * Merge medium contents during a live snapshot deletion. All details
1213 * must have been configured through CFGM or this will fail.
1214 * This method is optional (i.e. the function pointer may be NULL).
1215 *
1216 * @returns VBox status code.
1217 * @param pInterface Pointer to the interface structure containing the called function pointer.
1218 * @param pfnProgress Function pointer for progress notification.
1219 * @param pvUser Opaque user data for progress notification.
1220 * @thread Any thread.
1221 */
1222 DECLR3CALLBACKMEMBER(int, pfnMerge,(PPDMIMEDIA pInterface, PFNSIMPLEPROGRESS pfnProgress, void *pvUser));
1223
1224 /**
1225 * Get the media size in bytes.
1226 *
1227 * @returns Media size in bytes.
1228 * @param pInterface Pointer to the interface structure containing the called function pointer.
1229 * @thread Any thread.
1230 */
1231 DECLR3CALLBACKMEMBER(uint64_t, pfnGetSize,(PPDMIMEDIA pInterface));
1232
1233 /**
1234 * Check if the media is readonly or not.
1235 *
1236 * @returns true if readonly.
1237 * @returns false if read/write.
1238 * @param pInterface Pointer to the interface structure containing the called function pointer.
1239 * @thread Any thread.
1240 */
1241 DECLR3CALLBACKMEMBER(bool, pfnIsReadOnly,(PPDMIMEDIA pInterface));
1242
1243 /**
1244 * Get stored media geometry (physical CHS, PCHS) - BIOS property.
1245 * This is an optional feature of a media.
1246 *
1247 * @returns VBox status code.
1248 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1249 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnBiosSetPCHSGeometry() yet.
1250 * @param pInterface Pointer to the interface structure containing the called function pointer.
1251 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
1252 * @remark This has no influence on the read/write operations.
1253 * @thread Any thread.
1254 */
1255 DECLR3CALLBACKMEMBER(int, pfnBiosGetPCHSGeometry,(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry));
1256
1257 /**
1258 * Store the media geometry (physical CHS, PCHS) - BIOS property.
1259 * This is an optional feature of a media.
1260 *
1261 * @returns VBox status code.
1262 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1263 * @param pInterface Pointer to the interface structure containing the called function pointer.
1264 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
1265 * @remark This has no influence on the read/write operations.
1266 * @thread The emulation thread.
1267 */
1268 DECLR3CALLBACKMEMBER(int, pfnBiosSetPCHSGeometry,(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry));
1269
1270 /**
1271 * Get stored media geometry (logical CHS, LCHS) - BIOS property.
1272 * This is an optional feature of a media.
1273 *
1274 * @returns VBox status code.
1275 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1276 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnBiosSetLCHSGeometry() yet.
1277 * @param pInterface Pointer to the interface structure containing the called function pointer.
1278 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
1279 * @remark This has no influence on the read/write operations.
1280 * @thread Any thread.
1281 */
1282 DECLR3CALLBACKMEMBER(int, pfnBiosGetLCHSGeometry,(PPDMIMEDIA pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry));
1283
1284 /**
1285 * Store the media geometry (logical CHS, LCHS) - BIOS property.
1286 * This is an optional feature of a media.
1287 *
1288 * @returns VBox status code.
1289 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1290 * @param pInterface Pointer to the interface structure containing the called function pointer.
1291 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
1292 * @remark This has no influence on the read/write operations.
1293 * @thread The emulation thread.
1294 */
1295 DECLR3CALLBACKMEMBER(int, pfnBiosSetLCHSGeometry,(PPDMIMEDIA pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry));
1296
1297 /**
1298 * Gets the UUID of the media drive.
1299 *
1300 * @returns VBox status code.
1301 * @param pInterface Pointer to the interface structure containing the called function pointer.
1302 * @param pUuid Where to store the UUID on success.
1303 * @thread Any thread.
1304 */
1305 DECLR3CALLBACKMEMBER(int, pfnGetUuid,(PPDMIMEDIA pInterface, PRTUUID pUuid));
1306
1307} PDMIMEDIA;
1308/** PDMIMEDIA interface ID. */
1309#define PDMIMEDIA_IID "f5bb07c9-2843-46f8-a56f-cc090b6e5bac"
1310
1311
1312/** Pointer to a block BIOS interface. */
1313typedef struct PDMIBLOCKBIOS *PPDMIBLOCKBIOS;
1314/**
1315 * Media BIOS interface (Up / External).
1316 * The interface the getting and setting properties which the BIOS/CMOS care about.
1317 */
1318typedef struct PDMIBLOCKBIOS
1319{
1320 /**
1321 * Get stored media geometry (physical CHS, PCHS) - BIOS property.
1322 * This is an optional feature of a media.
1323 *
1324 * @returns VBox status code.
1325 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1326 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnSetPCHSGeometry() yet.
1327 * @param pInterface Pointer to the interface structure containing the called function pointer.
1328 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
1329 * @remark This has no influence on the read/write operations.
1330 * @thread Any thread.
1331 */
1332 DECLR3CALLBACKMEMBER(int, pfnGetPCHSGeometry,(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pPCHSGeometry));
1333
1334 /**
1335 * Store the media geometry (physical CHS, PCHS) - BIOS property.
1336 * This is an optional feature of a media.
1337 *
1338 * @returns VBox status code.
1339 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1340 * @param pInterface Pointer to the interface structure containing the called function pointer.
1341 * @param pPCHSGeometry Pointer to PCHS geometry (cylinders/heads/sectors).
1342 * @remark This has no influence on the read/write operations.
1343 * @thread The emulation thread.
1344 */
1345 DECLR3CALLBACKMEMBER(int, pfnSetPCHSGeometry,(PPDMIBLOCKBIOS pInterface, PCPDMMEDIAGEOMETRY pPCHSGeometry));
1346
1347 /**
1348 * Get stored media geometry (logical CHS, LCHS) - BIOS property.
1349 * This is an optional feature of a media.
1350 *
1351 * @returns VBox status code.
1352 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1353 * @returns VERR_PDM_GEOMETRY_NOT_SET if the geometry hasn't been set using pfnSetLCHSGeometry() yet.
1354 * @param pInterface Pointer to the interface structure containing the called function pointer.
1355 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
1356 * @remark This has no influence on the read/write operations.
1357 * @thread Any thread.
1358 */
1359 DECLR3CALLBACKMEMBER(int, pfnGetLCHSGeometry,(PPDMIBLOCKBIOS pInterface, PPDMMEDIAGEOMETRY pLCHSGeometry));
1360
1361 /**
1362 * Store the media geometry (logical CHS, LCHS) - BIOS property.
1363 * This is an optional feature of a media.
1364 *
1365 * @returns VBox status code.
1366 * @returns VERR_NOT_IMPLEMENTED if the media doesn't support storing the geometry.
1367 * @param pInterface Pointer to the interface structure containing the called function pointer.
1368 * @param pLCHSGeometry Pointer to LCHS geometry (cylinders/heads/sectors).
1369 * @remark This has no influence on the read/write operations.
1370 * @thread The emulation thread.
1371 */
1372 DECLR3CALLBACKMEMBER(int, pfnSetLCHSGeometry,(PPDMIBLOCKBIOS pInterface, PCPDMMEDIAGEOMETRY pLCHSGeometry));
1373
1374 /**
1375 * Checks if the device should be visible to the BIOS or not.
1376 *
1377 * @returns true if the device is visible to the BIOS.
1378 * @returns false if the device is not visible to the BIOS.
1379 * @param pInterface Pointer to the interface structure containing the called function pointer.
1380 * @thread Any thread.
1381 */
1382 DECLR3CALLBACKMEMBER(bool, pfnIsVisible,(PPDMIBLOCKBIOS pInterface));
1383
1384 /**
1385 * Gets the block drive type.
1386 *
1387 * @returns block drive type.
1388 * @param pInterface Pointer to the interface structure containing the called function pointer.
1389 * @thread Any thread.
1390 */
1391 DECLR3CALLBACKMEMBER(PDMBLOCKTYPE, pfnGetType,(PPDMIBLOCKBIOS pInterface));
1392
1393} PDMIBLOCKBIOS;
1394/** PDMIBLOCKBIOS interface ID. */
1395#define PDMIBLOCKBIOS_IID "477c3eee-a48d-48a9-82fd-2a54de16b2e9"
1396
1397
1398/** Pointer to a static block core driver interface. */
1399typedef struct PDMIMEDIASTATIC *PPDMIMEDIASTATIC;
1400/**
1401 * Static block core driver interface.
1402 */
1403typedef struct PDMIMEDIASTATIC
1404{
1405 /**
1406 * Check if the specified file is a format which the core driver can handle.
1407 *
1408 * @returns true / false accordingly.
1409 * @param pInterface Pointer to the interface structure containing the called function pointer.
1410 * @param pszFilename Name of the file to probe.
1411 */
1412 DECLR3CALLBACKMEMBER(bool, pfnCanHandle,(PPDMIMEDIASTATIC pInterface, const char *pszFilename));
1413} PDMIMEDIASTATIC;
1414
1415
1416
1417
1418
1419/** Pointer to a asynchronous block notify interface. */
1420typedef struct PDMIBLOCKASYNCPORT *PPDMIBLOCKASYNCPORT;
1421/**
1422 * Asynchronous block notify interface (up).
1423 * Pair with PDMIBLOCKASYNC.
1424 */
1425typedef struct PDMIBLOCKASYNCPORT
1426{
1427 /**
1428 * Notify completion of a asynchronous transfer.
1429 *
1430 * @returns VBox status code.
1431 * @param pInterface Pointer to the interface structure containing the called function pointer.
1432 * @param pvUser The user argument given in pfnStartWrite/Read.
1433 * @param rcReq IPRT Status code of the completed request.
1434 * @thread Any thread.
1435 */
1436 DECLR3CALLBACKMEMBER(int, pfnTransferCompleteNotify, (PPDMIBLOCKASYNCPORT pInterface, void *pvUser, int rcReq));
1437} PDMIBLOCKASYNCPORT;
1438/** PDMIBLOCKASYNCPORT interface ID. */
1439#define PDMIBLOCKASYNCPORT_IID "e3bdc0cb-9d99-41dd-8eec-0dc8cf5b2a92"
1440
1441
1442
1443/** Pointer to a asynchronous block interface. */
1444typedef struct PDMIBLOCKASYNC *PPDMIBLOCKASYNC;
1445/**
1446 * Asynchronous block interface (down).
1447 * Pair with PDMIBLOCKASYNCPORT.
1448 */
1449typedef struct PDMIBLOCKASYNC
1450{
1451 /**
1452 * Start reading task.
1453 *
1454 * @returns VBox status code.
1455 * @param pInterface Pointer to the interface structure containing the called function pointer.
1456 * @param off Offset to start reading from.c
1457 * @param paSegs Pointer to the S/G segment array.
1458 * @param cSegs Number of entries in the array.
1459 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
1460 * @param pvUser User argument which is returned in completion callback.
1461 * @thread Any thread.
1462 */
1463 DECLR3CALLBACKMEMBER(int, pfnStartRead,(PPDMIBLOCKASYNC pInterface, uint64_t off, PCRTSGSEG paSegs, unsigned cSegs, size_t cbRead, void *pvUser));
1464
1465 /**
1466 * Write bits.
1467 *
1468 * @returns VBox status code.
1469 * @param pInterface Pointer to the interface structure containing the called function pointer.
1470 * @param off Offset to start writing at. The offset must be aligned to a sector boundary.
1471 * @param paSegs Pointer to the S/G segment array.
1472 * @param cSegs Number of entries in the array.
1473 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
1474 * @param pvUser User argument which is returned in completion callback.
1475 * @thread Any thread.
1476 */
1477 DECLR3CALLBACKMEMBER(int, pfnStartWrite,(PPDMIBLOCKASYNC pInterface, uint64_t off, PCRTSGSEG paSegs, unsigned cSegs, size_t cbWrite, void *pvUser));
1478
1479 /**
1480 * Flush everything to disk.
1481 *
1482 * @returns VBox status code.
1483 * @param pInterface Pointer to the interface structure containing the called function pointer.
1484 * @param pvUser User argument which is returned in completion callback.
1485 * @thread Any thread.
1486 */
1487 DECLR3CALLBACKMEMBER(int, pfnStartFlush,(PPDMIBLOCKASYNC pInterface, void *pvUser));
1488
1489} PDMIBLOCKASYNC;
1490/** PDMIBLOCKASYNC interface ID. */
1491#define PDMIBLOCKASYNC_IID "78302d0d-4978-498c-be3c-8989cb5ff5c8"
1492
1493
1494/** Pointer to a asynchronous notification interface. */
1495typedef struct PDMIMEDIAASYNCPORT *PPDMIMEDIAASYNCPORT;
1496/**
1497 * Asynchronous version of the media interface (up).
1498 * Pair with PDMIMEDIAASYNC.
1499 */
1500typedef struct PDMIMEDIAASYNCPORT
1501{
1502 /**
1503 * Notify completion of a task.
1504 *
1505 * @returns VBox status code.
1506 * @param pInterface Pointer to the interface structure containing the called function pointer.
1507 * @param pvUser The user argument given in pfnStartWrite.
1508 * @param rcReq IPRT Status code of the completed request.
1509 * @thread Any thread.
1510 */
1511 DECLR3CALLBACKMEMBER(int, pfnTransferCompleteNotify, (PPDMIMEDIAASYNCPORT pInterface, void *pvUser, int rcReq));
1512} PDMIMEDIAASYNCPORT;
1513/** PDMIMEDIAASYNCPORT interface ID. */
1514#define PDMIMEDIAASYNCPORT_IID "22d38853-901f-4a71-9670-4d9da6e82317"
1515
1516
1517/** Pointer to a asynchronous media interface. */
1518typedef struct PDMIMEDIAASYNC *PPDMIMEDIAASYNC;
1519/**
1520 * Asynchronous version of PDMIMEDIA (down).
1521 * Pair with PDMIMEDIAASYNCPORT.
1522 */
1523typedef struct PDMIMEDIAASYNC
1524{
1525 /**
1526 * Start reading task.
1527 *
1528 * @returns VBox status code.
1529 * @param pInterface Pointer to the interface structure containing the called function pointer.
1530 * @param off Offset to start reading from. Must be aligned to a sector boundary.
1531 * @param paSegs Pointer to the S/G segment array.
1532 * @param cSegs Number of entries in the array.
1533 * @param cbRead Number of bytes to read. Must be aligned to a sector boundary.
1534 * @param pvUser User data.
1535 * @thread Any thread.
1536 */
1537 DECLR3CALLBACKMEMBER(int, pfnStartRead,(PPDMIMEDIAASYNC pInterface, uint64_t off, PCRTSGSEG paSegs, unsigned cSegs, size_t cbRead, void *pvUser));
1538
1539 /**
1540 * Start writing task.
1541 *
1542 * @returns VBox status code.
1543 * @param pInterface Pointer to the interface structure containing the called function pointer.
1544 * @param off Offset to start writing at. Must be aligned to a sector boundary.
1545 * @param paSegs Pointer to the S/G segment array.
1546 * @param cSegs Number of entries in the array.
1547 * @param cbWrite Number of bytes to write. Must be aligned to a sector boundary.
1548 * @param pvUser User data.
1549 * @thread Any thread.
1550 */
1551 DECLR3CALLBACKMEMBER(int, pfnStartWrite,(PPDMIMEDIAASYNC pInterface, uint64_t off, PCRTSGSEG paSegs, unsigned cSegs, size_t cbWrite, void *pvUser));
1552
1553 /**
1554 * Flush everything to disk.
1555 *
1556 * @returns VBox status code.
1557 * @param pInterface Pointer to the interface structure containing the called function pointer.
1558 * @param pvUser User argument which is returned in completion callback.
1559 * @thread Any thread.
1560 */
1561 DECLR3CALLBACKMEMBER(int, pfnStartFlush,(PPDMIMEDIAASYNC pInterface, void *pvUser));
1562
1563} PDMIMEDIAASYNC;
1564/** PDMIMEDIAASYNC interface ID. */
1565#define PDMIMEDIAASYNC_IID "3553227d-714d-4d28-b993-59f4e671588e"
1566
1567
1568/** Pointer to a char port interface. */
1569typedef struct PDMICHARPORT *PPDMICHARPORT;
1570/**
1571 * Char port interface (down).
1572 * Pair with PDMICHARCONNECTOR.
1573 */
1574typedef struct PDMICHARPORT
1575{
1576 /**
1577 * Deliver data read to the device/driver.
1578 *
1579 * @returns VBox status code.
1580 * @param pInterface Pointer to the interface structure containing the called function pointer.
1581 * @param pvBuf Where the read bits are stored.
1582 * @param pcbRead Number of bytes available for reading/having been read.
1583 * @thread Any thread.
1584 */
1585 DECLR3CALLBACKMEMBER(int, pfnNotifyRead,(PPDMICHARPORT pInterface, const void *pvBuf, size_t *pcbRead));
1586
1587 /**
1588 * Notify the device/driver when the status lines changed.
1589 *
1590 * @returns VBox status code.
1591 * @param pInterface Pointer to the interface structure containing the called function pointer.
1592 * @param fNewStatusLine New state of the status line pins.
1593 * @thread Any thread.
1594 */
1595 DECLR3CALLBACKMEMBER(int, pfnNotifyStatusLinesChanged,(PPDMICHARPORT pInterface, uint32_t fNewStatusLines));
1596
1597 /**
1598 * Notify the device when the driver buffer is full.
1599 *
1600 * @returns VBox status code.
1601 * @param pInterface Pointer to the interface structure containing the called function pointer.
1602 * @param fFull Buffer full.
1603 * @thread Any thread.
1604 */
1605 DECLR3CALLBACKMEMBER(int, pfnNotifyBufferFull,(PPDMICHARPORT pInterface, bool fFull));
1606
1607 /**
1608 * Notify the device/driver that a break occurred.
1609 *
1610 * @returns VBox statsus code.
1611 * @param pInterface Pointer to the interface structure containing the called function pointer.
1612 * @thread Any thread.
1613 */
1614 DECLR3CALLBACKMEMBER(int, pfnNotifyBreak,(PPDMICHARPORT pInterface));
1615} PDMICHARPORT;
1616/** PDMICHARPORT interface ID. */
1617#define PDMICHARPORT_IID "22769834-ea8b-4a6d-ade1-213dcdbd1228"
1618
1619/** @name Bit mask definitions for status line type.
1620 * @{ */
1621#define PDMICHARPORT_STATUS_LINES_DCD RT_BIT(0)
1622#define PDMICHARPORT_STATUS_LINES_RI RT_BIT(1)
1623#define PDMICHARPORT_STATUS_LINES_DSR RT_BIT(2)
1624#define PDMICHARPORT_STATUS_LINES_CTS RT_BIT(3)
1625/** @} */
1626
1627
1628/** Pointer to a char interface. */
1629typedef struct PDMICHARCONNECTOR *PPDMICHARCONNECTOR;
1630/**
1631 * Char connector interface (up).
1632 * Pair with PDMICHARPORT.
1633 */
1634typedef struct PDMICHARCONNECTOR
1635{
1636 /**
1637 * Write bits.
1638 *
1639 * @returns VBox status code.
1640 * @param pInterface Pointer to the interface structure containing the called function pointer.
1641 * @param pvBuf Where to store the write bits.
1642 * @param cbWrite Number of bytes to write.
1643 * @thread Any thread.
1644 */
1645 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMICHARCONNECTOR pInterface, const void *pvBuf, size_t cbWrite));
1646
1647 /**
1648 * Set device parameters.
1649 *
1650 * @returns VBox status code.
1651 * @param pInterface Pointer to the interface structure containing the called function pointer.
1652 * @param Bps Speed of the serial connection. (bits per second)
1653 * @param chParity Parity method: 'E' - even, 'O' - odd, 'N' - none.
1654 * @param cDataBits Number of data bits.
1655 * @param cStopBits Number of stop bits.
1656 * @thread Any thread.
1657 */
1658 DECLR3CALLBACKMEMBER(int, pfnSetParameters,(PPDMICHARCONNECTOR pInterface, unsigned Bps, char chParity, unsigned cDataBits, unsigned cStopBits));
1659
1660 /**
1661 * Set the state of the modem lines.
1662 *
1663 * @returns VBox status code.
1664 * @param pInterface Pointer to the interface structure containing the called function pointer.
1665 * @param fRequestToSend Set to true to make the Request to Send line active otherwise to 0.
1666 * @param fDataTerminalReady Set to true to make the Data Terminal Ready line active otherwise 0.
1667 * @thread Any thread.
1668 */
1669 DECLR3CALLBACKMEMBER(int, pfnSetModemLines,(PPDMICHARCONNECTOR pInterface, bool fRequestToSend, bool fDataTerminalReady));
1670
1671 /**
1672 * Sets the TD line into break condition.
1673 *
1674 * @returns VBox status code.
1675 * @param pInterface Pointer to the interface structure containing the called function pointer.
1676 * @param fBreak Set to true to let the device send a break false to put into normal operation.
1677 * @thread Any thread.
1678 */
1679 DECLR3CALLBACKMEMBER(int, pfnSetBreak,(PPDMICHARCONNECTOR pInterface, bool fBreak));
1680} PDMICHARCONNECTOR;
1681/** PDMICHARCONNECTOR interface ID. */
1682#define PDMICHARCONNECTOR_IID "4ad5c190-b408-4cef-926f-fbffce0dc5cc"
1683
1684
1685/** Pointer to a stream interface. */
1686typedef struct PDMISTREAM *PPDMISTREAM;
1687/**
1688 * Stream interface (up).
1689 * Makes up the foundation for PDMICHARCONNECTOR. No pair interface.
1690 */
1691typedef struct PDMISTREAM
1692{
1693 /**
1694 * Read bits.
1695 *
1696 * @returns VBox status code.
1697 * @param pInterface Pointer to the interface structure containing the called function pointer.
1698 * @param pvBuf Where to store the read bits.
1699 * @param cbRead Number of bytes to read/bytes actually read.
1700 * @thread Any thread.
1701 */
1702 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMISTREAM pInterface, void *pvBuf, size_t *cbRead));
1703
1704 /**
1705 * Write bits.
1706 *
1707 * @returns VBox status code.
1708 * @param pInterface Pointer to the interface structure containing the called function pointer.
1709 * @param pvBuf Where to store the write bits.
1710 * @param cbWrite Number of bytes to write/bytes actually written.
1711 * @thread Any thread.
1712 */
1713 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMISTREAM pInterface, const void *pvBuf, size_t *cbWrite));
1714} PDMISTREAM;
1715/** PDMISTREAM interface ID. */
1716#define PDMISTREAM_IID "d1a5bf5e-3d2c-449a-bde9-addd7920b71f"
1717
1718
1719/** Mode of the parallel port */
1720typedef enum PDMPARALLELPORTMODE
1721{
1722 PDM_PARALLEL_PORT_MODE_COMPAT,
1723 PDM_PARALLEL_PORT_MODE_EPP,
1724 PDM_PARALLEL_PORT_MODE_ECP
1725} PDMPARALLELPORTMODE;
1726
1727/** Pointer to a host parallel port interface. */
1728typedef struct PDMIHOSTPARALLELPORT *PPDMIHOSTPARALLELPORT;
1729/**
1730 * Host parallel port interface (down).
1731 * Pair with PDMIHOSTPARALLELCONNECTOR.
1732 */
1733typedef struct PDMIHOSTPARALLELPORT
1734{
1735 /**
1736 * Deliver data read to the device/driver.
1737 *
1738 * @returns VBox status code.
1739 * @param pInterface Pointer to the interface structure containing the called function pointer.
1740 * @param pvBuf Where the read bits are stored.
1741 * @param pcbRead Number of bytes available for reading/having been read.
1742 * @thread Any thread.
1743 */
1744 DECLR3CALLBACKMEMBER(int, pfnNotifyRead,(PPDMIHOSTPARALLELPORT pInterface, const void *pvBuf, size_t *pcbRead));
1745
1746 /**
1747 * Notify device/driver that an interrupt has occurred.
1748 *
1749 * @returns VBox status code.
1750 * @param pInterface Pointer to the interface structure containing the called function pointer.
1751 * @thread Any thread.
1752 */
1753 DECLR3CALLBACKMEMBER(int, pfnNotifyInterrupt,(PPDMIHOSTPARALLELPORT pInterface));
1754} PDMIHOSTPARALLELPORT;
1755/** PDMIHOSTPARALLELPORT interface ID. */
1756#define PDMIHOSTPARALLELPORT_IID "ac13e437-cd30-47ac-a271-6120571f3a22"
1757
1758
1759
1760/** Pointer to a Host Parallel connector interface. */
1761typedef struct PDMIHOSTPARALLELCONNECTOR *PPDMIHOSTPARALLELCONNECTOR;
1762/**
1763 * Host parallel connector interface (up).
1764 * Pair with PDMIHOSTPARALLELPORT.
1765 */
1766typedef struct PDMIHOSTPARALLELCONNECTOR
1767{
1768 /**
1769 * Write bits.
1770 *
1771 * @returns VBox status code.
1772 * @param pInterface Pointer to the interface structure containing the called function pointer.
1773 * @param pvBuf Where to store the write bits.
1774 * @param pcbWrite Number of bytes to write/bytes actually written.
1775 * @thread Any thread.
1776 */
1777 DECLR3CALLBACKMEMBER(int, pfnWrite,(PPDMIHOSTPARALLELCONNECTOR pInterface, const void *pvBuf, size_t *pcbWrite));
1778
1779 /**
1780 * Read bits.
1781 *
1782 * @returns VBox status code.
1783 * @param pInterface Pointer to the interface structure containing the called function pointer.
1784 * @param pvBuf Where to store the read bits.
1785 * @param pcbRead Number of bytes to read/bytes actually read.
1786 * @thread Any thread.
1787 */
1788 DECLR3CALLBACKMEMBER(int, pfnRead,(PPDMIHOSTPARALLELCONNECTOR pInterface, void *pvBuf, size_t *pcbRead));
1789
1790 /**
1791 * Write control register bits.
1792 *
1793 * @returns VBox status code.
1794 * @param pInterface Pointer to the interface structure containing the called function pointer.
1795 * @param fReg The new control register value.
1796 * @thread Any thread.
1797 */
1798 DECLR3CALLBACKMEMBER(int, pfnWriteControl,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t fReg));
1799
1800 /**
1801 * Read control register bits.
1802 *
1803 * @returns VBox status code.
1804 * @param pInterface Pointer to the interface structure containing the called function pointer.
1805 * @param pfReg Where to store the control register bits.
1806 * @thread Any thread.
1807 */
1808 DECLR3CALLBACKMEMBER(int, pfnReadControl,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg));
1809
1810 /**
1811 * Read status register bits.
1812 *
1813 * @returns VBox status code.
1814 * @param pInterface Pointer to the interface structure containing the called function pointer.
1815 * @param pfReg Where to store the status register bits.
1816 * @thread Any thread.
1817 */
1818 DECLR3CALLBACKMEMBER(int, pfnReadStatus,(PPDMIHOSTPARALLELCONNECTOR pInterface, uint8_t *pfReg));
1819
1820 /**
1821 * Set mode of the host parallel port.
1822 *
1823 * @returns VBox status code.
1824 * @param pInterface Pointer to the interface structure containing the called function pointer.
1825 * @param enmMode The mode of the host parallel port.
1826 * @thread Any thread.
1827 */
1828 DECLR3CALLBACKMEMBER(int, pfnSetMode,(PPDMIHOSTPARALLELCONNECTOR pInterface, PDMPARALLELPORTMODE enmMode));
1829} PDMIHOSTPARALLELCONNECTOR;
1830/** PDMIHOSTPARALLELCONNECTOR interface ID. */
1831#define PDMIHOSTPARALLELCONNECTOR_IID "a03567ca-b29e-4a1b-b2f3-a12435fa2982"
1832
1833
1834/** ACPI power source identifier */
1835typedef enum PDMACPIPOWERSOURCE
1836{
1837 PDM_ACPI_POWER_SOURCE_UNKNOWN = 0,
1838 PDM_ACPI_POWER_SOURCE_OUTLET,
1839 PDM_ACPI_POWER_SOURCE_BATTERY
1840} PDMACPIPOWERSOURCE;
1841/** Pointer to ACPI battery state. */
1842typedef PDMACPIPOWERSOURCE *PPDMACPIPOWERSOURCE;
1843
1844/** ACPI battey capacity */
1845typedef enum PDMACPIBATCAPACITY
1846{
1847 PDM_ACPI_BAT_CAPACITY_MIN = 0,
1848 PDM_ACPI_BAT_CAPACITY_MAX = 100,
1849 PDM_ACPI_BAT_CAPACITY_UNKNOWN = 255
1850} PDMACPIBATCAPACITY;
1851/** Pointer to ACPI battery capacity. */
1852typedef PDMACPIBATCAPACITY *PPDMACPIBATCAPACITY;
1853
1854/** ACPI battery state. See ACPI 3.0 spec '_BST (Battery Status)' */
1855typedef enum PDMACPIBATSTATE
1856{
1857 PDM_ACPI_BAT_STATE_CHARGED = 0x00,
1858 PDM_ACPI_BAT_STATE_DISCHARGING = 0x01,
1859 PDM_ACPI_BAT_STATE_CHARGING = 0x02,
1860 PDM_ACPI_BAT_STATE_CRITICAL = 0x04
1861} PDMACPIBATSTATE;
1862/** Pointer to ACPI battery state. */
1863typedef PDMACPIBATSTATE *PPDMACPIBATSTATE;
1864
1865/** Pointer to an ACPI port interface. */
1866typedef struct PDMIACPIPORT *PPDMIACPIPORT;
1867/**
1868 * ACPI port interface (down). Used by both the ACPI driver and (grumble) main.
1869 * Pair with PDMIACPICONNECTOR.
1870 */
1871typedef struct PDMIACPIPORT
1872{
1873 /**
1874 * Send an ACPI power off event.
1875 *
1876 * @returns VBox status code
1877 * @param pInterface Pointer to the interface structure containing the called function pointer.
1878 */
1879 DECLR3CALLBACKMEMBER(int, pfnPowerButtonPress,(PPDMIACPIPORT pInterface));
1880
1881 /**
1882 * Send an ACPI sleep button event.
1883 *
1884 * @returns VBox status code
1885 * @param pInterface Pointer to the interface structure containing the called function pointer.
1886 */
1887 DECLR3CALLBACKMEMBER(int, pfnSleepButtonPress,(PPDMIACPIPORT pInterface));
1888
1889 /**
1890 * Check if the last power button event was handled by the guest.
1891 *
1892 * @returns VBox status code
1893 * @param pInterface Pointer to the interface structure containing the called function pointer.
1894 * @param pfHandled Is set to true if the last power button event was handled, false otherwise.
1895 */
1896 DECLR3CALLBACKMEMBER(int, pfnGetPowerButtonHandled,(PPDMIACPIPORT pInterface, bool *pfHandled));
1897
1898 /**
1899 * Check if the guest entered the ACPI mode.
1900 *
1901 * @returns VBox status code
1902 * @param pInterface Pointer to the interface structure containing the called function pointer.
1903 * @param pfEnabled Is set to true if the guest entered the ACPI mode, false otherwise.
1904 */
1905 DECLR3CALLBACKMEMBER(int, pfnGetGuestEnteredACPIMode,(PPDMIACPIPORT pInterface, bool *pfEntered));
1906
1907 /**
1908 * Check if the given CPU is still locked by the guest.
1909 *
1910 * @returns VBox status code
1911 * @param pInterface Pointer to the interface structure containing the called function pointer.
1912 * @param uCpu The CPU to check for.
1913 * @param pfLocked Is set to true if the CPU is still locked by the guest, false otherwise.
1914 */
1915 DECLR3CALLBACKMEMBER(int, pfnGetCpuStatus,(PPDMIACPIPORT pInterface, unsigned uCpu, bool *pfLocked));
1916} PDMIACPIPORT;
1917/** PDMIACPIPORT interface ID. */
1918#define PDMIACPIPORT_IID "30d3dc4c-6a73-40c8-80e9-34309deacbb3"
1919
1920
1921/** Pointer to an ACPI connector interface. */
1922typedef struct PDMIACPICONNECTOR *PPDMIACPICONNECTOR;
1923/**
1924 * ACPI connector interface (up).
1925 * Pair with PDMIACPIPORT.
1926 */
1927typedef struct PDMIACPICONNECTOR
1928{
1929 /**
1930 * Get the current power source of the host system.
1931 *
1932 * @returns VBox status code
1933 * @param pInterface Pointer to the interface structure containing the called function pointer.
1934 * @param penmPowerSource Pointer to the power source result variable.
1935 */
1936 DECLR3CALLBACKMEMBER(int, pfnQueryPowerSource,(PPDMIACPICONNECTOR, PPDMACPIPOWERSOURCE penmPowerSource));
1937
1938 /**
1939 * Query the current battery status of the host system.
1940 *
1941 * @returns VBox status code?
1942 * @param pInterface Pointer to the interface structure containing the called function pointer.
1943 * @param pfPresent Is set to true if battery is present, false otherwise.
1944 * @param penmRemainingCapacity Pointer to the battery remaining capacity (0 - 100 or 255 for unknown).
1945 * @param penmBatteryState Pointer to the battery status.
1946 * @param pu32PresentRate Pointer to the present rate (0..1000 of the total capacity).
1947 */
1948 DECLR3CALLBACKMEMBER(int, pfnQueryBatteryStatus,(PPDMIACPICONNECTOR, bool *pfPresent, PPDMACPIBATCAPACITY penmRemainingCapacity,
1949 PPDMACPIBATSTATE penmBatteryState, uint32_t *pu32PresentRate));
1950} PDMIACPICONNECTOR;
1951/** PDMIACPICONNECTOR interface ID. */
1952#define PDMIACPICONNECTOR_IID "5f14bf8d-1edf-4e3a-a1e1-cca9fd08e359"
1953
1954
1955/** Pointer to a VMMDevice port interface. */
1956typedef struct PDMIVMMDEVPORT *PPDMIVMMDEVPORT;
1957/**
1958 * VMMDevice port interface (down).
1959 * Pair with PDMIVMMDEVCONNECTOR.
1960 */
1961typedef struct PDMIVMMDEVPORT
1962{
1963 /**
1964 * Return the current absolute mouse position in pixels
1965 *
1966 * @returns VBox status code
1967 * @param pInterface Pointer to the interface structure containing the called function pointer.
1968 * @param pxAbs Pointer of result value, can be NULL
1969 * @param pyAbs Pointer of result value, can be NULL
1970 */
1971 DECLR3CALLBACKMEMBER(int, pfnQueryAbsoluteMouse,(PPDMIVMMDEVPORT pInterface, uint32_t *pxAbs, uint32_t *pyAbs));
1972
1973 /**
1974 * Set the new absolute mouse position in pixels
1975 *
1976 * @returns VBox status code
1977 * @param pInterface Pointer to the interface structure containing the called function pointer.
1978 * @param xabs New absolute X position
1979 * @param yAbs New absolute Y position
1980 */
1981 DECLR3CALLBACKMEMBER(int, pfnSetAbsoluteMouse,(PPDMIVMMDEVPORT pInterface, uint32_t xAbs, uint32_t yAbs));
1982
1983 /**
1984 * Return the current mouse capability flags
1985 *
1986 * @returns VBox status code
1987 * @param pInterface Pointer to the interface structure containing the called function pointer.
1988 * @param pfCapabilities Pointer of result value
1989 */
1990 DECLR3CALLBACKMEMBER(int, pfnQueryMouseCapabilities,(PPDMIVMMDEVPORT pInterface, uint32_t *pfCapabilities));
1991
1992 /**
1993 * Set the current mouse capability flag (host side)
1994 *
1995 * @returns VBox status code
1996 * @param pInterface Pointer to the interface structure containing the called function pointer.
1997 * @param fCapsAdded Mask of capabilities to add to the flag
1998 * @param fCapsRemoved Mask of capabilities to remove from the flag
1999 */
2000 DECLR3CALLBACKMEMBER(int, pfnUpdateMouseCapabilities,(PPDMIVMMDEVPORT pInterface, uint32_t fCapsAdded, uint32_t fCapsRemoved));
2001
2002 /**
2003 * Issue a display resolution change request.
2004 *
2005 * Note that there can only one request in the queue and that in case the guest does
2006 * not process it, issuing another request will overwrite the previous.
2007 *
2008 * @returns VBox status code
2009 * @param pInterface Pointer to the interface structure containing the called function pointer.
2010 * @param cx Horizontal pixel resolution (0 = do not change).
2011 * @param cy Vertical pixel resolution (0 = do not change).
2012 * @param cBits Bits per pixel (0 = do not change).
2013 * @param idxDisplay The display index.
2014 */
2015 DECLR3CALLBACKMEMBER(int, pfnRequestDisplayChange,(PPDMIVMMDEVPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBits, uint32_t idxDisplay));
2016
2017 /**
2018 * Pass credentials to guest.
2019 *
2020 * Note that there can only be one set of credentials and the guest may or may not
2021 * query them and may do whatever it wants with them.
2022 *
2023 * @returns VBox status code.
2024 * @param pInterface Pointer to the interface structure containing the called function pointer.
2025 * @param pszUsername User name, may be empty (UTF-8).
2026 * @param pszPassword Password, may be empty (UTF-8).
2027 * @param pszDomain Domain name, may be empty (UTF-8).
2028 * @param fFlags VMMDEV_SETCREDENTIALS_*.
2029 */
2030 DECLR3CALLBACKMEMBER(int, pfnSetCredentials,(PPDMIVMMDEVPORT pInterface, const char *pszUsername,
2031 const char *pszPassword, const char *pszDomain,
2032 uint32_t fFlags));
2033
2034 /**
2035 * Notify the driver about a VBVA status change.
2036 *
2037 * @returns Nothing. Because it is informational callback.
2038 * @param pInterface Pointer to the interface structure containing the called function pointer.
2039 * @param fEnabled Current VBVA status.
2040 */
2041 DECLR3CALLBACKMEMBER(void, pfnVBVAChange, (PPDMIVMMDEVPORT pInterface, bool fEnabled));
2042
2043 /**
2044 * Issue a seamless mode change request.
2045 *
2046 * Note that there can only one request in the queue and that in case the guest does
2047 * not process it, issuing another request will overwrite the previous.
2048 *
2049 * @returns VBox status code
2050 * @param pInterface Pointer to the interface structure containing the called function pointer.
2051 * @param fEnabled Seamless mode enabled or not
2052 */
2053 DECLR3CALLBACKMEMBER(int, pfnRequestSeamlessChange,(PPDMIVMMDEVPORT pInterface, bool fEnabled));
2054
2055 /**
2056 * Issue a memory balloon change request.
2057 *
2058 * Note that there can only one request in the queue and that in case the guest does
2059 * not process it, issuing another request will overwrite the previous.
2060 *
2061 * @returns VBox status code
2062 * @param pInterface Pointer to the interface structure containing the called function pointer.
2063 * @param cMbBalloon Balloon size in megabytes
2064 */
2065 DECLR3CALLBACKMEMBER(int, pfnSetMemoryBalloon,(PPDMIVMMDEVPORT pInterface, uint32_t cMbBalloon));
2066
2067 /**
2068 * Issue a statistcs interval change request.
2069 *
2070 * Note that there can only one request in the queue and that in case the guest does
2071 * not process it, issuing another request will overwrite the previous.
2072 *
2073 * @returns VBox status code
2074 * @param pInterface Pointer to the interface structure containing the called function pointer.
2075 * @param cSecsStatInterval Statistics query interval in seconds
2076 * (0=disable).
2077 */
2078 DECLR3CALLBACKMEMBER(int, pfnSetStatisticsInterval,(PPDMIVMMDEVPORT pInterface, uint32_t cSecsStatInterval));
2079
2080 /**
2081 * Notify the guest about a VRDP status change.
2082 *
2083 * @returns VBox status code
2084 * @param pInterface Pointer to the interface structure containing the called function pointer.
2085 * @param fVRDPEnabled Current VRDP status.
2086 * @param uVRDPExperienceLevel Which visual effects to be disabled in
2087 * the guest.
2088 */
2089 DECLR3CALLBACKMEMBER(int, pfnVRDPChange, (PPDMIVMMDEVPORT pInterface, bool fVRDPEnabled, uint32_t uVRDPExperienceLevel));
2090
2091 /**
2092 * Notify the guest of CPU hot-unplug event.
2093 *
2094 * @returns VBox status code
2095 * @param pInterface Pointer to the interface structure containing the called function pointer.
2096 * @param idCpuCore The core id of the CPU to remove.
2097 * @param idCpuPackage The package id of the CPU to remove.
2098 */
2099 DECLR3CALLBACKMEMBER(int, pfnCpuHotUnplug, (PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage));
2100
2101 /**
2102 * Notify the guest of CPU hot-plug event.
2103 *
2104 * @returns VBox status code
2105 * @param pInterface Pointer to the interface structure containing the called function pointer.
2106 * @param idCpuCore The core id of the CPU to add.
2107 * @param idCpuPackage The package id of the CPU to add.
2108 */
2109 DECLR3CALLBACKMEMBER(int, pfnCpuHotPlug, (PPDMIVMMDEVPORT pInterface, uint32_t idCpuCore, uint32_t idCpuPackage));
2110
2111} PDMIVMMDEVPORT;
2112/** PDMIVMMDEVPORT interface ID. */
2113#define PDMIVMMDEVPORT_IID "d7e52035-3b6c-422e-9215-2a75646a945d"
2114
2115
2116/** Pointer to a HPET legacy notification interface. */
2117typedef struct PDMIHPETLEGACYNOTIFY *PPDMIHPETLEGACYNOTIFY;
2118/**
2119 * HPET legacy notification interface.
2120 */
2121typedef struct PDMIHPETLEGACYNOTIFY
2122{
2123 /**
2124 * Notify about change of HPET legacy mode.
2125 *
2126 * @param pInterface Pointer to the interface structure containing the
2127 * called function pointer.
2128 * @param fActivated If HPET legacy mode is activated (@c true) or
2129 * deactivated (@c false).
2130 */
2131 DECLR3CALLBACKMEMBER(void, pfnModeChanged,(PPDMIHPETLEGACYNOTIFY pInterface, bool fActivated));
2132} PDMIHPETLEGACYNOTIFY;
2133/** PDMIHPETLEGACYNOTIFY interface ID. */
2134#define PDMIHPETLEGACYNOTIFY_IID "c9ada595-4b65-4311-8b21-b10498997774"
2135
2136
2137/** @name Flags for PDMIVMMDEVPORT::pfnSetCredentials.
2138 * @{ */
2139/** The guest should perform a logon with the credentials. */
2140#define VMMDEV_SETCREDENTIALS_GUESTLOGON RT_BIT(0)
2141/** The guest should prevent local logons. */
2142#define VMMDEV_SETCREDENTIALS_NOLOCALLOGON RT_BIT(1)
2143/** The guest should verify the credentials. */
2144#define VMMDEV_SETCREDENTIALS_JUDGE RT_BIT(15)
2145/** @} */
2146
2147/** Forward declaration of the guest information structure. */
2148struct VBoxGuestInfo;
2149/** Forward declaration of the guest information-2 structure. */
2150struct VBoxGuestInfo2;
2151/** Forward declaration of the guest statistics structure */
2152struct VBoxGuestStatistics;
2153/** Forward declaration of the guest status structure */
2154struct VBoxGuestStatus;
2155
2156/** Forward declaration of the video accelerator command memory. */
2157struct VBVAMEMORY;
2158/** Pointer to video accelerator command memory. */
2159typedef struct VBVAMEMORY *PVBVAMEMORY;
2160
2161/** Pointer to a VMMDev connector interface. */
2162typedef struct PDMIVMMDEVCONNECTOR *PPDMIVMMDEVCONNECTOR;
2163/**
2164 * VMMDev connector interface (up).
2165 * Pair with PDMIVMMDEVPORT.
2166 */
2167typedef struct PDMIVMMDEVCONNECTOR
2168{
2169 /**
2170 * Reports the guest status.
2171 * Called whenever the Additions issue a guest status report request.
2172 *
2173 * @param pInterface Pointer to this interface.
2174 * @param pGuestStatus Pointer to guest information structure
2175 * @thread The emulation thread.
2176 */
2177 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestStatus,(PPDMIVMMDEVCONNECTOR pInterface, const struct VBoxGuestStatus *pGuestStatus));
2178
2179 /**
2180 * Reports the guest API and OS version.
2181 * Called whenever the Additions issue a guest info report request.
2182 *
2183 * @param pInterface Pointer to this interface.
2184 * @param pGuestInfo Pointer to guest information structure
2185 * @thread The emulation thread.
2186 */
2187 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestInfo,(PPDMIVMMDEVCONNECTOR pInterface, const struct VBoxGuestInfo *pGuestInfo));
2188
2189 /**
2190 * Reports the detailed Guest Additions version.
2191 * Called whenever the Additions issue a guest version report request or the VM is reset.
2192 *
2193 * @param pInterface Pointer to this interface.
2194 * @param guestInfo Pointer to Guest Additions information structure.
2195 * @thread The emulation thread.
2196 */
2197 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestInfo2,(PPDMIVMMDEVCONNECTOR pInterface, const struct VBoxGuestInfo2 *pGuestInfo));
2198
2199 /**
2200 * Update the guest additions capabilities.
2201 * This is called when the guest additions capabilities change. The new capabilities
2202 * are given and the connector should update its internal state.
2203 *
2204 * @param pInterface Pointer to this interface.
2205 * @param newCapabilities New capabilities.
2206 * @thread The emulation thread.
2207 */
2208 DECLR3CALLBACKMEMBER(void, pfnUpdateGuestCapabilities,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t newCapabilities));
2209
2210 /**
2211 * Update the mouse capabilities.
2212 * This is called when the mouse capabilities change. The new capabilities
2213 * are given and the connector should update its internal state.
2214 *
2215 * @param pInterface Pointer to this interface.
2216 * @param newCapabilities New capabilities.
2217 * @thread The emulation thread.
2218 */
2219 DECLR3CALLBACKMEMBER(void, pfnUpdateMouseCapabilities,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t newCapabilities));
2220
2221 /**
2222 * Update the pointer shape.
2223 * This is called when the mouse pointer shape changes. The new shape
2224 * is passed as a caller allocated buffer that will be freed after returning
2225 *
2226 * @param pInterface Pointer to this interface.
2227 * @param fVisible Visibility indicator (if false, the other parameters are undefined).
2228 * @param fAlpha Flag whether alpha channel is being passed.
2229 * @param xHot Pointer hot spot x coordinate.
2230 * @param yHot Pointer hot spot y coordinate.
2231 * @param x Pointer new x coordinate on screen.
2232 * @param y Pointer new y coordinate on screen.
2233 * @param cx Pointer width in pixels.
2234 * @param cy Pointer height in pixels.
2235 * @param cbScanline Size of one scanline in bytes.
2236 * @param pvShape New shape buffer.
2237 * @thread The emulation thread.
2238 */
2239 DECLR3CALLBACKMEMBER(void, pfnUpdatePointerShape,(PPDMIVMMDEVCONNECTOR pInterface, bool fVisible, bool fAlpha,
2240 uint32_t xHot, uint32_t yHot,
2241 uint32_t cx, uint32_t cy,
2242 void *pvShape));
2243
2244 /**
2245 * Enable or disable video acceleration on behalf of guest.
2246 *
2247 * @param pInterface Pointer to this interface.
2248 * @param fEnable Whether to enable acceleration.
2249 * @param pVbvaMemory Video accelerator memory.
2250
2251 * @return VBox rc. VINF_SUCCESS if VBVA was enabled.
2252 * @thread The emulation thread.
2253 */
2254 DECLR3CALLBACKMEMBER(int, pfnVideoAccelEnable,(PPDMIVMMDEVCONNECTOR pInterface, bool fEnable, PVBVAMEMORY pVbvaMemory));
2255
2256 /**
2257 * Force video queue processing.
2258 *
2259 * @param pInterface Pointer to this interface.
2260 * @thread The emulation thread.
2261 */
2262 DECLR3CALLBACKMEMBER(void, pfnVideoAccelFlush,(PPDMIVMMDEVCONNECTOR pInterface));
2263
2264 /**
2265 * Return whether the given video mode is supported/wanted by the host.
2266 *
2267 * @returns VBox status code
2268 * @param pInterface Pointer to this interface.
2269 * @param display The guest monitor, 0 for primary.
2270 * @param cy Video mode horizontal resolution in pixels.
2271 * @param cx Video mode vertical resolution in pixels.
2272 * @param cBits Video mode bits per pixel.
2273 * @param pfSupported Where to put the indicator for whether this mode is supported. (output)
2274 * @thread The emulation thread.
2275 */
2276 DECLR3CALLBACKMEMBER(int, pfnVideoModeSupported,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t display, uint32_t cx, uint32_t cy, uint32_t cBits, bool *pfSupported));
2277
2278 /**
2279 * Queries by how many pixels the height should be reduced when calculating video modes
2280 *
2281 * @returns VBox status code
2282 * @param pInterface Pointer to this interface.
2283 * @param pcyReduction Pointer to the result value.
2284 * @thread The emulation thread.
2285 */
2286 DECLR3CALLBACKMEMBER(int, pfnGetHeightReduction,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcyReduction));
2287
2288 /**
2289 * Informs about a credentials judgement result from the guest.
2290 *
2291 * @returns VBox status code
2292 * @param pInterface Pointer to this interface.
2293 * @param fFlags Judgement result flags.
2294 * @thread The emulation thread.
2295 */
2296 DECLR3CALLBACKMEMBER(int, pfnSetCredentialsJudgementResult,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t fFlags));
2297
2298 /**
2299 * Set the visible region of the display
2300 *
2301 * @returns VBox status code.
2302 * @param pInterface Pointer to this interface.
2303 * @param cRect Number of rectangles in pRect
2304 * @param pRect Rectangle array
2305 * @thread The emulation thread.
2306 */
2307 DECLR3CALLBACKMEMBER(int, pfnSetVisibleRegion,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t cRect, PRTRECT pRect));
2308
2309 /**
2310 * Query the visible region of the display
2311 *
2312 * @returns VBox status code.
2313 * @param pInterface Pointer to this interface.
2314 * @param pcRect Number of rectangles in pRect
2315 * @param pRect Rectangle array (set to NULL to query the number of rectangles)
2316 * @thread The emulation thread.
2317 */
2318 DECLR3CALLBACKMEMBER(int, pfnQueryVisibleRegion,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcRect, PRTRECT pRect));
2319
2320 /**
2321 * Request the statistics interval
2322 *
2323 * @returns VBox status code.
2324 * @param pInterface Pointer to this interface.
2325 * @param pulInterval Pointer to interval in seconds
2326 * @thread The emulation thread.
2327 */
2328 DECLR3CALLBACKMEMBER(int, pfnQueryStatisticsInterval,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pulInterval));
2329
2330 /**
2331 * Report new guest statistics
2332 *
2333 * @returns VBox status code.
2334 * @param pInterface Pointer to this interface.
2335 * @param pGuestStats Guest statistics
2336 * @thread The emulation thread.
2337 */
2338 DECLR3CALLBACKMEMBER(int, pfnReportStatistics,(PPDMIVMMDEVCONNECTOR pInterface, struct VBoxGuestStatistics *pGuestStats));
2339
2340 /**
2341 * Query the current balloon size
2342 *
2343 * @returns VBox status code.
2344 * @param pInterface Pointer to this interface.
2345 * @param pcbBalloon Balloon size
2346 * @thread The emulation thread.
2347 */
2348 DECLR3CALLBACKMEMBER(int, pfnQueryBalloonSize,(PPDMIVMMDEVCONNECTOR pInterface, uint32_t *pcbBalloon));
2349
2350 /**
2351 * Query the current page fusion setting
2352 *
2353 * @returns VBox status code.
2354 * @param pInterface Pointer to this interface.
2355 * @param pfPageFusionEnabled Pointer to boolean
2356 * @thread The emulation thread.
2357 */
2358 DECLR3CALLBACKMEMBER(int, pfnIsPageFusionEnabled,(PPDMIVMMDEVCONNECTOR pInterface, bool *pfPageFusionEnabled));
2359
2360} PDMIVMMDEVCONNECTOR;
2361/** PDMIVMMDEVCONNECTOR interface ID. */
2362#define PDMIVMMDEVCONNECTOR_IID "aff90240-a443-434e-9132-80c186ab97d4"
2363
2364
2365/** Pointer to a network connector interface */
2366typedef struct PDMIAUDIOCONNECTOR *PPDMIAUDIOCONNECTOR;
2367/**
2368 * Audio connector interface (up).
2369 * No interface pair yet.
2370 */
2371typedef struct PDMIAUDIOCONNECTOR
2372{
2373 DECLR3CALLBACKMEMBER(void, pfnRun,(PPDMIAUDIOCONNECTOR pInterface));
2374
2375/* DECLR3CALLBACKMEMBER(int, pfnSetRecordSource,(PPDMIAUDIOINCONNECTOR pInterface, AUDIORECSOURCE)); */
2376
2377} PDMIAUDIOCONNECTOR;
2378/** PDMIAUDIOCONNECTOR interface ID. */
2379#define PDMIAUDIOCONNECTOR_IID "85d52af5-b3aa-4b3e-b176-4b5ebfc52f47"
2380
2381
2382/** @todo r=bird: the two following interfaces are hacks to work around the missing audio driver
2383 * interface. This should be addressed rather than making more temporary hacks. */
2384
2385/** Pointer to a Audio Sniffer Device port interface. */
2386typedef struct PDMIAUDIOSNIFFERPORT *PPDMIAUDIOSNIFFERPORT;
2387/**
2388 * Audio Sniffer port interface (down).
2389 * Pair with PDMIAUDIOSNIFFERCONNECTOR.
2390 */
2391typedef struct PDMIAUDIOSNIFFERPORT
2392{
2393 /**
2394 * Enables or disables sniffing.
2395 *
2396 * If sniffing is being enabled also sets a flag whether the audio must be also
2397 * left on the host.
2398 *
2399 * @returns VBox status code
2400 * @param pInterface Pointer to this interface.
2401 * @param fEnable 'true' for enable sniffing, 'false' to disable.
2402 * @param fKeepHostAudio Indicates whether host audio should also present
2403 * 'true' means that sound should not be played
2404 * by the audio device.
2405 */
2406 DECLR3CALLBACKMEMBER(int, pfnSetup,(PPDMIAUDIOSNIFFERPORT pInterface, bool fEnable, bool fKeepHostAudio));
2407
2408 /**
2409 * Enables or disables audio input.
2410 *
2411 * @returns VBox status code
2412 * @param pInterface Pointer to this interface.
2413 * @param fIntercept 'true' for interception of audio input,
2414 * 'false' to let the host audio backend do audio input.
2415 */
2416 DECLR3CALLBACKMEMBER(int, pfnAudioInputIntercept,(PPDMIAUDIOSNIFFERPORT pInterface, bool fIntercept));
2417
2418 /**
2419 * Audio input is about to start.
2420 *
2421 * @returns VBox status code.
2422 * @param pvContext The callback context, supplied in the
2423 * PDMIAUDIOSNIFFERCONNECTOR::pfnAudioInputBegin as pvContext.
2424 * @param iSampleHz The sample frequency in Hz.
2425 * @param cChannels Number of channels. 1 for mono, 2 for stereo.
2426 * @param cBits How many bits a sample for a single channel has. Normally 8 or 16.
2427 * @param fUnsigned Whether samples are unsigned values.
2428 */
2429 DECLR3CALLBACKMEMBER(int, pfnAudioInputEventBegin,(PPDMIAUDIOSNIFFERPORT pInterface,
2430 void *pvContext,
2431 int iSampleHz,
2432 int cChannels,
2433 int cBits,
2434 bool fUnsigned));
2435
2436 /**
2437 * Callback which delivers audio data to the audio device.
2438 *
2439 * @returns VBox status code.
2440 * @param pvContext The callback context, supplied in the
2441 * PDMIAUDIOSNIFFERCONNECTOR::pfnAudioInputBegin as pvContext.
2442 * @param pvData Event specific data.
2443 * @param cbData Size of the buffer pointed by pvData.
2444 */
2445 DECLR3CALLBACKMEMBER(int, pfnAudioInputEventData,(PPDMIAUDIOSNIFFERPORT pInterface,
2446 void *pvContext,
2447 const void *pvData,
2448 uint32_t cbData));
2449
2450 /**
2451 * Audio input ends.
2452 *
2453 * @param pvContext The callback context, supplied in the
2454 * PDMIAUDIOSNIFFERCONNECTOR::pfnAudioInputBegin as pvContext.
2455 */
2456 DECLR3CALLBACKMEMBER(void, pfnAudioInputEventEnd,(PPDMIAUDIOSNIFFERPORT pInterface,
2457 void *pvContext));
2458} PDMIAUDIOSNIFFERPORT;
2459/** PDMIAUDIOSNIFFERPORT interface ID. */
2460#define PDMIAUDIOSNIFFERPORT_IID "8ad25d78-46e9-479b-a363-bb0bc0fe022f"
2461
2462
2463/** Pointer to a Audio Sniffer connector interface. */
2464typedef struct PDMIAUDIOSNIFFERCONNECTOR *PPDMIAUDIOSNIFFERCONNECTOR;
2465
2466/**
2467 * Audio Sniffer connector interface (up).
2468 * Pair with PDMIAUDIOSNIFFERPORT.
2469 */
2470typedef struct PDMIAUDIOSNIFFERCONNECTOR
2471{
2472 /**
2473 * AudioSniffer device calls this method when audio samples
2474 * are about to be played and sniffing is enabled.
2475 *
2476 * @param pInterface Pointer to this interface.
2477 * @param pvSamples Audio samples buffer.
2478 * @param cSamples How many complete samples are in the buffer.
2479 * @param iSampleHz The sample frequency in Hz.
2480 * @param cChannels Number of channels. 1 for mono, 2 for stereo.
2481 * @param cBits How many bits a sample for a single channel has. Normally 8 or 16.
2482 * @param fUnsigned Whether samples are unsigned values.
2483 * @thread The emulation thread.
2484 */
2485 DECLR3CALLBACKMEMBER(void, pfnAudioSamplesOut,(PPDMIAUDIOSNIFFERCONNECTOR pInterface, void *pvSamples, uint32_t cSamples,
2486 int iSampleHz, int cChannels, int cBits, bool fUnsigned));
2487
2488 /**
2489 * AudioSniffer device calls this method when output volume is changed.
2490 *
2491 * @param pInterface Pointer to this interface.
2492 * @param u16LeftVolume 0..0xFFFF volume level for left channel.
2493 * @param u16RightVolume 0..0xFFFF volume level for right channel.
2494 * @thread The emulation thread.
2495 */
2496 DECLR3CALLBACKMEMBER(void, pfnAudioVolumeOut,(PPDMIAUDIOSNIFFERCONNECTOR pInterface, uint16_t u16LeftVolume, uint16_t u16RightVolume));
2497
2498 /**
2499 * Audio input has been requested by the virtual audio device.
2500 *
2501 * @param pInterface Pointer to this interface.
2502 * @param ppvUserCtx The interface context for this audio input stream,
2503 * it will be used in the pfnAudioInputEnd call.
2504 * @param pvContext The context pointer to be used in PDMIAUDIOSNIFFERPORT::pfnAudioInputEvent.
2505 * @param cSamples How many samples in a block is preferred in
2506 * PDMIAUDIOSNIFFERPORT::pfnAudioInputEvent.
2507 * @param iSampleHz The sample frequency in Hz.
2508 * @param cChannels Number of channels. 1 for mono, 2 for stereo.
2509 * @param cBits How many bits a sample for a single channel has. Normally 8 or 16.
2510 * @thread The emulation thread.
2511 */
2512 DECLR3CALLBACKMEMBER(int, pfnAudioInputBegin,(PPDMIAUDIOSNIFFERCONNECTOR pInterface,
2513 void **ppvUserCtx,
2514 void *pvContext,
2515 uint32_t cSamples,
2516 uint32_t iSampleHz,
2517 uint32_t cChannels,
2518 uint32_t cBits));
2519
2520 /**
2521 * Audio input has been requested by the virtual audio device.
2522 *
2523 * @param pInterface Pointer to this interface.
2524 * @param pvUserCtx The interface context for this audio input stream,
2525 * which was returned by pfnAudioInputBegin call.
2526 * @thread The emulation thread.
2527 */
2528 DECLR3CALLBACKMEMBER(void, pfnAudioInputEnd,(PPDMIAUDIOSNIFFERCONNECTOR pInterface,
2529 void *pvUserCtx));
2530} PDMIAUDIOSNIFFERCONNECTOR;
2531/** PDMIAUDIOSNIFFERCONNECTOR - The Audio Sniffer Driver connector interface. */
2532#define PDMIAUDIOSNIFFERCONNECTOR_IID "9d37f543-27af-45f8-8002-8ef7abac71e4"
2533
2534
2535/**
2536 * Generic status LED core.
2537 * Note that a unit doesn't have to support all the indicators.
2538 */
2539typedef union PDMLEDCORE
2540{
2541 /** 32-bit view. */
2542 uint32_t volatile u32;
2543 /** Bit view. */
2544 struct
2545 {
2546 /** Reading/Receiving indicator. */
2547 uint32_t fReading : 1;
2548 /** Writing/Sending indicator. */
2549 uint32_t fWriting : 1;
2550 /** Busy indicator. */
2551 uint32_t fBusy : 1;
2552 /** Error indicator. */
2553 uint32_t fError : 1;
2554 } s;
2555} PDMLEDCORE;
2556
2557/** LED bit masks for the u32 view.
2558 * @{ */
2559/** Reading/Receiving indicator. */
2560#define PDMLED_READING RT_BIT(0)
2561/** Writing/Sending indicator. */
2562#define PDMLED_WRITING RT_BIT(1)
2563/** Busy indicator. */
2564#define PDMLED_BUSY RT_BIT(2)
2565/** Error indicator. */
2566#define PDMLED_ERROR RT_BIT(3)
2567/** @} */
2568
2569
2570/**
2571 * Generic status LED.
2572 * Note that a unit doesn't have to support all the indicators.
2573 */
2574typedef struct PDMLED
2575{
2576 /** Just a magic for sanity checking. */
2577 uint32_t u32Magic;
2578 uint32_t u32Alignment; /**< structure size alignment. */
2579 /** The actual LED status.
2580 * Only the device is allowed to change this. */
2581 PDMLEDCORE Actual;
2582 /** The asserted LED status which is cleared by the reader.
2583 * The device will assert the bits but never clear them.
2584 * The driver clears them as it sees fit. */
2585 PDMLEDCORE Asserted;
2586} PDMLED;
2587
2588/** Pointer to an LED. */
2589typedef PDMLED *PPDMLED;
2590/** Pointer to a const LED. */
2591typedef const PDMLED *PCPDMLED;
2592
2593/** Magic value for PDMLED::u32Magic. */
2594#define PDMLED_MAGIC UINT32_C(0x11335577)
2595
2596/** Pointer to an LED ports interface. */
2597typedef struct PDMILEDPORTS *PPDMILEDPORTS;
2598/**
2599 * Interface for exporting LEDs (down).
2600 * Pair with PDMILEDCONNECTORS.
2601 */
2602typedef struct PDMILEDPORTS
2603{
2604 /**
2605 * Gets the pointer to the status LED of a unit.
2606 *
2607 * @returns VBox status code.
2608 * @param pInterface Pointer to the interface structure containing the called function pointer.
2609 * @param iLUN The unit which status LED we desire.
2610 * @param ppLed Where to store the LED pointer.
2611 */
2612 DECLR3CALLBACKMEMBER(int, pfnQueryStatusLed,(PPDMILEDPORTS pInterface, unsigned iLUN, PPDMLED *ppLed));
2613
2614} PDMILEDPORTS;
2615/** PDMILEDPORTS interface ID. */
2616#define PDMILEDPORTS_IID "435e0cec-8549-4ca0-8c0d-98e52f1dc038"
2617
2618
2619/** Pointer to an LED connectors interface. */
2620typedef struct PDMILEDCONNECTORS *PPDMILEDCONNECTORS;
2621/**
2622 * Interface for reading LEDs (up).
2623 * Pair with PDMILEDPORTS.
2624 */
2625typedef struct PDMILEDCONNECTORS
2626{
2627 /**
2628 * Notification about a unit which have been changed.
2629 *
2630 * The driver must discard any pointers to data owned by
2631 * the unit and requery it.
2632 *
2633 * @param pInterface Pointer to the interface structure containing the called function pointer.
2634 * @param iLUN The unit number.
2635 */
2636 DECLR3CALLBACKMEMBER(void, pfnUnitChanged,(PPDMILEDCONNECTORS pInterface, unsigned iLUN));
2637} PDMILEDCONNECTORS;
2638/** PDMILEDCONNECTORS interface ID. */
2639#define PDMILEDCONNECTORS_IID "8ed63568-82a7-4193-b57b-db8085ac4495"
2640
2641
2642/** The special status unit number */
2643#define PDM_STATUS_LUN 999
2644
2645
2646#ifdef VBOX_WITH_HGCM
2647
2648/** Abstract HGCM command structure. Used only to define a typed pointer. */
2649struct VBOXHGCMCMD;
2650
2651/** Pointer to HGCM command structure. This pointer is unique and identifies
2652 * the command being processed. The pointer is passed to HGCM connector methods,
2653 * and must be passed back to HGCM port when command is completed.
2654 */
2655typedef struct VBOXHGCMCMD *PVBOXHGCMCMD;
2656
2657/** Pointer to a HGCM port interface. */
2658typedef struct PDMIHGCMPORT *PPDMIHGCMPORT;
2659/**
2660 * Host-Guest communication manager port interface (down). Normally implemented
2661 * by VMMDev.
2662 * Pair with PDMIHGCMCONNECTOR.
2663 */
2664typedef struct PDMIHGCMPORT
2665{
2666 /**
2667 * Notify the guest on a command completion.
2668 *
2669 * @param pInterface Pointer to this interface.
2670 * @param rc The return code (VBox error code).
2671 * @param pCmd A pointer that identifies the completed command.
2672 *
2673 * @returns VBox status code
2674 */
2675 DECLR3CALLBACKMEMBER(void, pfnCompleted,(PPDMIHGCMPORT pInterface, int32_t rc, PVBOXHGCMCMD pCmd));
2676
2677} PDMIHGCMPORT;
2678/** PDMIHGCMPORT interface ID. */
2679# define PDMIHGCMPORT_IID "e00a0cbf-b75a-45c3-87f4-41cddbc5ae0b"
2680
2681
2682/** Pointer to a HGCM service location structure. */
2683typedef struct HGCMSERVICELOCATION *PHGCMSERVICELOCATION;
2684
2685/** Pointer to a HGCM connector interface. */
2686typedef struct PDMIHGCMCONNECTOR *PPDMIHGCMCONNECTOR;
2687/**
2688 * The Host-Guest communication manager connector interface (up). Normally
2689 * implemented by Main::VMMDevInterface.
2690 * Pair with PDMIHGCMPORT.
2691 */
2692typedef struct PDMIHGCMCONNECTOR
2693{
2694 /**
2695 * Locate a service and inform it about a client connection.
2696 *
2697 * @param pInterface Pointer to this interface.
2698 * @param pCmd A pointer that identifies the command.
2699 * @param pServiceLocation Pointer to the service location structure.
2700 * @param pu32ClientID Where to store the client id for the connection.
2701 * @return VBox status code.
2702 * @thread The emulation thread.
2703 */
2704 DECLR3CALLBACKMEMBER(int, pfnConnect,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, PHGCMSERVICELOCATION pServiceLocation, uint32_t *pu32ClientID));
2705
2706 /**
2707 * Disconnect from service.
2708 *
2709 * @param pInterface Pointer to this interface.
2710 * @param pCmd A pointer that identifies the command.
2711 * @param u32ClientID The client id returned by the pfnConnect call.
2712 * @return VBox status code.
2713 * @thread The emulation thread.
2714 */
2715 DECLR3CALLBACKMEMBER(int, pfnDisconnect,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID));
2716
2717 /**
2718 * Process a guest issued command.
2719 *
2720 * @param pInterface Pointer to this interface.
2721 * @param pCmd A pointer that identifies the command.
2722 * @param u32ClientID The client id returned by the pfnConnect call.
2723 * @param u32Function Function to be performed by the service.
2724 * @param cParms Number of parameters in the array pointed to by paParams.
2725 * @param paParms Pointer to an array of parameters.
2726 * @return VBox status code.
2727 * @thread The emulation thread.
2728 */
2729 DECLR3CALLBACKMEMBER(int, pfnCall,(PPDMIHGCMCONNECTOR pInterface, PVBOXHGCMCMD pCmd, uint32_t u32ClientID, uint32_t u32Function,
2730 uint32_t cParms, PVBOXHGCMSVCPARM paParms));
2731
2732} PDMIHGCMCONNECTOR;
2733/** PDMIHGCMCONNECTOR interface ID. */
2734# define PDMIHGCMCONNECTOR_IID "a1104758-c888-4437-8f2a-7bac17865b5c"
2735
2736#endif /* VBOX_WITH_HGCM */
2737
2738/**
2739 * Data direction.
2740 */
2741typedef enum PDMSCSIREQUESTTXDIR
2742{
2743 PDMSCSIREQUESTTXDIR_UNKNOWN = 0x00,
2744 PDMSCSIREQUESTTXDIR_FROM_DEVICE = 0x01,
2745 PDMSCSIREQUESTTXDIR_TO_DEVICE = 0x02,
2746 PDMSCSIREQUESTTXDIR_NONE = 0x03,
2747 PDMSCSIREQUESTTXDIR_32BIT_HACK = 0x7fffffff
2748} PDMSCSIREQUESTTXDIR;
2749
2750/**
2751 * SCSI request structure.
2752 */
2753typedef struct PDMSCSIREQUEST
2754{
2755 /** The logical unit. */
2756 uint32_t uLogicalUnit;
2757 /** Direction of the data flow. */
2758 PDMSCSIREQUESTTXDIR uDataDirection;
2759 /** Size of the SCSI CDB. */
2760 uint32_t cbCDB;
2761 /** Pointer to the SCSI CDB. */
2762 uint8_t *pbCDB;
2763 /** Overall size of all scatter gather list elements
2764 * for data transfer if any. */
2765 uint32_t cbScatterGather;
2766 /** Number of elements in the scatter gather list. */
2767 uint32_t cScatterGatherEntries;
2768 /** Pointer to the head of the scatter gather list. */
2769 PRTSGSEG paScatterGatherHead;
2770 /** Size of the sense buffer. */
2771 uint32_t cbSenseBuffer;
2772 /** Pointer to the sense buffer. *
2773 * Current assumption that the sense buffer is not scattered. */
2774 uint8_t *pbSenseBuffer;
2775 /** Opaque user data for use by the device. Left untouched by everything else! */
2776 void *pvUser;
2777} PDMSCSIREQUEST, *PPDMSCSIREQUEST;
2778/** Pointer to a const SCSI request structure. */
2779typedef const PDMSCSIREQUEST *PCSCSIREQUEST;
2780
2781/** Pointer to a SCSI port interface. */
2782typedef struct PDMISCSIPORT *PPDMISCSIPORT;
2783/**
2784 * SCSI command execution port interface (down).
2785 * Pair with PDMISCSICONNECTOR.
2786 */
2787typedef struct PDMISCSIPORT
2788{
2789
2790 /**
2791 * Notify the device on request completion.
2792 *
2793 * @returns VBox status code.
2794 * @param pInterface Pointer to this interface.
2795 * @param pSCSIRequest Pointer to the finished SCSI request.
2796 * @param rcCompletion SCSI_STATUS_* code for the completed request.
2797 * @param fRedo Flag whether the request can to be redone
2798 * when it failed.
2799 * @param rcReq The status code the request completed with (VERR_*)
2800 * Should be only used to choose the correct error message
2801 * displayed to the user if the error can be fixed by him
2802 * (fRedo is true).
2803 */
2804 DECLR3CALLBACKMEMBER(int, pfnSCSIRequestCompleted, (PPDMISCSIPORT pInterface, PPDMSCSIREQUEST pSCSIRequest,
2805 int rcCompletion, bool fRedo, int rcReq));
2806
2807 /**
2808 * Returns the storage controller name, instance and LUN of the attached medium.
2809 *
2810 * @returns VBox status.
2811 * @param pInterface Pointer to this interface.
2812 * @param ppcszController Where to store the name of the storage controller.
2813 * @param piInstance Where to store the instance number of the controller.
2814 * @param piLUN Where to store the LUN of the attached device.
2815 */
2816 DECLR3CALLBACKMEMBER(int, pfnQueryDeviceLocation, (PPDMISCSIPORT pInterface, const char **ppcszController,
2817 uint32_t *piInstance, uint32_t *piLUN));
2818
2819} PDMISCSIPORT;
2820/** PDMISCSIPORT interface ID. */
2821#define PDMISCSIPORT_IID "05d9fc3b-e38c-4b30-8344-a323feebcfe5"
2822
2823
2824/** Pointer to a SCSI connector interface. */
2825typedef struct PDMISCSICONNECTOR *PPDMISCSICONNECTOR;
2826/**
2827 * SCSI command execution connector interface (up).
2828 * Pair with PDMISCSIPORT.
2829 */
2830typedef struct PDMISCSICONNECTOR
2831{
2832
2833 /**
2834 * Submits a SCSI request for execution.
2835 *
2836 * @returns VBox status code.
2837 * @param pInterface Pointer to this interface.
2838 * @param pSCSIRequest Pointer to the SCSI request to execute.
2839 */
2840 DECLR3CALLBACKMEMBER(int, pfnSCSIRequestSend, (PPDMISCSICONNECTOR pInterface, PPDMSCSIREQUEST pSCSIRequest));
2841
2842} PDMISCSICONNECTOR;
2843/** PDMISCSICONNECTOR interface ID. */
2844#define PDMISCSICONNECTOR_IID "94465fbd-a2f2-447e-88c9-7366421bfbfe"
2845
2846
2847/** Pointer to a display VBVA callbacks interface. */
2848typedef struct PDMIDISPLAYVBVACALLBACKS *PPDMIDISPLAYVBVACALLBACKS;
2849/**
2850 * Display VBVA callbacks interface (up).
2851 */
2852typedef struct PDMIDISPLAYVBVACALLBACKS
2853{
2854
2855 /**
2856 * Informs guest about completion of processing the given Video HW Acceleration
2857 * command, does not wait for the guest to process the command.
2858 *
2859 * @returns ???
2860 * @param pInterface Pointer to this interface.
2861 * @param pCmd The Video HW Acceleration Command that was
2862 * completed.
2863 * @todo r=bird: if async means asynchronous; then
2864 * s/pfnVHWACommandCompleteAsynch/pfnVHWACommandCompleteAsync/;
2865 * fi
2866 */
2867 DECLR3CALLBACKMEMBER(int, pfnVHWACommandCompleteAsynch, (PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVHWACMD pCmd));
2868
2869 DECLR3CALLBACKMEMBER(int, pfnCrHgsmiCommandCompleteAsync, (PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CMD pCmd, int rc));
2870
2871 DECLR3CALLBACKMEMBER(int, pfnCrHgsmiControlCompleteAsync, (PPDMIDISPLAYVBVACALLBACKS pInterface, PVBOXVDMACMD_CHROMIUM_CTL pCmd, int rc));
2872} PDMIDISPLAYVBVACALLBACKS;
2873/** PDMIDISPLAYVBVACALLBACKS */
2874#define PDMIDISPLAYVBVACALLBACKS_IID "b78b81d2-c821-4e66-96ff-dbafa76343a5"
2875
2876/** @} */
2877
2878RT_C_DECLS_END
2879
2880#endif
Note: See TracBrowser for help on using the repository browser.

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