winmm: The default I/O procedure should return MMIOERR_FILENOTFOUND if the openable...
[wine] / dlls / winmm / driver.c
1 /*
2  * WINE Drivers functions
3  *
4  * Copyright 1994 Martin Ayotte
5  * Copyright 1998 Marcus Meissner
6  * Copyright 1999 Eric Pouech
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <string.h>
27 #include <stdarg.h>
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "winnls.h"
33 #include "winreg.h"
34 #include "mmddk.h"
35 #include "winemm.h"
36 #include "wine/debug.h"
37 #include "wine/unicode.h"
38 #include "excpt.h"
39 #include "wine/exception.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(driver);
42
43 static CRITICAL_SECTION mmdriver_lock;
44 static CRITICAL_SECTION_DEBUG mmdriver_lock_debug =
45 {
46     0, 0, &mmdriver_lock,
47     { &mmdriver_lock_debug.ProcessLocksList, &mmdriver_lock_debug.ProcessLocksList },
48       0, 0, { (DWORD_PTR)(__FILE__ ": mmdriver_lock") }
49 };
50 static CRITICAL_SECTION mmdriver_lock = { &mmdriver_lock_debug, -1, 0, 0, 0, 0 };
51
52 static LPWINE_DRIVER   lpDrvItemList  /* = NULL */;
53 static const WCHAR HKLM_BASE[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
54                                   'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0};
55
56 static void DRIVER_Dump(const char *comment)
57 {
58 #if 0
59     LPWINE_DRIVER       lpDrv;
60
61     TRACE("%s\n", comment);
62
63     EnterCriticalSection( &mmdriver_lock );
64
65     for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpDrv->lpNextItem)
66     {
67         TRACE("%p, magic %04lx, id %p, next %p\n", lpDrv, lpDrv->dwMagic, lpDrv->d.d32.dwDriverID, lpDrv->lpNextItem);
68     }
69
70     LeaveCriticalSection( &mmdriver_lock );
71 #endif
72 }
73
74 /**************************************************************************
75  *                      DRIVER_GetNumberOfModuleRefs            [internal]
76  *
77  * Returns the number of open drivers which share the same module.
78  */
79 static  unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** found)
80 {
81     LPWINE_DRIVER       lpDrv;
82     unsigned            count = 0;
83
84     EnterCriticalSection( &mmdriver_lock );
85
86     if (found) *found = NULL;
87     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
88     {
89         if (lpDrv->hModule == hModule)
90         {
91             if (found && !*found) *found = lpDrv;
92             count++;
93         }
94     }
95
96     LeaveCriticalSection( &mmdriver_lock );
97     return count;
98 }
99
100 /**************************************************************************
101  *                              DRIVER_FindFromHDrvr            [internal]
102  *
103  * From a hDrvr being 32 bits, returns the WINE internal structure.
104  */
105 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
106 {
107     LPWINE_DRIVER d;
108
109     __TRY
110     {
111         d = (LPWINE_DRIVER)hDrvr;
112         if (d && d->dwMagic != WINE_DI_MAGIC) d = NULL;
113     }
114     __EXCEPT_PAGE_FAULT
115     {
116         return NULL;
117     }
118     __ENDTRY;
119
120     if (d) TRACE("%p -> %p, %p\n", hDrvr, d->lpDrvProc, (void *)d->dwDriverID);
121     else TRACE("%p -> NULL\n", hDrvr);
122
123     return d;
124 }
125
126 /**************************************************************************
127  *                              DRIVER_SendMessage              [internal]
128  */
129 static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
130                                          LPARAM lParam1, LPARAM lParam2)
131 {
132     LRESULT             ret = 0;
133
134     TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
135           lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2);
136     ret = lpDrv->lpDrvProc(lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
137     TRACE("After  call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
138           lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2, ret);
139
140     return ret;
141 }
142
143 /**************************************************************************
144  *                              SendDriverMessage               [WINMM.@]
145  *                              DrvSendMessage                  [WINMM.@]
146  */
147 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
148                                  LPARAM lParam2)
149 {
150     LPWINE_DRIVER       lpDrv;
151     LRESULT             retval = 0;
152
153     TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
154
155     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
156         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
157     } else {
158         WARN("Bad driver handle %p\n", hDriver);
159     }
160     TRACE("retval = %ld\n", retval);
161
162     return retval;
163 }
164
165 /**************************************************************************
166  *                              DRIVER_RemoveFromList           [internal]
167  *
168  * Generates all the logic to handle driver closure / deletion
169  * Removes a driver struct to the list of open drivers.
170  */
171 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
172 {
173     /* last of this driver in list ? */
174     if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 1) {
175         DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
176         DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
177     }
178
179     EnterCriticalSection( &mmdriver_lock );
180
181     if (lpDrv->lpPrevItem)
182         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
183     else
184         lpDrvItemList = lpDrv->lpNextItem;
185     if (lpDrv->lpNextItem)
186         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
187     /* trash magic number */
188     lpDrv->dwMagic ^= 0xa5a5a5a5;
189     lpDrv->lpDrvProc = NULL;
190     lpDrv->dwDriverID = 0;
191
192     LeaveCriticalSection( &mmdriver_lock );
193
194     return TRUE;
195 }
196
197 /**************************************************************************
198  *                              DRIVER_AddToList                [internal]
199  *
200  * Adds a driver struct to the list of open drivers.
201  * Generates all the logic to handle driver creation / open.
202  */
203 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
204 {
205     lpNewDrv->dwMagic = WINE_DI_MAGIC;
206     /* First driver to be loaded for this module, need to load correctly the module */
207     /* first of this driver in list ? */
208     if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->hModule, NULL) == 0) {
209         if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
210             TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
211             return FALSE;
212         }
213         /* returned value is not checked */
214         DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
215     }
216
217     /* Now just open a new instance of a driver on this module */
218     lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
219
220     if (lpNewDrv->dwDriverID == 0)
221     {
222         TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
223         return FALSE;
224     }
225
226     EnterCriticalSection( &mmdriver_lock );
227
228     lpNewDrv->lpNextItem = NULL;
229     if (lpDrvItemList == NULL) {
230         lpDrvItemList = lpNewDrv;
231         lpNewDrv->lpPrevItem = NULL;
232     } else {
233         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
234         while (lpDrv->lpNextItem != NULL)
235             lpDrv = lpDrv->lpNextItem;
236
237         lpDrv->lpNextItem = lpNewDrv;
238         lpNewDrv->lpPrevItem = lpDrv;
239     }
240
241     LeaveCriticalSection( &mmdriver_lock );
242     return TRUE;
243 }
244
245 /**************************************************************************
246  *                              DRIVER_GetLibName               [internal]
247  *
248  */
249 BOOL    DRIVER_GetLibName(LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
250 {
251     HKEY        hKey, hSecKey;
252     DWORD       bufLen, lRet;
253     static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0};
254     WCHAR       wsznull = '\0';
255
256     TRACE("registry: %s, %s, %p, %d\n", debugstr_w(keyName), debugstr_w(sectName), buf, sz);
257
258     lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
259     if (lRet == ERROR_SUCCESS) {
260         lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
261         if (lRet == ERROR_SUCCESS) {
262             bufLen = sz;
263             lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen);
264             RegCloseKey( hSecKey );
265         }
266         RegCloseKey( hKey );
267     }
268     if (lRet == ERROR_SUCCESS) return TRUE;
269
270     /* default to system.ini if we can't find it in the registry,
271      * to support native installations where system.ini is still used */
272     TRACE("system.ini: %s, %s, %p, %d\n", debugstr_w(keyName), debugstr_w(sectName), buf, sz);
273     return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz / sizeof(WCHAR), wszSystemIni);
274 }
275
276 /**************************************************************************
277  *                              DRIVER_TryOpenDriver32          [internal]
278  *
279  * Tries to load a 32 bit driver whose DLL's (module) name is fn
280  */
281 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCWSTR fn, LPARAM lParam2)
282 {
283     LPWINE_DRIVER       lpDrv = NULL;
284     HMODULE             hModule = 0;
285     LPWSTR              ptr;
286     LPCSTR              cause = 0;
287
288     TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
289
290     if ((ptr = strchrW(fn, ' ')) != NULL) {
291         *ptr++ = '\0';
292         while (*ptr == ' ') ptr++;
293         if (*ptr == '\0') ptr = NULL;
294     }
295
296     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
297     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
298
299     if ((hModule = LoadLibraryW(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
300
301     lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
302     if (lpDrv->lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
303
304     lpDrv->dwFlags    = 0;
305     lpDrv->hModule    = hModule;
306     lpDrv->dwDriverID = 0;
307
308     /* Win32 installable drivers must support a two phase opening scheme:
309      * + first open with NULL as lParam2 (session instance),
310      * + then do a second open with the real non null lParam2)
311      */
312     if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 0 && lParam2)
313     {
314         LPWINE_DRIVER   ret;
315
316         if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
317         {
318             cause = "load0 failed";
319             goto exit;
320         }
321         ret = DRIVER_TryOpenDriver32(fn, lParam2);
322         if (!ret)
323         {
324             CloseDriver((HDRVR)lpDrv, 0L, 0L);
325             cause = "load1 failed";
326             goto exit;
327         }
328         lpDrv->dwFlags |= WINE_GDF_SESSION;
329         return ret;
330     }
331
332     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
333     {cause = "load failed"; goto exit;}
334
335     TRACE("=> %p\n", lpDrv);
336     return lpDrv;
337  exit:
338     FreeLibrary(hModule);
339     HeapFree(GetProcessHeap(), 0, lpDrv);
340     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause);
341     return NULL;
342 }
343
344 /**************************************************************************
345  *                              OpenDriverA                     [WINMM.@]
346  *                              DrvOpenA                        [WINMM.@]
347  * (0,1,DRV_LOAD  ,0       ,0)
348  * (0,1,DRV_ENABLE,0       ,0)
349  * (0,1,DRV_OPEN  ,buf[256],0)
350  */
351 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
352 {
353     INT                 len;
354     LPWSTR              dn = NULL;
355     LPWSTR              sn = NULL;
356     HDRVR               ret = 0;
357
358     if (lpDriverName)
359     {
360         len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 );
361         dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
362         if (!dn) goto done;
363         MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len );
364     }
365
366     if (lpSectionName)
367     {
368         len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 );
369         sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
370         if (!sn) goto done;
371         MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len );
372     }
373
374     ret = OpenDriver(dn, sn, lParam);
375
376 done:
377     HeapFree(GetProcessHeap(), 0, dn);
378     HeapFree(GetProcessHeap(), 0, sn);
379     return ret;
380 }
381
382 /**************************************************************************
383  *                              OpenDriver                      [WINMM.@]
384  *                              DrvOpen                         [WINMM.@]
385  */
386 HDRVR WINAPI OpenDriver(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
387 {
388     LPWINE_DRIVER       lpDrv = NULL;
389     WCHAR               libName[MAX_PATH + 1];
390     LPCWSTR             lsn = lpSectionName;
391
392     TRACE("(%s, %s, 0x%08lx);\n", 
393           debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
394
395     DRIVER_Dump("BEFORE:");
396
397     if (lsn == NULL) {
398         static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0};
399         lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR));
400
401         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
402             goto the_end;
403         lsn = wszDrivers32;
404     }
405     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
406         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)))
407         goto the_end;
408
409     TRACE("Failed to open driver %s from system.ini file, section %s\n", 
410           debugstr_w(lpDriverName), debugstr_w(lpSectionName));
411
412 the_end:
413     TRACE("=> %p\n", lpDrv);
414
415     DRIVER_Dump("AFTER:");
416
417     return (HDRVR)lpDrv;
418 }
419
420 /**************************************************************************
421  *                      CloseDriver                             [WINMM.@]
422  *                      DrvClose                                [WINMM.@]
423  */
424 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
425 {
426     BOOL ret;
427     LPWINE_DRIVER       lpDrv;
428
429     TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
430
431     DRIVER_Dump("BEFORE:");
432
433     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
434     {
435         LPWINE_DRIVER lpDrv0;
436
437         DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
438
439         DRIVER_RemoveFromList(lpDrv);
440
441         if (lpDrv->dwFlags & WINE_GDF_SESSION)
442             FIXME("WINE_GDF_SESSION: Shouldn't happen (%p)\n", lpDrv);
443         /* if driver has an opened session instance, we have to close it too */
444         if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, &lpDrv0) == 1 &&
445             (lpDrv0->dwFlags & WINE_GDF_SESSION))
446         {
447             DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0, 0);
448             DRIVER_RemoveFromList(lpDrv0);
449             FreeLibrary(lpDrv0->hModule);
450             HeapFree(GetProcessHeap(), 0, lpDrv0);
451         }
452         FreeLibrary(lpDrv->hModule);
453
454         HeapFree(GetProcessHeap(), 0, lpDrv);
455         ret = TRUE;
456     }
457     else
458     {
459         WARN("Failed to close driver\n");
460         ret = FALSE;
461     }
462
463     DRIVER_Dump("AFTER:");
464
465     return ret;
466 }
467
468 /**************************************************************************
469  *                              GetDriverFlags          [WINMM.@]
470  * [in] hDrvr handle to the driver
471  *
472  * Returns:
473  *      0x00000000 if hDrvr is an invalid handle
474  *      0x80000000 if hDrvr is a valid 32 bit driver
475  *      0x90000000 if hDrvr is a valid 16 bit driver
476  *
477  * native WINMM doesn't return those flags
478  *      0x80000000 for a valid 32 bit driver and that's it
479  *      (I may have mixed up the two flags :-(
480  */
481 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
482 {
483     LPWINE_DRIVER       lpDrv;
484     DWORD               ret = 0;
485
486     TRACE("(%p)\n", hDrvr);
487
488     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
489         ret = WINE_GDF_EXIST | (lpDrv->dwFlags & WINE_GDF_EXTERNAL_MASK);
490     }
491     return ret;
492 }
493
494 /**************************************************************************
495  *                              GetDriverModuleHandle   [WINMM.@]
496  *                              DrvGetModuleHandle      [WINMM.@]
497  */
498 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
499 {
500     LPWINE_DRIVER       lpDrv;
501     HMODULE             hModule = 0;
502
503     TRACE("(%p);\n", hDrvr);
504
505     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
506         hModule = lpDrv->hModule;
507     }
508     TRACE("=> %p\n", hModule);
509     return hModule;
510 }
511
512 /**************************************************************************
513  *                              DefDriverProc                     [WINMM.@]
514  *                              DrvDefDriverProc                  [WINMM.@]
515  */
516 LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv,
517                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
518 {
519     switch (Msg) {
520     case DRV_LOAD:
521     case DRV_FREE:
522     case DRV_ENABLE:
523     case DRV_DISABLE:
524         return 1;
525     case DRV_INSTALL:
526     case DRV_REMOVE:
527         return DRV_SUCCESS;
528     default:
529         return 0;
530     }
531 }
532
533 /**************************************************************************
534  *                              DriverCallback                  [WINMM.@]
535  */
536 BOOL WINAPI DriverCallback(DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev,
537                            DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1,
538                            DWORD_PTR dwParam2)
539 {
540     TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX)\n",
541           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
542
543     switch (uFlags & DCB_TYPEMASK) {
544     case DCB_NULL:
545         TRACE("Null !\n");
546         break;
547     case DCB_WINDOW:
548         TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
549         PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
550         break;
551     case DCB_TASK: /* aka DCB_THREAD */
552         TRACE("Task(%04lx) !\n", dwCallBack);
553         PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
554         break;
555     case DCB_FUNCTION:
556         TRACE("Function (32 bit) !\n");
557         if (dwCallBack)
558             ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
559         break;
560     case DCB_EVENT:
561         TRACE("Event(%08lx) !\n", dwCallBack);
562         SetEvent((HANDLE)dwCallBack);
563         break;
564 #if 0
565         /* FIXME: for now only usable in mmsystem.dll16
566          * If needed, should be enabled back
567          */
568     case 6: /* I would dub it DCB_MMTHREADSIGNAL */
569         /* this is an undocumented DCB_ value used for mmThreads
570          * loword of dwCallBack contains the handle of the lpMMThd block
571          * which dwSignalCount has to be incremented
572          */     
573         if (pFnGetMMThread16)
574         {
575             WINE_MMTHREAD*      lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
576
577             TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
578             /* same as mmThreadSignal16 */
579             InterlockedIncrement(&lpMMThd->dwSignalCount);
580             SetEvent(lpMMThd->hEvent);
581             /* some other stuff on lpMMThd->hVxD */
582         }
583         break;
584 #endif
585 #if 0
586     case 4:
587         /* this is an undocumented DCB_ value for... I don't know */
588         break;
589 #endif
590     default:
591         WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
592         return FALSE;
593     }
594     TRACE("Done\n");
595     return TRUE;
596 }
597
598 /******************************************************************
599  *              DRIVER_UnloadAll
600  *
601  *
602  */
603 void    DRIVER_UnloadAll(void)
604 {
605     LPWINE_DRIVER       lpDrv;
606     LPWINE_DRIVER       lpNextDrv = NULL;
607     unsigned            count = 0;
608
609 restart:
610     EnterCriticalSection( &mmdriver_lock );
611
612     for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
613     {
614         lpNextDrv = lpDrv->lpNextItem;
615
616         /* session instances will be unloaded automatically */
617         if (!(lpDrv->dwFlags & WINE_GDF_SESSION))
618         {
619             LeaveCriticalSection( &mmdriver_lock );
620             CloseDriver((HDRVR)lpDrv, 0, 0);
621             count++;
622             /* restart from the beginning of the list */
623             goto restart;
624         }
625     }
626
627     LeaveCriticalSection( &mmdriver_lock );
628
629     TRACE("Unloaded %u drivers\n", count);
630 }