VirtualBox

source: vbox/trunk/src/VBox/Main/src-client/MouseImpl.cpp@ 63360

Last change on this file since 63360 was 63244, checked in by vboxsync, 8 years ago

Main: warnings

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 38.4 KB
Line 
1/* $Id: MouseImpl.cpp 63244 2016-08-10 10:36:09Z vboxsync $ */
2/** @file
3 * VirtualBox COM class implementation
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#include <iprt/cpp/utils.h>
19
20#include "MouseImpl.h"
21#include "DisplayImpl.h"
22#include "VMMDev.h"
23#include "MousePointerShapeWrap.h"
24
25#include "AutoCaller.h"
26#include "Logging.h"
27
28#include <VBox/vmm/pdmdrv.h>
29#include <VBox/VMMDev.h>
30
31#include <iprt/asm.h>
32
33class ATL_NO_VTABLE MousePointerShape:
34 public MousePointerShapeWrap
35{
36public:
37
38 DECLARE_EMPTY_CTOR_DTOR(MousePointerShape)
39
40 HRESULT FinalConstruct();
41 void FinalRelease();
42
43 /* Public initializer/uninitializer for internal purposes only. */
44 HRESULT init(ComObjPtr<Mouse> pMouse,
45 bool fVisible, bool fAlpha,
46 uint32_t hotX, uint32_t hotY,
47 uint32_t width, uint32_t height,
48 const uint8_t *pu8Shape, uint32_t cbShape);
49 void uninit();
50
51private:
52 // wrapped IMousePointerShape properties
53 virtual HRESULT getVisible(BOOL *aVisible);
54 virtual HRESULT getAlpha(BOOL *aAlpha);
55 virtual HRESULT getHotX(ULONG *aHotX);
56 virtual HRESULT getHotY(ULONG *aHotY);
57 virtual HRESULT getWidth(ULONG *aWidth);
58 virtual HRESULT getHeight(ULONG *aHeight);
59 virtual HRESULT getShape(std::vector<BYTE> &aShape);
60
61 struct Data
62 {
63 ComObjPtr<Mouse> pMouse;
64 bool fVisible;
65 bool fAlpha;
66 uint32_t hotX;
67 uint32_t hotY;
68 uint32_t width;
69 uint32_t height;
70 std::vector<BYTE> shape;
71 };
72
73 Data m;
74};
75
76/*
77 * MousePointerShape implementation.
78 */
79DEFINE_EMPTY_CTOR_DTOR(MousePointerShape)
80
81HRESULT MousePointerShape::FinalConstruct()
82{
83 return BaseFinalConstruct();
84}
85
86void MousePointerShape::FinalRelease()
87{
88 uninit();
89
90 BaseFinalRelease();
91}
92
93HRESULT MousePointerShape::init(ComObjPtr<Mouse> pMouse,
94 bool fVisible, bool fAlpha,
95 uint32_t hotX, uint32_t hotY,
96 uint32_t width, uint32_t height,
97 const uint8_t *pu8Shape, uint32_t cbShape)
98{
99 LogFlowThisFunc(("v %d, a %d, h %d,%d, %dx%d, cb %d\n",
100 fVisible, fAlpha, hotX, hotY, width, height, cbShape));
101
102 /* Enclose the state transition NotReady->InInit->Ready */
103 AutoInitSpan autoInitSpan(this);
104 AssertReturn(autoInitSpan.isOk(), E_FAIL);
105
106 m.pMouse = pMouse;
107 m.fVisible = fVisible;
108 m.fAlpha = fAlpha;
109 m.hotX = hotX;
110 m.hotY = hotY;
111 m.width = width;
112 m.height = height;
113 m.shape.resize(cbShape);
114 if (cbShape)
115 {
116 memcpy(&m.shape.front(), pu8Shape, cbShape);
117 }
118
119 /* Confirm a successful initialization */
120 autoInitSpan.setSucceeded();
121
122 return S_OK;
123}
124
125void MousePointerShape::uninit()
126{
127 LogFlowThisFunc(("\n"));
128
129 /* Enclose the state transition Ready->InUninit->NotReady */
130 AutoUninitSpan autoUninitSpan(this);
131 if (autoUninitSpan.uninitDone())
132 return;
133
134 m.pMouse.setNull();
135}
136
137HRESULT MousePointerShape::getVisible(BOOL *aVisible)
138{
139 *aVisible = m.fVisible;
140 return S_OK;
141}
142
143HRESULT MousePointerShape::getAlpha(BOOL *aAlpha)
144{
145 *aAlpha = m.fAlpha;
146 return S_OK;
147}
148
149HRESULT MousePointerShape::getHotX(ULONG *aHotX)
150{
151 *aHotX = m.hotX;
152 return S_OK;
153}
154
155HRESULT MousePointerShape::getHotY(ULONG *aHotY)
156{
157 *aHotY = m.hotY;
158 return S_OK;
159}
160
161HRESULT MousePointerShape::getWidth(ULONG *aWidth)
162{
163 *aWidth = m.width;
164 return S_OK;
165}
166
167HRESULT MousePointerShape::getHeight(ULONG *aHeight)
168{
169 *aHeight = m.height;
170 return S_OK;
171}
172
173HRESULT MousePointerShape::getShape(std::vector<BYTE> &aShape)
174{
175 aShape.resize(m.shape.size());
176 if (m.shape.size())
177 memcpy(&aShape.front(), &m.shape.front(), aShape.size());
178 return S_OK;
179}
180
181
182/** @name Mouse device capabilities bitfield
183 * @{ */
184enum
185{
186 /** The mouse device can do relative reporting */
187 MOUSE_DEVCAP_RELATIVE = 1,
188 /** The mouse device can do absolute reporting */
189 MOUSE_DEVCAP_ABSOLUTE = 2,
190 /** The mouse device can do absolute reporting */
191 MOUSE_DEVCAP_MULTI_TOUCH = 4
192};
193/** @} */
194
195
196/**
197 * Mouse driver instance data.
198 */
199struct DRVMAINMOUSE
200{
201 /** Pointer to the mouse object. */
202 Mouse *pMouse;
203 /** Pointer to the driver instance structure. */
204 PPDMDRVINS pDrvIns;
205 /** Pointer to the mouse port interface of the driver/device above us. */
206 PPDMIMOUSEPORT pUpPort;
207 /** Our mouse connector interface. */
208 PDMIMOUSECONNECTOR IConnector;
209 /** The capabilities of this device. */
210 uint32_t u32DevCaps;
211};
212
213
214// constructor / destructor
215/////////////////////////////////////////////////////////////////////////////
216
217Mouse::Mouse()
218 : mParent(NULL)
219{
220}
221
222Mouse::~Mouse()
223{
224}
225
226
227HRESULT Mouse::FinalConstruct()
228{
229 RT_ZERO(mpDrv);
230 RT_ZERO(mPointerData);
231 mcLastX = 0x8000;
232 mcLastY = 0x8000;
233 mfLastButtons = 0;
234 mfVMMDevGuestCaps = 0;
235 return BaseFinalConstruct();
236}
237
238void Mouse::FinalRelease()
239{
240 uninit();
241 BaseFinalRelease();
242}
243
244// public methods only for internal purposes
245/////////////////////////////////////////////////////////////////////////////
246
247/**
248 * Initializes the mouse object.
249 *
250 * @returns COM result indicator
251 * @param parent handle of our parent object
252 */
253HRESULT Mouse::init (ConsoleMouseInterface *parent)
254{
255 LogFlowThisFunc(("\n"));
256
257 ComAssertRet(parent, E_INVALIDARG);
258
259 /* Enclose the state transition NotReady->InInit->Ready */
260 AutoInitSpan autoInitSpan(this);
261 AssertReturn(autoInitSpan.isOk(), E_FAIL);
262
263 unconst(mParent) = parent;
264
265 unconst(mEventSource).createObject();
266 HRESULT rc = mEventSource->init();
267 AssertComRCReturnRC(rc);
268 mMouseEvent.init(mEventSource, VBoxEventType_OnGuestMouse,
269 0, 0, 0, 0, 0, 0);
270
271 /* Confirm a successful initialization */
272 autoInitSpan.setSucceeded();
273
274 return S_OK;
275}
276
277/**
278 * Uninitializes the instance and sets the ready flag to FALSE.
279 * Called either from FinalRelease() or by the parent when it gets destroyed.
280 */
281void Mouse::uninit()
282{
283 LogFlowThisFunc(("\n"));
284
285 /* Enclose the state transition Ready->InUninit->NotReady */
286 AutoUninitSpan autoUninitSpan(this);
287 if (autoUninitSpan.uninitDone())
288 return;
289
290 for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
291 {
292 if (mpDrv[i])
293 mpDrv[i]->pMouse = NULL;
294 mpDrv[i] = NULL;
295 }
296
297 mPointerShape.setNull();
298
299 RTMemFree(mPointerData.pu8Shape);
300 mPointerData.pu8Shape = NULL;
301 mPointerData.cbShape = 0;
302
303 mMouseEvent.uninit();
304 unconst(mEventSource).setNull();
305 unconst(mParent) = NULL;
306}
307
308void Mouse::updateMousePointerShape(bool fVisible, bool fAlpha,
309 uint32_t hotX, uint32_t hotY,
310 uint32_t width, uint32_t height,
311 const uint8_t *pu8Shape, uint32_t cbShape)
312{
313 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
314
315 RTMemFree(mPointerData.pu8Shape);
316 mPointerData.pu8Shape = NULL;
317 mPointerData.cbShape = 0;
318
319 mPointerData.fVisible = fVisible;
320 mPointerData.fAlpha = fAlpha;
321 mPointerData.hotX = hotX;
322 mPointerData.hotY = hotY;
323 mPointerData.width = width;
324 mPointerData.height = height;
325 if (cbShape)
326 {
327 mPointerData.pu8Shape = (uint8_t *)RTMemDup(pu8Shape, cbShape);
328 if (mPointerData.pu8Shape)
329 {
330 mPointerData.cbShape = cbShape;
331 }
332 }
333
334 mPointerShape.setNull();
335}
336
337// IMouse properties
338/////////////////////////////////////////////////////////////////////////////
339
340/** Report the front-end's mouse handling capabilities to the VMM device and
341 * thus to the guest.
342 * @note all calls out of this object are made with no locks held! */
343HRESULT Mouse::i_updateVMMDevMouseCaps(uint32_t fCapsAdded,
344 uint32_t fCapsRemoved)
345{
346 VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
347 if (!pVMMDev)
348 return E_FAIL; /* No assertion, as the front-ends can send events
349 * at all sorts of inconvenient times. */
350 DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
351 if (pDisplay == NULL)
352 return E_FAIL;
353 PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
354 if (!pVMMDevPort)
355 return E_FAIL; /* same here */
356
357 int rc = pVMMDevPort->pfnUpdateMouseCapabilities(pVMMDevPort, fCapsAdded,
358 fCapsRemoved);
359 if (RT_FAILURE(rc))
360 return E_FAIL;
361 return pDisplay->i_reportHostCursorCapabilities(fCapsAdded, fCapsRemoved);
362}
363
364/**
365 * Returns whether the currently active device portfolio can accept absolute
366 * mouse events.
367 *
368 * @returns COM status code
369 * @param absoluteSupported address of result variable
370 */
371HRESULT Mouse::getAbsoluteSupported(BOOL *aAbsoluteSupported)
372{
373 *aAbsoluteSupported = i_supportsAbs();
374 return S_OK;
375}
376
377/**
378 * Returns whether the currently active device portfolio can accept relative
379 * mouse events.
380 *
381 * @returns COM status code
382 * @param relativeSupported address of result variable
383 */
384HRESULT Mouse::getRelativeSupported(BOOL *aRelativeSupported)
385{
386 *aRelativeSupported = i_supportsRel();
387 return S_OK;
388}
389
390/**
391 * Returns whether the currently active device portfolio can accept multi-touch
392 * mouse events.
393 *
394 * @returns COM status code
395 * @param multiTouchSupported address of result variable
396 */
397HRESULT Mouse::getMultiTouchSupported(BOOL *aMultiTouchSupported)
398{
399 *aMultiTouchSupported = i_supportsMT();
400 return S_OK;
401}
402
403/**
404 * Returns whether the guest can currently switch to drawing the mouse cursor
405 * itself if it is asked to by the front-end.
406 *
407 * @returns COM status code
408 * @param pfNeedsHostCursor address of result variable
409 */
410HRESULT Mouse::getNeedsHostCursor(BOOL *aNeedsHostCursor)
411{
412 *aNeedsHostCursor = i_guestNeedsHostCursor();
413 return S_OK;
414}
415
416HRESULT Mouse::getPointerShape(ComPtr<IMousePointerShape> &aPointerShape)
417{
418 HRESULT hr = S_OK;
419
420 AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
421
422 if (mPointerShape.isNull())
423 {
424 ComObjPtr<MousePointerShape> obj;
425 hr = obj.createObject();
426 if (SUCCEEDED(hr))
427 {
428 hr = obj->init(this, mPointerData.fVisible, mPointerData.fAlpha,
429 mPointerData.hotX, mPointerData.hotY,
430 mPointerData.width, mPointerData.height,
431 mPointerData.pu8Shape, mPointerData.cbShape);
432 }
433
434 if (SUCCEEDED(hr))
435 {
436 mPointerShape = obj;
437 }
438 }
439
440 if (SUCCEEDED(hr))
441 {
442 aPointerShape = mPointerShape;
443 }
444
445 return hr;
446}
447
448// IMouse methods
449/////////////////////////////////////////////////////////////////////////////
450
451/** Converts a bitfield containing information about mouse buttons currently
452 * held down from the format used by the front-end to the format used by PDM
453 * and the emulated pointing devices. */
454static uint32_t i_mouseButtonsToPDM(LONG buttonState)
455{
456 uint32_t fButtons = 0;
457 if (buttonState & MouseButtonState_LeftButton)
458 fButtons |= PDMIMOUSEPORT_BUTTON_LEFT;
459 if (buttonState & MouseButtonState_RightButton)
460 fButtons |= PDMIMOUSEPORT_BUTTON_RIGHT;
461 if (buttonState & MouseButtonState_MiddleButton)
462 fButtons |= PDMIMOUSEPORT_BUTTON_MIDDLE;
463 if (buttonState & MouseButtonState_XButton1)
464 fButtons |= PDMIMOUSEPORT_BUTTON_X1;
465 if (buttonState & MouseButtonState_XButton2)
466 fButtons |= PDMIMOUSEPORT_BUTTON_X2;
467 return fButtons;
468}
469
470HRESULT Mouse::getEventSource(ComPtr<IEventSource> &aEventSource)
471{
472 // no need to lock - lifetime constant
473 mEventSource.queryInterfaceTo(aEventSource.asOutParam());
474 return S_OK;
475}
476
477/**
478 * Send a relative pointer event to the relative device we deem most
479 * appropriate.
480 *
481 * @returns COM status code
482 */
483HRESULT Mouse::i_reportRelEventToMouseDev(int32_t dx, int32_t dy, int32_t dz,
484 int32_t dw, uint32_t fButtons)
485{
486 if (dx || dy || dz || dw || fButtons != mfLastButtons)
487 {
488 PPDMIMOUSEPORT pUpPort = NULL;
489 {
490 AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
491
492 for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
493 {
494 if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE))
495 pUpPort = mpDrv[i]->pUpPort;
496 }
497 }
498 if (!pUpPort)
499 return S_OK;
500
501 int vrc = pUpPort->pfnPutEvent(pUpPort, dx, dy, dz, dw, fButtons);
502
503 if (RT_FAILURE(vrc))
504 return setError(VBOX_E_IPRT_ERROR,
505 tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
506 vrc);
507 mfLastButtons = fButtons;
508 }
509 return S_OK;
510}
511
512
513/**
514 * Send an absolute pointer event to the emulated absolute device we deem most
515 * appropriate.
516 *
517 * @returns COM status code
518 */
519HRESULT Mouse::i_reportAbsEventToMouseDev(int32_t x, int32_t y,
520 int32_t dz, int32_t dw, uint32_t fButtons)
521{
522 if ( x < VMMDEV_MOUSE_RANGE_MIN
523 || x > VMMDEV_MOUSE_RANGE_MAX)
524 return S_OK;
525 if ( y < VMMDEV_MOUSE_RANGE_MIN
526 || y > VMMDEV_MOUSE_RANGE_MAX)
527 return S_OK;
528 if ( x != mcLastX || y != mcLastY
529 || dz || dw || fButtons != mfLastButtons)
530 {
531 PPDMIMOUSEPORT pUpPort = NULL;
532 {
533 AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
534
535 for (unsigned i = 0; !pUpPort && i < MOUSE_MAX_DEVICES; ++i)
536 {
537 if (mpDrv[i] && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE))
538 pUpPort = mpDrv[i]->pUpPort;
539 }
540 }
541 if (!pUpPort)
542 return S_OK;
543
544 int vrc = pUpPort->pfnPutEventAbs(pUpPort, x, y, dz,
545 dw, fButtons);
546 if (RT_FAILURE(vrc))
547 return setError(VBOX_E_IPRT_ERROR,
548 tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
549 vrc);
550 mfLastButtons = fButtons;
551
552 }
553 return S_OK;
554}
555
556HRESULT Mouse::i_reportMultiTouchEventToDevice(uint8_t cContacts,
557 const uint64_t *pau64Contacts,
558 uint32_t u32ScanTime)
559{
560 HRESULT hrc = S_OK;
561
562 PPDMIMOUSEPORT pUpPort = NULL;
563 {
564 AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
565
566 unsigned i;
567 for (i = 0; i < MOUSE_MAX_DEVICES; ++i)
568 {
569 if ( mpDrv[i]
570 && (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_MULTI_TOUCH))
571 {
572 pUpPort = mpDrv[i]->pUpPort;
573 break;
574 }
575 }
576 }
577
578 if (pUpPort)
579 {
580 int vrc = pUpPort->pfnPutEventMultiTouch(pUpPort, cContacts, pau64Contacts, u32ScanTime);
581 if (RT_FAILURE(vrc))
582 hrc = setError(VBOX_E_IPRT_ERROR,
583 tr("Could not send the multi-touch event to the virtual device (%Rrc)"),
584 vrc);
585 }
586 else
587 {
588 hrc = E_UNEXPECTED;
589 }
590
591 return hrc;
592}
593
594
595/**
596 * Send an absolute position event to the VMM device.
597 * @note all calls out of this object are made with no locks held!
598 *
599 * @returns COM status code
600 */
601HRESULT Mouse::i_reportAbsEventToVMMDev(int32_t x, int32_t y)
602{
603 VMMDevMouseInterface *pVMMDev = mParent->i_getVMMDevMouseInterface();
604 ComAssertRet(pVMMDev, E_FAIL);
605 PPDMIVMMDEVPORT pVMMDevPort = pVMMDev->getVMMDevPort();
606 ComAssertRet(pVMMDevPort, E_FAIL);
607
608 if (x != mcLastX || y != mcLastY)
609 {
610 int vrc = pVMMDevPort->pfnSetAbsoluteMouse(pVMMDevPort,
611 x, y);
612 if (RT_FAILURE(vrc))
613 return setError(VBOX_E_IPRT_ERROR,
614 tr("Could not send the mouse event to the virtual mouse (%Rrc)"),
615 vrc);
616 }
617 return S_OK;
618}
619
620
621/**
622 * Send an absolute pointer event to a pointing device (the VMM device if
623 * possible or whatever emulated absolute device seems best to us if not).
624 *
625 * @returns COM status code
626 */
627HRESULT Mouse::i_reportAbsEventToInputDevices(int32_t x, int32_t y, int32_t dz, int32_t dw, uint32_t fButtons,
628 bool fUsesVMMDevEvent)
629{
630 HRESULT rc;
631 /** If we are using the VMMDev to report absolute position but without
632 * VMMDev IRQ support then we need to send a small "jiggle" to the emulated
633 * relative mouse device to alert the guest to changes. */
634 LONG cJiggle = 0;
635
636 if (i_vmmdevCanAbs())
637 {
638 /*
639 * Send the absolute mouse position to the VMM device.
640 */
641 if (x != mcLastX || y != mcLastY)
642 {
643 rc = i_reportAbsEventToVMMDev(x, y);
644 cJiggle = !fUsesVMMDevEvent;
645 }
646 rc = i_reportRelEventToMouseDev(cJiggle, 0, dz, dw, fButtons);
647 }
648 else
649 rc = i_reportAbsEventToMouseDev(x, y, dz, dw, fButtons);
650
651 mcLastX = x;
652 mcLastY = y;
653 return rc;
654}
655
656
657/**
658 * Send an absolute position event to the display device.
659 * @note all calls out of this object are made with no locks held!
660 * @param x Cursor X position in pixels relative to the first screen, where
661 * (1, 1) is the upper left corner.
662 * @param y Cursor Y position in pixels relative to the first screen, where
663 * (1, 1) is the upper left corner.
664 */
665HRESULT Mouse::i_reportAbsEventToDisplayDevice(int32_t x, int32_t y)
666{
667 DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
668 ComAssertRet(pDisplay, E_FAIL);
669
670 if (x != mcLastX || y != mcLastY)
671 {
672 pDisplay->i_reportHostCursorPosition(x - 1, y - 1);
673 }
674 return S_OK;
675}
676
677
678void Mouse::i_fireMouseEvent(bool fAbsolute, LONG x, LONG y, LONG dz, LONG dw,
679 LONG fButtons)
680{
681 /* If mouse button is pressed, we generate new event, to avoid reusable events coalescing and thus
682 dropping key press events */
683 GuestMouseEventMode_T mode;
684 if (fAbsolute)
685 mode = GuestMouseEventMode_Absolute;
686 else
687 mode = GuestMouseEventMode_Relative;
688
689 if (fButtons != 0)
690 {
691 VBoxEventDesc evDesc;
692 evDesc.init(mEventSource, VBoxEventType_OnGuestMouse, mode, x, y,
693 dz, dw, fButtons);
694 evDesc.fire(0);
695 }
696 else
697 {
698 mMouseEvent.reinit(VBoxEventType_OnGuestMouse, mode, x, y, dz, dw,
699 fButtons);
700 mMouseEvent.fire(0);
701 }
702}
703
704void Mouse::i_fireMultiTouchEvent(uint8_t cContacts,
705 const LONG64 *paContacts,
706 uint32_t u32ScanTime)
707{
708 com::SafeArray<SHORT> xPositions(cContacts);
709 com::SafeArray<SHORT> yPositions(cContacts);
710 com::SafeArray<USHORT> contactIds(cContacts);
711 com::SafeArray<USHORT> contactFlags(cContacts);
712
713 uint8_t i;
714 for (i = 0; i < cContacts; i++)
715 {
716 uint32_t u32Lo = RT_LO_U32(paContacts[i]);
717 uint32_t u32Hi = RT_HI_U32(paContacts[i]);
718 xPositions[i] = (int16_t)u32Lo;
719 yPositions[i] = (int16_t)(u32Lo >> 16);
720 contactIds[i] = RT_BYTE1(u32Hi);
721 contactFlags[i] = RT_BYTE2(u32Hi);
722 }
723
724 VBoxEventDesc evDesc;
725 evDesc.init(mEventSource, VBoxEventType_OnGuestMultiTouch,
726 cContacts, ComSafeArrayAsInParam(xPositions), ComSafeArrayAsInParam(yPositions),
727 ComSafeArrayAsInParam(contactIds), ComSafeArrayAsInParam(contactFlags), u32ScanTime);
728 evDesc.fire(0);
729}
730
731/**
732 * Send a relative mouse event to the guest.
733 * @note the VMMDev capability change is so that the guest knows we are sending
734 * real events over the PS/2 device and not dummy events to signal the
735 * arrival of new absolute pointer data
736 *
737 * @returns COM status code
738 * @param dx X movement
739 * @param dy Y movement
740 * @param dz Z movement
741 * @param fButtons The mouse button state
742 */
743HRESULT Mouse::putMouseEvent(LONG dx, LONG dy, LONG dz, LONG dw,
744 LONG aButtonState)
745{
746 HRESULT rc;
747 uint32_t fButtonsAdj;
748
749 LogRel3(("%s: dx=%d, dy=%d, dz=%d, dw=%d\n", __PRETTY_FUNCTION__,
750 dx, dy, dz, dw));
751
752 fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
753 /* Make sure that the guest knows that we are sending real movement
754 * events to the PS/2 device and not just dummy wake-up ones. */
755 i_updateVMMDevMouseCaps(0, VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE);
756 rc = i_reportRelEventToMouseDev(dx, dy, dz, dw, fButtonsAdj);
757
758 i_fireMouseEvent(false, dx, dy, dz, dw, aButtonState);
759
760 return rc;
761}
762
763/**
764 * Convert an (X, Y) value pair in screen co-ordinates (starting from 1) to a
765 * value from VMMDEV_MOUSE_RANGE_MIN to VMMDEV_MOUSE_RANGE_MAX. Sets the
766 * optional validity value to false if the pair is not on an active screen and
767 * to true otherwise.
768 * @note since guests with recent versions of X.Org use a different method
769 * to everyone else to map the valuator value to a screen pixel (they
770 * multiply by the screen dimension, do a floating point divide by
771 * the valuator maximum and round the result, while everyone else
772 * does truncating integer operations) we adjust the value we send
773 * so that it maps to the right pixel both when the result is rounded
774 * and when it is truncated.
775 *
776 * @returns COM status value
777 */
778HRESULT Mouse::i_convertDisplayRes(LONG x, LONG y, int32_t *pxAdj, int32_t *pyAdj,
779 bool *pfValid)
780{
781 AssertPtrReturn(pxAdj, E_POINTER);
782 AssertPtrReturn(pyAdj, E_POINTER);
783 AssertPtrNullReturn(pfValid, E_POINTER);
784 DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
785 ComAssertRet(pDisplay, E_FAIL);
786 /** The amount to add to the result (multiplied by the screen width/height)
787 * to compensate for differences in guest methods for mapping back to
788 * pixels */
789 enum { ADJUST_RANGE = - 3 * VMMDEV_MOUSE_RANGE / 4 };
790
791 if (pfValid)
792 *pfValid = true;
793 if (!(mfVMMDevGuestCaps & VMMDEV_MOUSE_NEW_PROTOCOL) && !pDisplay->i_isInputMappingSet())
794 {
795 ULONG displayWidth, displayHeight;
796 ULONG ulDummy;
797 LONG lDummy;
798 /* Takes the display lock */
799 HRESULT rc = pDisplay->i_getScreenResolution(0, &displayWidth,
800 &displayHeight, &ulDummy, &lDummy, &lDummy);
801 if (FAILED(rc))
802 return rc;
803
804 *pxAdj = displayWidth ? (x * VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
805 / (LONG) displayWidth: 0;
806 *pyAdj = displayHeight ? (y * VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
807 / (LONG) displayHeight: 0;
808 }
809 else
810 {
811 int32_t x1, y1, x2, y2;
812 /* Takes the display lock */
813 pDisplay->i_getFramebufferDimensions(&x1, &y1, &x2, &y2);
814 *pxAdj = x1 < x2 ? ((x - x1) * VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
815 / (x2 - x1) : 0;
816 *pyAdj = y1 < y2 ? ((y - y1) * VMMDEV_MOUSE_RANGE + ADJUST_RANGE)
817 / (y2 - y1) : 0;
818 if ( *pxAdj < VMMDEV_MOUSE_RANGE_MIN
819 || *pxAdj > VMMDEV_MOUSE_RANGE_MAX
820 || *pyAdj < VMMDEV_MOUSE_RANGE_MIN
821 || *pyAdj > VMMDEV_MOUSE_RANGE_MAX)
822 if (pfValid)
823 *pfValid = false;
824 }
825 return S_OK;
826}
827
828
829/**
830 * Send an absolute mouse event to the VM. This requires either VirtualBox-
831 * specific drivers installed in the guest or absolute pointing device
832 * emulation.
833 * @note the VMMDev capability change is so that the guest knows we are sending
834 * dummy events over the PS/2 device to signal the arrival of new
835 * absolute pointer data, and not pointer real movement data
836 * @note all calls out of this object are made with no locks held!
837 *
838 * @returns COM status code
839 * @param x X position (pixel), starting from 1
840 * @param y Y position (pixel), starting from 1
841 * @param dz Z movement
842 * @param fButtons The mouse button state
843 */
844HRESULT Mouse::putMouseEventAbsolute(LONG x, LONG y, LONG dz, LONG dw,
845 LONG aButtonState)
846{
847 LogRel3(("%s: x=%d, y=%d, dz=%d, dw=%d, fButtons=0x%x\n",
848 __PRETTY_FUNCTION__, x, y, dz, dw, aButtonState));
849
850 int32_t xAdj, yAdj;
851 uint32_t fButtonsAdj;
852 bool fValid;
853
854 /** @todo the front end should do this conversion to avoid races */
855 /** @note Or maybe not... races are pretty inherent in everything done in
856 * this object and not really bad as far as I can see. */
857 HRESULT rc = i_convertDisplayRes(x, y, &xAdj, &yAdj, &fValid);
858 if (FAILED(rc)) return rc;
859
860 fButtonsAdj = i_mouseButtonsToPDM(aButtonState);
861 /* If we are doing old-style (IRQ-less) absolute reporting to the VMM
862 * device then make sure the guest is aware of it, so that it knows to
863 * ignore relative movement on the PS/2 device. */
864 i_updateVMMDevMouseCaps(VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE, 0);
865 if (fValid)
866 {
867 rc = i_reportAbsEventToInputDevices(xAdj, yAdj, dz, dw, fButtonsAdj,
868 RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_NEW_PROTOCOL));
869 if (FAILED(rc)) return rc;
870
871 i_fireMouseEvent(true, x, y, dz, dw, aButtonState);
872 }
873 rc = i_reportAbsEventToDisplayDevice(x, y);
874
875 return rc;
876}
877
878/**
879 * Send a multi-touch event. This requires multi-touch pointing device emulation.
880 * @note all calls out of this object are made with no locks held!
881 *
882 * @returns COM status code.
883 * @param aCount Number of contacts.
884 * @param aContacts Information about each contact.
885 * @param aScanTime Timestamp.
886 */
887HRESULT Mouse::putEventMultiTouch(LONG aCount,
888 const std::vector<LONG64> &aContacts,
889 ULONG aScanTime)
890{
891 LogRel3(("%s: aCount %d(actual %d), aScanTime %u\n",
892 __FUNCTION__, aCount, aContacts.size(), aScanTime));
893
894 HRESULT rc = S_OK;
895
896 if ((LONG)aContacts.size() >= aCount)
897 {
898 const LONG64 *paContacts = aCount > 0? &aContacts.front(): NULL;
899
900 rc = i_putEventMultiTouch(aCount, paContacts, aScanTime);
901 }
902 else
903 {
904 rc = E_INVALIDARG;
905 }
906
907 return rc;
908}
909
910/**
911 * Send a multi-touch event. Version for scripting languages.
912 *
913 * @returns COM status code.
914 * @param aCount Number of contacts.
915 * @param aContacts Information about each contact.
916 * @param aScanTime Timestamp.
917 */
918HRESULT Mouse::putEventMultiTouchString(LONG aCount,
919 const com::Utf8Str &aContacts,
920 ULONG aScanTime)
921{
922 /** @todo implement: convert the string to LONG64 array and call putEventMultiTouch. */
923 NOREF(aCount);
924 NOREF(aContacts);
925 NOREF(aScanTime);
926 return E_NOTIMPL;
927}
928
929
930// private methods
931/////////////////////////////////////////////////////////////////////////////
932
933/* Used by PutEventMultiTouch and PutEventMultiTouchString. */
934HRESULT Mouse::i_putEventMultiTouch(LONG aCount,
935 const LONG64 *paContacts,
936 ULONG aScanTime)
937{
938 if (aCount >= 256)
939 {
940 return E_INVALIDARG;
941 }
942
943 DisplayMouseInterface *pDisplay = mParent->i_getDisplayMouseInterface();
944 ComAssertRet(pDisplay, E_FAIL);
945
946 /* Touch events are mapped to the primary monitor, because the emulated USB
947 * touchscreen device is associated with one (normally the primary) screen in the guest.
948 */
949 ULONG uScreenId = 0;
950
951 ULONG cWidth = 0;
952 ULONG cHeight = 0;
953 ULONG cBPP = 0;
954 LONG xOrigin = 0;
955 LONG yOrigin = 0;
956 HRESULT rc = pDisplay->i_getScreenResolution(uScreenId, &cWidth, &cHeight, &cBPP, &xOrigin, &yOrigin);
957 NOREF(cBPP);
958 ComAssertComRCRetRC(rc);
959
960 uint64_t* pau64Contacts = NULL;
961 uint8_t cContacts = 0;
962
963 /* Deliver 0 contacts too, touch device may use this to reset the state. */
964 if (aCount > 0)
965 {
966 /* Create a copy with converted coords. */
967 pau64Contacts = (uint64_t *)RTMemTmpAlloc(aCount * sizeof(uint64_t));
968 if (pau64Contacts)
969 {
970 int32_t x1 = xOrigin;
971 int32_t y1 = yOrigin;
972 int32_t x2 = x1 + cWidth;
973 int32_t y2 = y1 + cHeight;
974
975 LogRel3(("%s: screen [%d] %d,%d %d,%d\n",
976 __FUNCTION__, uScreenId, x1, y1, x2, y2));
977
978 LONG i;
979 for (i = 0; i < aCount; i++)
980 {
981 uint32_t u32Lo = RT_LO_U32(paContacts[i]);
982 uint32_t u32Hi = RT_HI_U32(paContacts[i]);
983 int32_t x = (int16_t)u32Lo;
984 int32_t y = (int16_t)(u32Lo >> 16);
985 uint8_t contactId = RT_BYTE1(u32Hi);
986 bool fInContact = (RT_BYTE2(u32Hi) & 0x1) != 0;
987 bool fInRange = (RT_BYTE2(u32Hi) & 0x2) != 0;
988
989 LogRel3(("%s: [%d] %d,%d id %d, inContact %d, inRange %d\n",
990 __FUNCTION__, i, x, y, contactId, fInContact, fInRange));
991
992 /* x1,y1 are inclusive and x2,y2 are exclusive,
993 * while x,y start from 1 and are inclusive.
994 */
995 if (x <= x1 || x > x2 || y <= y1 || y > y2)
996 {
997 /* Out of range. Skip the contact. */
998 continue;
999 }
1000
1001 int32_t xAdj = x1 < x2? ((x - 1 - x1) * VMMDEV_MOUSE_RANGE) / (x2 - x1) : 0;
1002 int32_t yAdj = y1 < y2? ((y - 1 - y1) * VMMDEV_MOUSE_RANGE) / (y2 - y1) : 0;
1003
1004 bool fValid = ( xAdj >= VMMDEV_MOUSE_RANGE_MIN
1005 && xAdj <= VMMDEV_MOUSE_RANGE_MAX
1006 && yAdj >= VMMDEV_MOUSE_RANGE_MIN
1007 && yAdj <= VMMDEV_MOUSE_RANGE_MAX);
1008
1009 if (fValid)
1010 {
1011 uint8_t fu8 = (uint8_t)( (fInContact? 0x01: 0x00)
1012 | (fInRange? 0x02: 0x00));
1013 pau64Contacts[cContacts] = RT_MAKE_U64_FROM_U16((uint16_t)xAdj,
1014 (uint16_t)yAdj,
1015 RT_MAKE_U16(contactId, fu8),
1016 0);
1017 cContacts++;
1018 }
1019 }
1020 }
1021 else
1022 {
1023 rc = E_OUTOFMEMORY;
1024 }
1025 }
1026
1027 if (SUCCEEDED(rc))
1028 {
1029 rc = i_reportMultiTouchEventToDevice(cContacts, cContacts? pau64Contacts: NULL, (uint32_t)aScanTime);
1030
1031 /* Send the original contact information. */
1032 i_fireMultiTouchEvent(cContacts, cContacts? paContacts: NULL, (uint32_t)aScanTime);
1033 }
1034
1035 RTMemTmpFree(pau64Contacts);
1036
1037 return rc;
1038}
1039
1040
1041/** Does the guest currently rely on the host to draw the mouse cursor or
1042 * can it switch to doing it itself in software? */
1043bool Mouse::i_guestNeedsHostCursor(void)
1044{
1045 return RT_BOOL(mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_NEEDS_HOST_CURSOR);
1046}
1047
1048
1049/** Check what sort of reporting can be done using the devices currently
1050 * enabled. Does not consider the VMM device. */
1051void Mouse::i_getDeviceCaps(bool *pfAbs, bool *pfRel, bool *pfMT)
1052{
1053 bool fAbsDev = false;
1054 bool fRelDev = false;
1055 bool fMTDev = false;
1056
1057 AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
1058
1059 for (unsigned i = 0; i < MOUSE_MAX_DEVICES; ++i)
1060 if (mpDrv[i])
1061 {
1062 if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_ABSOLUTE)
1063 fAbsDev = true;
1064 if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_RELATIVE)
1065 fRelDev = true;
1066 if (mpDrv[i]->u32DevCaps & MOUSE_DEVCAP_MULTI_TOUCH)
1067 fMTDev = true;
1068 }
1069 if (pfAbs)
1070 *pfAbs = fAbsDev;
1071 if (pfRel)
1072 *pfRel = fRelDev;
1073 if (pfMT)
1074 *pfMT = fMTDev;
1075}
1076
1077
1078/** Does the VMM device currently support absolute reporting? */
1079bool Mouse::i_vmmdevCanAbs(void)
1080{
1081 bool fRelDev;
1082
1083 i_getDeviceCaps(NULL, &fRelDev, NULL);
1084 return (mfVMMDevGuestCaps & VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE)
1085 && fRelDev;
1086}
1087
1088
1089/** Does the VMM device currently support absolute reporting? */
1090bool Mouse::i_deviceCanAbs(void)
1091{
1092 bool fAbsDev;
1093
1094 i_getDeviceCaps(&fAbsDev, NULL, NULL);
1095 return fAbsDev;
1096}
1097
1098
1099/** Can we currently send relative events to the guest? */
1100bool Mouse::i_supportsRel(void)
1101{
1102 bool fRelDev;
1103
1104 i_getDeviceCaps(NULL, &fRelDev, NULL);
1105 return fRelDev;
1106}
1107
1108
1109/** Can we currently send absolute events to the guest? */
1110bool Mouse::i_supportsAbs(void)
1111{
1112 bool fAbsDev;
1113
1114 i_getDeviceCaps(&fAbsDev, NULL, NULL);
1115 return fAbsDev || i_vmmdevCanAbs();
1116}
1117
1118
1119/** Can we currently send absolute events to the guest? */
1120bool Mouse::i_supportsMT(void)
1121{
1122 bool fMTDev;
1123
1124 i_getDeviceCaps(NULL, NULL, &fMTDev);
1125 return fMTDev;
1126}
1127
1128
1129/** Check what sort of reporting can be done using the devices currently
1130 * enabled (including the VMM device) and notify the guest and the front-end.
1131 */
1132void Mouse::i_sendMouseCapsNotifications(void)
1133{
1134 bool fRelDev, fMTDev, fCanAbs, fNeedsHostCursor;
1135
1136 {
1137 AutoReadLock aLock(this COMMA_LOCKVAL_SRC_POS);
1138
1139 i_getDeviceCaps(NULL, &fRelDev, &fMTDev);
1140 fCanAbs = i_supportsAbs();
1141 fNeedsHostCursor = i_guestNeedsHostCursor();
1142 }
1143 mParent->i_onMouseCapabilityChange(fCanAbs, fRelDev, fMTDev, fNeedsHostCursor);
1144}
1145
1146
1147/**
1148 * @interface_method_impl{PDMIMOUSECONNECTOR,pfnReportModes}
1149 * A virtual device is notifying us about its current state and capabilities
1150 */
1151DECLCALLBACK(void) Mouse::i_mouseReportModes(PPDMIMOUSECONNECTOR pInterface, bool fRel, bool fAbs, bool fMT)
1152{
1153 PDRVMAINMOUSE pDrv = RT_FROM_MEMBER(pInterface, DRVMAINMOUSE, IConnector);
1154 if (fRel)
1155 pDrv->u32DevCaps |= MOUSE_DEVCAP_RELATIVE;
1156 else
1157 pDrv->u32DevCaps &= ~MOUSE_DEVCAP_RELATIVE;
1158 if (fAbs)
1159 pDrv->u32DevCaps |= MOUSE_DEVCAP_ABSOLUTE;
1160 else
1161 pDrv->u32DevCaps &= ~MOUSE_DEVCAP_ABSOLUTE;
1162 if (fMT)
1163 pDrv->u32DevCaps |= MOUSE_DEVCAP_MULTI_TOUCH;
1164 else
1165 pDrv->u32DevCaps &= ~MOUSE_DEVCAP_MULTI_TOUCH;
1166
1167 pDrv->pMouse->i_sendMouseCapsNotifications();
1168}
1169
1170
1171/**
1172 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
1173 */
1174DECLCALLBACK(void *) Mouse::i_drvQueryInterface(PPDMIBASE pInterface, const char *pszIID)
1175{
1176 PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
1177 PDRVMAINMOUSE pDrv = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1178
1179 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pDrvIns->IBase);
1180 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIMOUSECONNECTOR, &pDrv->IConnector);
1181 return NULL;
1182}
1183
1184
1185/**
1186 * Destruct a mouse driver instance.
1187 *
1188 * @returns VBox status code.
1189 * @param pDrvIns The driver instance data.
1190 */
1191DECLCALLBACK(void) Mouse::i_drvDestruct(PPDMDRVINS pDrvIns)
1192{
1193 PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
1194 PDRVMAINMOUSE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1195 LogFlow(("Mouse::drvDestruct: iInstance=%d\n", pDrvIns->iInstance));
1196
1197 if (pThis->pMouse)
1198 {
1199 AutoWriteLock mouseLock(pThis->pMouse COMMA_LOCKVAL_SRC_POS);
1200 for (unsigned cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
1201 if (pThis->pMouse->mpDrv[cDev] == pThis)
1202 {
1203 pThis->pMouse->mpDrv[cDev] = NULL;
1204 break;
1205 }
1206 }
1207}
1208
1209
1210/**
1211 * Construct a mouse driver instance.
1212 *
1213 * @copydoc FNPDMDRVCONSTRUCT
1214 */
1215DECLCALLBACK(int) Mouse::i_drvConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfg, uint32_t fFlags)
1216{
1217 RT_NOREF(fFlags);
1218 PDMDRV_CHECK_VERSIONS_RETURN(pDrvIns);
1219 PDRVMAINMOUSE pThis = PDMINS_2_DATA(pDrvIns, PDRVMAINMOUSE);
1220 LogFlow(("drvMainMouse_Construct: iInstance=%d\n", pDrvIns->iInstance));
1221
1222 /*
1223 * Validate configuration.
1224 */
1225 if (!CFGMR3AreValuesValid(pCfg, "Object\0"))
1226 return VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES;
1227 AssertMsgReturn(PDMDrvHlpNoAttach(pDrvIns) == VERR_PDM_NO_ATTACHED_DRIVER,
1228 ("Configuration error: Not possible to attach anything to this driver!\n"),
1229 VERR_PDM_DRVINS_NO_ATTACH);
1230
1231 /*
1232 * IBase.
1233 */
1234 pDrvIns->IBase.pfnQueryInterface = Mouse::i_drvQueryInterface;
1235
1236 pThis->IConnector.pfnReportModes = Mouse::i_mouseReportModes;
1237
1238 /*
1239 * Get the IMousePort interface of the above driver/device.
1240 */
1241 pThis->pUpPort = (PPDMIMOUSEPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMIMOUSEPORT_IID);
1242 if (!pThis->pUpPort)
1243 {
1244 AssertMsgFailed(("Configuration error: No mouse port interface above!\n"));
1245 return VERR_PDM_MISSING_INTERFACE_ABOVE;
1246 }
1247
1248 /*
1249 * Get the Mouse object pointer and update the mpDrv member.
1250 */
1251 void *pv;
1252 int rc = CFGMR3QueryPtr(pCfg, "Object", &pv);
1253 if (RT_FAILURE(rc))
1254 {
1255 AssertMsgFailed(("Configuration error: No/bad \"Object\" value! rc=%Rrc\n", rc));
1256 return rc;
1257 }
1258 pThis->pMouse = (Mouse *)pv; /** @todo Check this cast! */
1259 unsigned cDev;
1260 {
1261 AutoWriteLock mouseLock(pThis->pMouse COMMA_LOCKVAL_SRC_POS);
1262
1263 for (cDev = 0; cDev < MOUSE_MAX_DEVICES; ++cDev)
1264 if (!pThis->pMouse->mpDrv[cDev])
1265 {
1266 pThis->pMouse->mpDrv[cDev] = pThis;
1267 break;
1268 }
1269 }
1270 if (cDev == MOUSE_MAX_DEVICES)
1271 return VERR_NO_MORE_HANDLES;
1272
1273 return VINF_SUCCESS;
1274}
1275
1276
1277/**
1278 * Main mouse driver registration record.
1279 */
1280const PDMDRVREG Mouse::DrvReg =
1281{
1282 /* u32Version */
1283 PDM_DRVREG_VERSION,
1284 /* szName */
1285 "MainMouse",
1286 /* szRCMod */
1287 "",
1288 /* szR0Mod */
1289 "",
1290 /* pszDescription */
1291 "Main mouse driver (Main as in the API).",
1292 /* fFlags */
1293 PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
1294 /* fClass. */
1295 PDM_DRVREG_CLASS_MOUSE,
1296 /* cMaxInstances */
1297 ~0U,
1298 /* cbInstance */
1299 sizeof(DRVMAINMOUSE),
1300 /* pfnConstruct */
1301 Mouse::i_drvConstruct,
1302 /* pfnDestruct */
1303 Mouse::i_drvDestruct,
1304 /* pfnRelocate */
1305 NULL,
1306 /* pfnIOCtl */
1307 NULL,
1308 /* pfnPowerOn */
1309 NULL,
1310 /* pfnReset */
1311 NULL,
1312 /* pfnSuspend */
1313 NULL,
1314 /* pfnResume */
1315 NULL,
1316 /* pfnAttach */
1317 NULL,
1318 /* pfnDetach */
1319 NULL,
1320 /* pfnPowerOff */
1321 NULL,
1322 /* pfnSoftReset */
1323 NULL,
1324 /* u32EndVersion */
1325 PDM_DRVREG_VERSION
1326};
1327/* vi: set tabstop=4 shiftwidth=4 expandtab: */
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