2 * WINE Drivers functions
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1998 Marcus Meissner
6 * Copyright 1999 Eric Pouech
8 * Reformatting and additional comments added by Andrew Greenwood.
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(driver
);
40 static LPWINE_DRIVER lpDrvItemList
/* = NULL */;
41 static const WCHAR HKLM_BASE
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
42 'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
44 WINE_MMTHREAD
* (*pFnGetMMThread16
)(UINT16 h
) /* = NULL */;
45 LPWINE_DRIVER (*pFnOpenDriver16
)(LPCWSTR
,LPCWSTR
,LPARAM
) /* = NULL */;
46 LRESULT (*pFnCloseDriver16
)(UINT16
,LPARAM
,LPARAM
) /* = NULL */;
47 LRESULT (*pFnSendMessage16
)(UINT16
,UINT
,LPARAM
,LPARAM
) /* = NULL */;
49 /**************************************************************************
50 * DRIVER_GetNumberOfModuleRefs [internal]
52 * Returns the number of open drivers which share the same module.
54 static unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule
, WINE_DRIVER
** found
)
59 if (found
) *found
= NULL
;
60 for (lpDrv
= lpDrvItemList
; lpDrv
; lpDrv
= lpDrv
->lpNextItem
)
62 if (!(lpDrv
->dwFlags
& WINE_GDF_16BIT
) && lpDrv
->d
.d32
.hModule
== hModule
)
64 if (found
&& !*found
) *found
= lpDrv
;
71 /**************************************************************************
72 * DRIVER_FindFromHDrvr [internal]
74 * From a hDrvr being 32 bits, returns the WINE internal structure.
76 LPWINE_DRIVER
DRIVER_FindFromHDrvr(HDRVR hDrvr
)
78 LPWINE_DRIVER d
= (LPWINE_DRIVER
)hDrvr
;
80 if (hDrvr
&& HeapValidate(GetProcessHeap(), 0, d
) && d
->dwMagic
== WINE_DI_MAGIC
) {
86 /**************************************************************************
87 * DRIVER_SendMessage [internal]
89 static LRESULT
inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv
, UINT msg
,
90 LPARAM lParam1
, LPARAM lParam2
)
94 if (lpDrv
->dwFlags
& WINE_GDF_16BIT
) {
95 /* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
98 ret
= pFnSendMessage16(lpDrv
->d
.d16
.hDriver16
, msg
, lParam1
, lParam2
);
100 TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
101 lpDrv
->d
.d32
.lpDrvProc
, lpDrv
->d
.d32
.dwDriverID
, (HDRVR
)lpDrv
, msg
, lParam1
, lParam2
);
102 ret
= lpDrv
->d
.d32
.lpDrvProc(lpDrv
->d
.d32
.dwDriverID
, (HDRVR
)lpDrv
, msg
, lParam1
, lParam2
);
103 TRACE("After call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
104 lpDrv
->d
.d32
.lpDrvProc
, lpDrv
->d
.d32
.dwDriverID
, (HDRVR
)lpDrv
, msg
, lParam1
, lParam2
, ret
);
109 /**************************************************************************
110 * SendDriverMessage [WINMM.@]
111 * DrvSendMessage [WINMM.@]
113 LRESULT WINAPI
SendDriverMessage(HDRVR hDriver
, UINT msg
, LONG lParam1
,
119 TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver
, msg
, lParam1
, lParam2
);
121 if ((lpDrv
= DRIVER_FindFromHDrvr(hDriver
)) != NULL
) {
122 retval
= DRIVER_SendMessage(lpDrv
, msg
, lParam1
, lParam2
);
124 WARN("Bad driver handle %p\n", hDriver
);
126 TRACE("retval = %ld\n", retval
);
131 /**************************************************************************
132 * DRIVER_RemoveFromList [internal]
134 * Generates all the logic to handle driver closure / deletion
135 * Removes a driver struct to the list of open drivers.
137 static BOOL
DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv
)
139 if (!(lpDrv
->dwFlags
& WINE_GDF_16BIT
)) {
140 /* last of this driver in list ? */
141 if (DRIVER_GetNumberOfModuleRefs(lpDrv
->d
.d32
.hModule
, NULL
) == 1) {
142 DRIVER_SendMessage(lpDrv
, DRV_DISABLE
, 0L, 0L);
143 DRIVER_SendMessage(lpDrv
, DRV_FREE
, 0L, 0L);
147 if (lpDrv
->lpPrevItem
)
148 lpDrv
->lpPrevItem
->lpNextItem
= lpDrv
->lpNextItem
;
150 lpDrvItemList
= lpDrv
->lpNextItem
;
151 if (lpDrv
->lpNextItem
)
152 lpDrv
->lpNextItem
->lpPrevItem
= lpDrv
->lpPrevItem
;
153 /* trash magic number */
154 lpDrv
->dwMagic
^= 0xa5a5a5a5;
159 /**************************************************************************
160 * DRIVER_AddToList [internal]
162 * Adds a driver struct to the list of open drivers.
163 * Generates all the logic to handle driver creation / open.
165 static BOOL
DRIVER_AddToList(LPWINE_DRIVER lpNewDrv
, LPARAM lParam1
, LPARAM lParam2
)
167 lpNewDrv
->dwMagic
= WINE_DI_MAGIC
;
168 /* First driver to be loaded for this module, need to load correctly the module */
169 if (!(lpNewDrv
->dwFlags
& WINE_GDF_16BIT
)) {
170 /* first of this driver in list ? */
171 if (DRIVER_GetNumberOfModuleRefs(lpNewDrv
->d
.d32
.hModule
, NULL
) == 0) {
172 if (DRIVER_SendMessage(lpNewDrv
, DRV_LOAD
, 0L, 0L) != DRV_SUCCESS
) {
173 TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv
);
176 /* returned value is not checked */
177 DRIVER_SendMessage(lpNewDrv
, DRV_ENABLE
, 0L, 0L);
181 lpNewDrv
->lpNextItem
= NULL
;
182 if (lpDrvItemList
== NULL
) {
183 lpDrvItemList
= lpNewDrv
;
184 lpNewDrv
->lpPrevItem
= NULL
;
186 LPWINE_DRIVER lpDrv
= lpDrvItemList
; /* find end of list */
187 while (lpDrv
->lpNextItem
!= NULL
)
188 lpDrv
= lpDrv
->lpNextItem
;
190 lpDrv
->lpNextItem
= lpNewDrv
;
191 lpNewDrv
->lpPrevItem
= lpDrv
;
194 if (!(lpNewDrv
->dwFlags
& WINE_GDF_16BIT
)) {
195 /* Now just open a new instance of a driver on this module */
196 lpNewDrv
->d
.d32
.dwDriverID
= DRIVER_SendMessage(lpNewDrv
, DRV_OPEN
, lParam1
, lParam2
);
198 if (lpNewDrv
->d
.d32
.dwDriverID
== 0) {
199 TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv
);
200 DRIVER_RemoveFromList(lpNewDrv
);
207 /**************************************************************************
208 * DRIVER_GetLibName [internal]
211 BOOL
DRIVER_GetLibName(LPCWSTR keyName
, LPCWSTR sectName
, LPWSTR buf
, int sz
)
215 static const WCHAR wszSystemIni
[] = {'S','Y','S','T','E','M','.','I','N','I',0};
216 WCHAR wsznull
= '\0';
218 /* This takes us as far as Windows NT\CurrentVersion */
219 lRet
= RegOpenKeyExW(HKEY_LOCAL_MACHINE
, HKLM_BASE
, 0, KEY_QUERY_VALUE
, &hKey
);
221 if (lRet
== ERROR_SUCCESS
)
223 /* Now we descend into the section name that we were given */
224 lRet
= RegOpenKeyExW(hKey
, sectName
, 0, KEY_QUERY_VALUE
, &hSecKey
);
226 if (lRet
== ERROR_SUCCESS
)
228 /* Retrieve the desired value - this is the filename of the lib */
230 lRet
= RegQueryValueExW(hSecKey
, keyName
, 0, 0, (void*)buf
, &bufLen
);
231 RegCloseKey( hSecKey
);
237 /* Finish up if we've got what we want from the registry */
238 if (lRet
== ERROR_SUCCESS
)
241 /* default to system.ini if we can't find it in the registry,
242 * to support native installations where system.ini is still used */
243 return GetPrivateProfileStringW(sectName
, keyName
, &wsznull
, buf
, sz
/ sizeof(WCHAR
), wszSystemIni
);
246 /**************************************************************************
247 * DRIVER_TryOpenDriver32 [internal]
249 * Tries to load a 32 bit driver whose DLL's (module) name is fn
251 LPWINE_DRIVER
DRIVER_TryOpenDriver32(LPCWSTR fn
, LPARAM lParam2
)
253 LPWINE_DRIVER lpDrv
= NULL
;
258 TRACE("(%s, %08lX);\n", debugstr_w(fn
), lParam2
);
260 if ((ptr
= strchrW(fn
, ' ')) != NULL
)
271 lpDrv
= HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER
));
279 if ((hModule
= LoadLibraryW(fn
)) == 0)
281 cause
= "Not a 32 bit lib";
285 lpDrv
->d
.d32
.lpDrvProc
= (DRIVERPROC
)GetProcAddress(hModule
, "DriverProc");
287 if (lpDrv
->d
.d32
.lpDrvProc
== NULL
)
289 cause
= "no DriverProc";
294 lpDrv
->d
.d32
.hModule
= hModule
;
295 lpDrv
->d
.d32
.dwDriverID
= 0;
297 /* Win32 installable drivers must support a two phase opening scheme:
298 * + first open with NULL as lParam2 (session instance),
299 * + then do a second open with the real non null lParam2)
301 if (DRIVER_GetNumberOfModuleRefs(lpDrv
->d
.d32
.hModule
, NULL
) == 0 && lParam2
)
305 if (!DRIVER_AddToList(lpDrv
, (LPARAM
)ptr
, 0L))
307 cause
= "load0 failed";
310 ret
= DRIVER_TryOpenDriver32(fn
, lParam2
);
313 CloseDriver((HDRVR
)lpDrv
, 0L, 0L);
314 cause
= "load1 failed";
320 if (!DRIVER_AddToList(lpDrv
, (LPARAM
)ptr
, lParam2
))
322 cause
= "load failed";
326 TRACE("=> %p\n", lpDrv
);
330 FreeLibrary(hModule
);
331 HeapFree(GetProcessHeap(), 0, lpDrv
);
332 TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn
), cause
);
336 /**************************************************************************
337 * OpenDriverA [WINMM.@]
339 * (0,1,DRV_LOAD ,0 ,0)
340 * (0,1,DRV_ENABLE,0 ,0)
341 * (0,1,DRV_OPEN ,buf[256],0)
343 HDRVR WINAPI
OpenDriverA(LPCSTR lpDriverName
, LPCSTR lpSectionName
, LPARAM lParam
)
352 len
= MultiByteToWideChar( CP_ACP
, 0, lpDriverName
, -1, NULL
, 0 );
353 dn
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
355 MultiByteToWideChar( CP_ACP
, 0, lpDriverName
, -1, dn
, len
);
360 len
= MultiByteToWideChar( CP_ACP
, 0, lpSectionName
, -1, NULL
, 0 );
361 sn
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
363 MultiByteToWideChar( CP_ACP
, 0, lpSectionName
, -1, sn
, len
);
366 ret
= OpenDriver(dn
, sn
, lParam
);
369 HeapFree(GetProcessHeap(), 0, dn
);
370 HeapFree(GetProcessHeap(), 0, sn
);
374 /**************************************************************************
375 * OpenDriver [WINMM.@]
378 HDRVR WINAPI
OpenDriver(LPCWSTR lpDriverName
, LPCWSTR lpSectionName
, LONG lParam
)
380 LPWINE_DRIVER lpDrv
= NULL
;
382 LPCWSTR lsn
= lpSectionName
;
384 TRACE("(%s, %s, 0x%08lx);\n",
385 debugstr_w(lpDriverName
), debugstr_w(lpSectionName
), lParam
);
387 /* If no section name is specified, either the caller is intending on
388 opening a driver by filename, or wants to open a user-installable
389 driver that has an entry in the Drivers32 key in the registry */
392 /* Default registry key */
393 static const WCHAR wszDrivers32
[] = {'D','r','i','v','e','r','s','3','2',0};
395 lstrcpynW(libName
, lpDriverName
, sizeof(libName
) / sizeof(WCHAR
));
397 /* Try and open the driver by filename */
398 if ( (lpDrv
= DRIVER_TryOpenDriver32(libName
, lParam
)) )
401 /* If we got here, the file wasn't found. So we assume the caller
402 wanted a driver specified under the Drivers32 registry key */
406 /* Attempt to locate the driver filename in the registry */
407 if ( DRIVER_GetLibName(lpDriverName
, lsn
, libName
, sizeof(libName
)) )
409 /* Now we have the filename, we can try and load it */
410 if ( (lpDrv
= DRIVER_TryOpenDriver32(libName
, lParam
)) )
414 /* now we will try a 16 bit driver (and add all the glue to make it work... which
415 * is located in our mmsystem implementation)
416 * so ensure, we can load our mmsystem, otherwise just fail
418 WINMM_CheckForMMSystem();
419 if (pFnOpenDriver16
&&
420 (lpDrv
= pFnOpenDriver16(lpDriverName
, lpSectionName
, lParam
)))
422 if (DRIVER_AddToList(lpDrv
, 0, lParam
)) goto the_end
;
423 HeapFree(GetProcessHeap(), 0, lpDrv
);
425 TRACE("Failed to open driver %s from system.ini file, section %s\n",
426 debugstr_w(lpDriverName
), debugstr_w(lpSectionName
));
430 if (lpDrv
) TRACE("=> %p\n", lpDrv
);
434 /**************************************************************************
435 * CloseDriver [WINMM.@]
438 LRESULT WINAPI
CloseDriver(HDRVR hDrvr
, LONG lParam1
, LONG lParam2
)
442 TRACE("(%p, %08lX, %08lX);\n", hDrvr
, lParam1
, lParam2
);
444 if ((lpDrv
= DRIVER_FindFromHDrvr(hDrvr
)) != NULL
)
446 if (lpDrv
->dwFlags
& WINE_GDF_16BIT
)
448 if (pFnCloseDriver16
)
449 pFnCloseDriver16(lpDrv
->d
.d16
.hDriver16
, lParam1
, lParam2
);
453 DRIVER_SendMessage(lpDrv
, DRV_CLOSE
, lParam1
, lParam2
);
454 lpDrv
->d
.d32
.dwDriverID
= 0;
456 if (DRIVER_RemoveFromList(lpDrv
)) {
457 if (!(lpDrv
->dwFlags
& WINE_GDF_16BIT
))
459 LPWINE_DRIVER lpDrv0
;
461 /* if driver has an opened session instance, we have to close it too */
462 if (DRIVER_GetNumberOfModuleRefs(lpDrv
->d
.d32
.hModule
, &lpDrv0
) == 1)
464 DRIVER_SendMessage(lpDrv0
, DRV_CLOSE
, 0L, 0L);
465 lpDrv0
->d
.d32
.dwDriverID
= 0;
466 DRIVER_RemoveFromList(lpDrv0
);
467 FreeLibrary(lpDrv0
->d
.d32
.hModule
);
468 HeapFree(GetProcessHeap(), 0, lpDrv0
);
470 FreeLibrary(lpDrv
->d
.d32
.hModule
);
472 HeapFree(GetProcessHeap(), 0, lpDrv
);
476 WARN("Failed to close driver\n");
480 /**************************************************************************
481 * GetDriverFlags [WINMM.@]
482 * [in] hDrvr handle to the driver
485 * 0x00000000 if hDrvr is an invalid handle
486 * 0x80000000 if hDrvr is a valid 32 bit driver
487 * 0x90000000 if hDrvr is a valid 16 bit driver
489 * native WINMM doesn't return those flags
490 * 0x80000000 for a valid 32 bit driver and that's it
491 * (I may have mixed up the two flags :-(
493 DWORD WINAPI
GetDriverFlags(HDRVR hDrvr
)
498 TRACE("(%p)\n", hDrvr
);
500 if ((lpDrv
= DRIVER_FindFromHDrvr(hDrvr
)) != NULL
) {
501 ret
= WINE_GDF_EXIST
| lpDrv
->dwFlags
;
506 /**************************************************************************
507 * GetDriverModuleHandle [WINMM.@]
508 * DrvGetModuleHandle [WINMM.@]
510 HMODULE WINAPI
GetDriverModuleHandle(HDRVR hDrvr
)
515 TRACE("(%p);\n", hDrvr
);
517 if ((lpDrv
= DRIVER_FindFromHDrvr(hDrvr
)) != NULL
) {
518 if (!(lpDrv
->dwFlags
& WINE_GDF_16BIT
))
519 hModule
= lpDrv
->d
.d32
.hModule
;
521 TRACE("=> %p\n", hModule
);
525 /**************************************************************************
526 * DefDriverProc [WINMM.@]
527 * DrvDefDriverProc [WINMM.@]
529 LONG WINAPI
DefDriverProc(DWORD dwDriverIdentifier
, HDRVR hDrv
,
530 UINT Msg
, LONG lParam1
, LONG lParam2
)
546 /**************************************************************************
547 * DriverCallback [WINMM.@]
549 BOOL WINAPI
DriverCallback(DWORD dwCallBack
, UINT uFlags
, HDRVR hDev
,
550 UINT wMsg
, DWORD dwUser
, DWORD dwParam1
,
553 TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n",
554 dwCallBack
, uFlags
, hDev
, wMsg
, dwUser
, dwParam1
, dwParam2
);
556 switch (uFlags
& DCB_TYPEMASK
) {
560 WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags
, dwCallBack
);
563 TRACE("Window(%04lX) handle=%p!\n", dwCallBack
, hDev
);
564 PostMessageA((HWND
)dwCallBack
, wMsg
, (WPARAM
)hDev
, dwParam1
);
566 case DCB_TASK
: /* aka DCB_THREAD */
567 TRACE("Task(%04lx) !\n", dwCallBack
);
568 PostThreadMessageA(dwCallBack
, wMsg
, (WPARAM
)hDev
, dwParam1
);
571 TRACE("Function (32 bit) !\n");
572 ((LPDRVCALLBACK
)dwCallBack
)(hDev
, wMsg
, dwUser
, dwParam1
, dwParam2
);
575 TRACE("Event(%08lx) !\n", dwCallBack
);
576 SetEvent((HANDLE
)dwCallBack
);
578 case 6: /* I would dub it DCB_MMTHREADSIGNAL */
579 /* this is an undocumented DCB_ value used for mmThreads
580 * loword of dwCallBack contains the handle of the lpMMThd block
581 * which dwSignalCount has to be incremented
583 if (pFnGetMMThread16
)
585 WINE_MMTHREAD
* lpMMThd
= pFnGetMMThread16(LOWORD(dwCallBack
));
587 TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack
), lpMMThd
);
588 /* same as mmThreadSignal16 */
589 InterlockedIncrement((PLONG
)&lpMMThd
->dwSignalCount
);
590 SetEvent(lpMMThd
->hEvent
);
591 /* some other stuff on lpMMThd->hVxD */
596 /* this is an undocumented DCB_ value for... I don't know */
600 WARN("Unknown callback type %d\n", uFlags
& DCB_TYPEMASK
);
607 /******************************************************************
612 void DRIVER_UnloadAll(void)
615 LPWINE_DRIVER lpNextDrv
= NULL
;
618 for (lpDrv
= lpDrvItemList
; lpDrv
!= NULL
; lpDrv
= lpNextDrv
)
620 lpNextDrv
= lpDrv
->lpNextItem
;
621 CloseDriver((HDRVR
)lpDrv
, 0, 0);
624 TRACE("Unloaded %u drivers\n", count
);