VirtualBox

source: vbox/trunk/include/VBox/vmm/pdmifs.h@ 51934

Last change on this file since 51934 was 51836, checked in by vboxsync, 10 years ago

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

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