dlls/winmm/driver.c

   1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
   2
   3 /*
   4  * WINE Drivers functions
   5  *
   6  * Copyright 1994 Martin Ayotte
   7  * Copyright 1998 Marcus Meissner
   8  * Copyright 1999 Eric Pouech
   9  *
  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.
  14  *
  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.
  19  *
  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
  23  */
  24
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winnls.h"
  32 #include "winreg.h"
  33 #include "mmddk.h"
  34 #include "winemm.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(driver);
  38
  39 #define HKLM_BASE "Software\\Microsoft\\Windows NT\\CurrentVersion"
  40
  41 static LPWINE_DRIVER   lpDrvItemList  /* = NULL */;
  42
  43 WINE_MMTHREAD*  (*pFnGetMMThread16)(UINT16 h) /* = NULL */;
  44 LPWINE_DRIVER   (*pFnOpenDriver16)(LPCSTR,LPCSTR,LPARAM) /* = NULL */;
  45 LRESULT         (*pFnCloseDriver16)(UINT16,LPARAM,LPARAM) /* = NULL */;
  46 LRESULT         (*pFnSendMessage16)(UINT16,UINT,LPARAM,LPARAM) /* = NULL */;
  47
  48 /**************************************************************************
  49  *                      DRIVER_GetNumberOfModuleRefs            [internal]
  50  *
  51  * Returns the number of open drivers which share the same module.
  52  */
  53 static  unsigned DRIVER_GetNumberOfModuleRefs(HMODULE hModule, WINE_DRIVER** found)
  54 {
  55     LPWINE_DRIVER       lpDrv;
  56     unsigned            count = 0;
  57
  58     if (found) *found = NULL;
  59     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
  60     {
  61         if (!(lpDrv->dwFlags & WINE_GDF_16BIT) && lpDrv->d.d32.hModule == hModule)
  62         {
  63             if (found && !*found) *found = lpDrv;
  64             count++;
  65         }
  66     }
  67     return count;
  68 }
  69
  70 /**************************************************************************
  71  *                              DRIVER_FindFromHDrvr            [internal]
  72  *
  73  * From a hDrvr being 32 bits, returns the WINE internal structure.
  74  */
  75 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
  76 {
  77     LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
  78
  79     if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
  80         return d;
  81     }
  82     return NULL;
  83 }
  84
  85 /**************************************************************************
  86  *                              DRIVER_SendMessage              [internal]
  87  */
  88 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
  89                                          LPARAM lParam1, LPARAM lParam2)
  90 {
  91     LRESULT             ret = 0;
  92
  93     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
  94         /* no need to check mmsystem presence: the driver must have been opened as a 16 bit one,
  95          */
  96         if (pFnSendMessage16)
  97             ret = pFnSendMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
  98     } else {
  99         TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
 100               lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
 101         ret = lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
 102         TRACE("After  call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
 103               lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2, ret);
 104     }
 105     return ret;
 106 }
 107
 108 /**************************************************************************
 109  *                              SendDriverMessage               [WINMM.@]
 110  *                              DrvSendMessage                  [WINMM.@]
 111  */
 112 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
 113                                  LPARAM lParam2)
 114 {
 115     LPWINE_DRIVER       lpDrv;
 116     LRESULT             retval = 0;
 117
 118     TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
 119
 120     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
 121         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
 122     } else {
 123         WARN("Bad driver handle %p\n", hDriver);
 124     }
 125     TRACE("retval = %ld\n", retval);
 126
 127     return retval;
 128 }
 129
 130 /**************************************************************************
 131  *                              DRIVER_RemoveFromList           [internal]
 132  *
 133  * Generates all the logic to handle driver closure / deletion
 134  * Removes a driver struct to the list of open drivers.
 135  */
 136 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
 137 {
 138     if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
 139         /* last of this driver in list ? */
 140         if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 1) {
 141             DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
 142             DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
 143         }
 144     }
 145
 146     if (lpDrv->lpPrevItem)
 147         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
 148     else
 149         lpDrvItemList = lpDrv->lpNextItem;
 150     if (lpDrv->lpNextItem)
 151         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
 152     /* trash magic number */
 153     lpDrv->dwMagic ^= 0xa5a5a5a5;
 154
 155     return TRUE;
 156 }
 157
 158 /**************************************************************************
 159  *                              DRIVER_AddToList                [internal]
 160  *
 161  * Adds a driver struct to the list of open drivers.
 162  * Generates all the logic to handle driver creation / open.
 163  */
 164 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
 165 {
 166     lpNewDrv->dwMagic = WINE_DI_MAGIC;
 167     /* First driver to be loaded for this module, need to load correctly the module */
 168     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 169         /* first of this driver in list ? */
 170         if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->d.d32.hModule, NULL) == 0) {
 171             if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
 172                 TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 173                 return FALSE;
 174             }
 175             /* returned value is not checked */
 176             DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
 177         }
 178     }
 179
 180     lpNewDrv->lpNextItem = NULL;
 181     if (lpDrvItemList == NULL) {
 182         lpDrvItemList = lpNewDrv;
 183         lpNewDrv->lpPrevItem = NULL;
 184     } else {
 185         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
 186         while (lpDrv->lpNextItem != NULL)
 187             lpDrv = lpDrv->lpNextItem;
 188
 189         lpDrv->lpNextItem = lpNewDrv;
 190         lpNewDrv->lpPrevItem = lpDrv;
 191     }
 192
 193     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 194         /* Now just open a new instance of a driver on this module */
 195         lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
 196
 197         if (lpNewDrv->d.d32.dwDriverID == 0) {
 198             TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 199             DRIVER_RemoveFromList(lpNewDrv);
 200             return FALSE;
 201         }
 202     }
 203     return TRUE;
 204 }
 205
 206 /**************************************************************************
 207  *                              DRIVER_GetLibName               [internal]
 208  *
 209  */
 210 BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
 211 {
 212     HKEY        hKey, hSecKey;
 213     DWORD       bufLen, lRet;
 214
 215     lRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
 216     if (lRet == ERROR_SUCCESS) {
 217         lRet = RegOpenKeyExA(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
 218         if (lRet == ERROR_SUCCESS) {
 219             lRet = RegQueryValueExA(hSecKey, keyName, 0, 0, buf, &bufLen);
 220             RegCloseKey( hSecKey );
 221         }
 222         RegCloseKey( hKey );
 223     }
 224     if (lRet == ERROR_SUCCESS) return TRUE;
 225     /* default to system.ini if we can't find it in the registry,
 226      * to support native installations where system.ini is still used */
 227     return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI");
 228 }
 229
 230 /**************************************************************************
 231  *                              DRIVER_TryOpenDriver32          [internal]
 232  *
 233  * Tries to load a 32 bit driver whose DLL's (module) name is fn
 234  */
 235 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
 236 {
 237     LPWINE_DRIVER       lpDrv = NULL;
 238     HMODULE             hModule = 0;
 239     LPSTR               ptr;
 240     LPCSTR              cause = 0;
 241
 242     TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
 243
 244     if ((ptr = strchr(fn, ' ')) != NULL) {
 245         *ptr++ = '\0';
 246         while (*ptr == ' ') ptr++;
 247         if (*ptr == '\0') ptr = NULL;
 248     }
 249
 250     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 251     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 252
 253     if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
 254
 255     lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
 256     if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
 257
 258     lpDrv->dwFlags          = 0;
 259     lpDrv->d.d32.hModule    = hModule;
 260     lpDrv->d.d32.dwDriverID = 0;
 261
 262     /* Win32 installable drivers must support a two phase opening scheme:
 263      * + first open with NULL as lParam2 (session instance),
 264      * + then do a second open with the real non null lParam2)
 265      */
 266     if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, NULL) == 0 && lParam2)
 267     {
 268         LPWINE_DRIVER   ret;
 269
 270         if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
 271         {
 272             cause = "load0 failed";
 273             goto exit;
 274         }
 275         ret = DRIVER_TryOpenDriver32(fn, lParam2);
 276         if (!ret)
 277         {
 278             CloseDriver((HDRVR)lpDrv, 0L, 0L);
 279             cause = "load1 failed";
 280             goto exit;
 281         }
 282         return ret;
 283     }
 284
 285     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
 286     {cause = "load failed"; goto exit;}
 287
 288     TRACE("=> %p\n", lpDrv);
 289     return lpDrv;
 290  exit:
 291     FreeLibrary(hModule);
 292     HeapFree(GetProcessHeap(), 0, lpDrv);
 293     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
 294     return NULL;
 295 }
 296
 297 /**************************************************************************
 298  *                              OpenDriverA                     [WINMM.@]
 299  *                              DrvOpenA                        [WINMM.@]
 300  * (0,1,DRV_LOAD  ,0       ,0)
 301  * (0,1,DRV_ENABLE,0       ,0)
 302  * (0,1,DRV_OPEN  ,buf[256],0)
 303  */
 304 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
 305 {
 306     LPWINE_DRIVER       lpDrv = NULL;
 307     char                libName[128];
 308     LPCSTR              lsn = lpSectionName;
 309
 310     TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
 311
 312     if (lsn == NULL) {
 313         lstrcpynA(libName, lpDriverName, sizeof(libName));
 314
 315         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 316             goto the_end;
 317         lsn = "Drivers32";
 318     }
 319     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
 320         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 321         goto the_end;
 322
 323     /* now we will try a 16 bit driver (and add all the glue to make it work... which
 324      * is located in our mmsystem implementation)
 325      * so ensure, we can load our mmsystem, otherwise just fail
 326      */
 327     WINMM_CheckForMMSystem();
 328     if (pFnOpenDriver16 &&
 329         (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam2)))
 330     {
 331         if (DRIVER_AddToList(lpDrv, 0, lParam2)) goto the_end;
 332         HeapFree(GetProcessHeap(), 0, lpDrv);
 333     }
 334     TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
 335     return 0;
 336
 337  the_end:
 338     if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
 339     return (HDRVR)lpDrv;
 340 }
 341
 342 /**************************************************************************
 343  *                              OpenDriver                      [WINMM.@]
 344  *                              DrvOpen                         [WINMM.@]
 345  */
 346 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
 347 {
 348     INT                 len;
 349     LPSTR               dn = NULL;
 350     LPSTR               sn = NULL;
 351     HDRVR               ret;
 352
 353     if (lpDriverName)
 354     {
 355         len = WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, NULL, 0, NULL, NULL );
 356         dn = HeapAlloc( GetProcessHeap(), 0, len );
 357         if (!dn) return 0;
 358         WideCharToMultiByte( CP_ACP, 0, lpDriverName, -1, dn, len, NULL, NULL );
 359     }
 360
 361     if (lpSectionName)
 362     {
 363         len = WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, NULL, 0, NULL, NULL );
 364         sn = HeapAlloc( GetProcessHeap(), 0, len );
 365         if (!sn) return 0;
 366         WideCharToMultiByte( CP_ACP, 0, lpSectionName, -1, sn, len, NULL, NULL );
 367     }
 368
 369     ret = OpenDriverA(dn, sn, lParam);
 370
 371     if (dn) HeapFree(GetProcessHeap(), 0, dn);
 372     if (sn) HeapFree(GetProcessHeap(), 0, sn);
 373     return ret;
 374 }
 375
 376 /**************************************************************************
 377  *                      CloseDriver                             [WINMM.@]
 378  *                      DrvClose                                [WINMM.@]
 379  */
 380 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 381 {
 382     LPWINE_DRIVER       lpDrv;
 383
 384     TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 385
 386     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
 387     {
 388         if (lpDrv->dwFlags & WINE_GDF_16BIT)
 389         {
 390             if (pFnCloseDriver16)
 391                 pFnCloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
 392         }
 393         else
 394         {
 395             DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
 396             lpDrv->d.d32.dwDriverID = 0;
 397         }
 398         if (DRIVER_RemoveFromList(lpDrv)) {
 399             if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
 400             {
 401                 LPWINE_DRIVER       lpDrv0;
 402
 403                 /* if driver has an opened session instance, we have to close it too */
 404                 if (DRIVER_GetNumberOfModuleRefs(lpDrv->d.d32.hModule, &lpDrv0) == 1)
 405                 {
 406                     DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0L, 0L);
 407                     lpDrv0->d.d32.dwDriverID = 0;
 408                     DRIVER_RemoveFromList(lpDrv0);
 409                     FreeLibrary(lpDrv0->d.d32.hModule);
 410                     HeapFree(GetProcessHeap(), 0, lpDrv0);
 411                 }
 412                 FreeLibrary(lpDrv->d.d32.hModule);
 413             }
 414             HeapFree(GetProcessHeap(), 0, lpDrv);
 415             return TRUE;
 416         }
 417     }
 418     WARN("Failed to close driver\n");
 419     return FALSE;
 420 }
 421
 422 /**************************************************************************
 423  *                              GetDriverFlags          [WINMM.@]
 424  * [in] hDrvr handle to the driver
 425  *
 426  * Returns:
 427  *      0x00000000 if hDrvr is an invalid handle
 428  *      0x80000000 if hDrvr is a valid 32 bit driver
 429  *      0x90000000 if hDrvr is a valid 16 bit driver
 430  *
 431  * native WINMM doesn't return those flags
 432  *      0x80000000 for a valid 32 bit driver and that's it
 433  *      (I may have mixed up the two flags :-(
 434  */
 435 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
 436 {
 437     LPWINE_DRIVER       lpDrv;
 438     DWORD               ret = 0;
 439
 440     TRACE("(%p)\n", hDrvr);
 441
 442     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 443         ret = WINE_GDF_EXIST | lpDrv->dwFlags;
 444     }
 445     return ret;
 446 }
 447
 448 /**************************************************************************
 449  *                              GetDriverModuleHandle   [WINMM.@]
 450  *                              DrvGetModuleHandle      [WINMM.@]
 451  */
 452 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
 453 {
 454     LPWINE_DRIVER       lpDrv;
 455     HMODULE             hModule = 0;
 456
 457     TRACE("(%p);\n", hDrvr);
 458
 459     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 460         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
 461             hModule = lpDrv->d.d32.hModule;
 462     }
 463     TRACE("=> %p\n", hModule);
 464     return hModule;
 465 }
 466
 467 /**************************************************************************
 468  *                              DefDriverProc                     [WINMM.@]
 469  *                              DrvDefDriverProc                  [WINMM.@]
 470  */
 471 LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
 472                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
 473 {
 474     switch (Msg) {
 475     case DRV_LOAD:
 476     case DRV_FREE:
 477     case DRV_ENABLE:
 478     case DRV_DISABLE:
 479         return 1;
 480     case DRV_INSTALL:
 481     case DRV_REMOVE:
 482         return DRV_SUCCESS;
 483     default:
 484         return 0;
 485     }
 486 }
 487
 488 /**************************************************************************
 489  *                              DriverCallback                  [WINMM.@]
 490  */
 491 BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
 492                            UINT wMsg, DWORD dwUser, DWORD dwParam1,
 493                            DWORD dwParam2)
 494 {
 495     TRACE("(%08lX, %04X, %p, %04X, %08lX, %08lX, %08lX); !\n",
 496           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
 497
 498     switch (uFlags & DCB_TYPEMASK) {
 499     case DCB_NULL:
 500         TRACE("Null !\n");
 501         if (dwCallBack)
 502             WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
 503         break;
 504     case DCB_WINDOW:
 505         TRACE("Window(%04lX) handle=%p!\n", dwCallBack, hDev);
 506         PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
 507         break;
 508     case DCB_TASK: /* aka DCB_THREAD */
 509         TRACE("Task(%04lx) !\n", dwCallBack);
 510         PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
 511         break;
 512     case DCB_FUNCTION:
 513         TRACE("Function (32 bit) !\n");
 514         ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
 515         break;
 516     case DCB_EVENT:
 517         TRACE("Event(%08lx) !\n", dwCallBack);
 518         SetEvent((HANDLE)dwCallBack);
 519         break;
 520     case 6: /* I would dub it DCB_MMTHREADSIGNAL */
 521         /* this is an undocumented DCB_ value used for mmThreads
 522          * loword of dwCallBack contains the handle of the lpMMThd block
 523          * which dwSignalCount has to be incremented
 524          */
 525         if (pFnGetMMThread16)
 526         {
 527             WINE_MMTHREAD*      lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
 528
 529             TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
 530             /* same as mmThreadSignal16 */
 531             InterlockedIncrement(&lpMMThd->dwSignalCount);
 532             SetEvent(lpMMThd->hEvent);
 533             /* some other stuff on lpMMThd->hVxD */
 534         }
 535         break;
 536 #if 0
 537     case 4:
 538         /* this is an undocumented DCB_ value for... I don't know */
 539         break;
 540 #endif
 541     default:
 542         WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
 543         return FALSE;
 544     }
 545     TRACE("Done\n");
 546     return TRUE;
 547 }
 548
 549 /******************************************************************
 550  *              DRIVER_UnloadAll
 551  *
 552  *
 553  */
 554 void    DRIVER_UnloadAll(void)
 555 {
 556     LPWINE_DRIVER       lpDrv;
 557     LPWINE_DRIVER       lpNextDrv = NULL;
 558     unsigned            count = 0;
 559
 560     for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
 561     {
 562         lpNextDrv = lpDrv->lpNextItem;
 563         CloseDriver((HDRVR)lpDrv, 0, 0);
 564         count++;
 565     }
 566     TRACE("Unloaded %u drivers\n", count);
 567 }