git.oblomov.eu Git - wine/blob - 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
  11 #include <string.h>
  12 #include "heap.h"
  13 #include "windef.h"
  14 #include "mmddk.h"
  15 #include "winemm.h"
  16 #include "wine/winbase16.h"
  17 #include "debugtools.h"
  18
  19 DEFAULT_DEBUG_CHANNEL(driver);
  20
  21 static LPWINE_DRIVER    lpDrvItemList = NULL;
  22
  23 /* TODO list :
  24  *      - LoadModule count and clean up is not handled correctly (it's not a
  25  *        problem as long as FreeLibrary is not working correctly)
  26  */
  27
  28 /**************************************************************************
  29  *                      DRIVER_GetNumberOfModuleRefs            [internal]
  30  *
  31  * Returns the number of open drivers which share the same module.
  32  */
  33 static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
  34 {
  35     LPWINE_DRIVER       lpDrv;
  36     WORD                count = 0;
  37
  38     if (lpNewDrv->dwFlags & WINE_GDF_16BIT) ERR("OOOch\n");
  39     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
  40         if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
  41             lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
  42             count++;
  43         }
  44     }
  45     return count;
  46 }
  47
  48 /**************************************************************************
  49  *                              DRIVER_FindFromHDrvr            [internal]
  50  *
  51  * From a hDrvr being 32 bits, returns the WINE internal structure.
  52  */
  53 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
  54 {
  55     LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
  56
  57     if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
  58         return d;
  59     }
  60     return NULL;
  61 }
  62
  63 /**************************************************************************
  64  *                              DRIVER_MapMsg32To16             [internal]
  65  *
  66  * Map a 32 bit driver message to a 16 bit driver message.
  67  *  1 : ok, some memory allocated, need to call DRIVER_UnMapMsg32To16
  68  *  0 : ok, no memory allocated
  69  * -1 : ko, unknown message
  70  * -2 : ko, memory problem
  71  */
  72 static int DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
  73 {
  74     int ret = -1;
  75
  76     switch (wMsg) {
  77     case DRV_LOAD:
  78     case DRV_ENABLE:
  79     case DRV_DISABLE:
  80     case DRV_FREE:
  81     case DRV_QUERYCONFIGURE:
  82     case DRV_REMOVE:
  83     case DRV_EXITSESSION:
  84     case DRV_EXITAPPLICATION:
  85     case DRV_POWER:
  86     case DRV_CLOSE:     /* should be 0/0 */
  87     case DRV_OPEN:      /* pass through */
  88         /* lParam1 and lParam2 are not used */
  89         ret = 0;
  90         break;
  91         break;
  92     case DRV_CONFIGURE:
  93     case DRV_INSTALL:
  94         /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
  95          * lParam2 is a pointer to DRVCONFIGINFO
  96          */
  97         if (*lParam2) {
  98             LPDRVCONFIGINFO16 dci16 = HeapAlloc( GetProcessHeap(), 0, sizeof(*dci16) );
  99             LPDRVCONFIGINFO     dci32 = (LPDRVCONFIGINFO)(*lParam2);
 100
 101             if (dci16) {
 102                 LPSTR str1;
 103
 104                 dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
 105
 106                 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL)
 107                 {
 108                     dci16->lpszDCISectionName = MapLS( str1 );
 109                 } else {
 110                     return -2;
 111                 }
 112                 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL)
 113                 {
 114                     dci16->lpszDCIAliasName = MapLS( str1 );
 115                 } else {
 116                     return -2;
 117                 }
 118             } else {
 119                 return -2;
 120             }
 121             *lParam2 = MapLS( dci16 );
 122             ret = 1;
 123         } else {
 124             ret = 0;
 125         }
 126         break;
 127     default:
 128         if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
 129            FIXME("Unknown message 0x%04x\n", wMsg);
 130         }
 131         ret = 0;
 132     }
 133     return ret;
 134 }
 135
 136 /**************************************************************************
 137  *                              DRIVER_UnMapMsg32To16           [internal]
 138  *
 139  * UnMap a 32 bit driver message to a 16 bit driver message.
 140  *  0 : ok
 141  * -1 : ko
 142  * -2 : ko, memory problem
 143  */
 144 static int DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
 145 {
 146     int ret = -1;
 147
 148     switch (wMsg) {
 149     case DRV_LOAD:
 150     case DRV_ENABLE:
 151     case DRV_DISABLE:
 152     case DRV_FREE:
 153     case DRV_QUERYCONFIGURE:
 154     case DRV_REMOVE:
 155     case DRV_EXITSESSION:
 156     case DRV_EXITAPPLICATION:
 157     case DRV_POWER:
 158     case DRV_OPEN:
 159     case DRV_CLOSE:
 160         /* lParam1 and lParam2 are not used */
 161         break;
 162     case DRV_CONFIGURE:
 163     case DRV_INSTALL:
 164         /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
 165         if (lParam2) {
 166             LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
 167             HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCISectionName) );
 168             HeapFree( GetProcessHeap(), 0, MapSL(dci16->lpszDCIAliasName) );
 169             UnMapLS( lParam2 );
 170             UnMapLS( dci16->lpszDCISectionName );
 171             UnMapLS( dci16->lpszDCIAliasName );
 172             HeapFree( GetProcessHeap(), 0, dci16 );
 173         }
 174         ret = 0;
 175         break;
 176     default:
 177         if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
 178             FIXME("Unknown message 0x%04x\n", wMsg);
 179         }
 180         ret = 0;
 181     }
 182     return ret;
 183 }
 184
 185 /**************************************************************************
 186  *                              DRIVER_SendMessage              [internal]
 187  */
 188 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
 189                                         LPARAM lParam1, LPARAM lParam2)
 190 {
 191     if (lpDrv->dwFlags & WINE_GDF_16BIT) {
 192         LRESULT         ret;
 193         int             map = 0;
 194         TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
 195               lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
 196
 197         if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
 198             ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
 199             if (map == 1)
 200                 DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
 201         } else {
 202             ret = 0;
 203         }
 204         return ret;
 205     }
 206     TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
 207           lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
 208     return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
 209 }
 210
 211 /**************************************************************************
 212  *                              SendDriverMessage               [WINMM.@]
 213  *                              DrvSendMessage                  [WINMM.@]
 214  */
 215 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
 216                                  LPARAM lParam2)
 217 {
 218     LPWINE_DRIVER       lpDrv;
 219     LRESULT             retval = 0;
 220
 221     TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
 222
 223     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
 224         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
 225     } else {
 226         WARN("Bad driver handle %u\n", hDriver);
 227     }
 228     TRACE("retval = %ld\n", retval);
 229
 230     return retval;
 231 }
 232
 233 /**************************************************************************
 234  *                              DRIVER_RemoveFromList           [internal]
 235  *
 236  * Generates all the logic to handle driver closure / deletion
 237  * Removes a driver struct to the list of open drivers.
 238  */
 239 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
 240 {
 241     if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
 242         if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
 243             DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
 244             DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
 245         }
 246     }
 247
 248     if (lpDrv->lpPrevItem)
 249         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
 250     else
 251         lpDrvItemList = lpDrv->lpNextItem;
 252     if (lpDrv->lpNextItem)
 253         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
 254
 255     return TRUE;
 256 }
 257
 258 /**************************************************************************
 259  *                              DRIVER_AddToList                [internal]
 260  *
 261  * Adds a driver struct to the list of open drivers.
 262  * Generates all the logic to handle driver creation / open.
 263  */
 264 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
 265 {
 266     lpNewDrv->dwMagic = WINE_DI_MAGIC;
 267     /* First driver to be loaded for this module, need to load correctly the module */
 268     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 269         if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
 270             if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
 271                 TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 272                 return FALSE;
 273             }
 274             /* returned value is not checked */
 275             DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
 276         }
 277     }
 278
 279     lpNewDrv->lpNextItem = NULL;
 280     if (lpDrvItemList == NULL) {
 281         lpDrvItemList = lpNewDrv;
 282         lpNewDrv->lpPrevItem = NULL;
 283     } else {
 284         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
 285         while (lpDrv->lpNextItem != NULL)
 286             lpDrv = lpDrv->lpNextItem;
 287
 288         lpDrv->lpNextItem = lpNewDrv;
 289         lpNewDrv->lpPrevItem = lpDrv;
 290     }
 291
 292     if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
 293         /* Now just open a new instance of a driver on this module */
 294         lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
 295
 296         if (lpNewDrv->d.d32.dwDriverID == 0) {
 297             TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
 298             DRIVER_RemoveFromList(lpNewDrv);
 299             return FALSE;
 300         }
 301     }
 302     return TRUE;
 303 }
 304
 305 /**************************************************************************
 306  *                              DRIVER_GetLibName               [internal]
 307  *
 308  */
 309 BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
 310 {
 311     /* should also do some registry diving */
 312     return GetPrivateProfileStringA(sectName, keyName, "", buf, sz, "SYSTEM.INI");
 313 }
 314
 315 /**************************************************************************
 316  *                              DRIVER_TryOpenDriver32          [internal]
 317  *
 318  * Tries to load a 32 bit driver whose DLL's (module) name is fn
 319  */
 320 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
 321 {
 322     LPWINE_DRIVER       lpDrv = NULL;
 323     HMODULE             hModule = 0;
 324     LPSTR               ptr;
 325     LPCSTR              cause = 0;
 326
 327     TRACE("(%s, %08lX);\n", debugstr_a(fn), lParam2);
 328
 329     if ((ptr = strchr(fn, ' ')) != NULL) {
 330         *ptr++ = '\0';
 331         while (*ptr == ' ') ptr++;
 332         if (*ptr == '\0') ptr = NULL;
 333     }
 334
 335     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 336     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 337
 338     if ((hModule = LoadLibraryA(fn)) == 0) {cause = "Not a 32 bit lib"; goto exit;}
 339
 340     lpDrv->d.d32.lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
 341     if (lpDrv->d.d32.lpDrvProc == NULL) {cause = "no DriverProc"; goto exit;}
 342
 343     lpDrv->dwFlags          = 0;
 344     lpDrv->d.d32.hModule    = hModule;
 345     lpDrv->d.d32.dwDriverID = 0;
 346
 347     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2)) {cause = "load failed"; goto exit;}
 348
 349     TRACE("=> %p\n", lpDrv);
 350     return lpDrv;
 351  exit:
 352     FreeLibrary(hModule);
 353     HeapFree(GetProcessHeap(), 0, lpDrv);
 354     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
 355     return NULL;
 356 }
 357
 358 /**************************************************************************
 359  *                              DRIVER_TryOpenDriver16          [internal]
 360  *
 361  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
 362  */
 363 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
 364 {
 365     LPWINE_DRIVER       lpDrv = NULL;
 366     LPCSTR              cause = 0;
 367
 368     TRACE("(%s, %08lX);\n", debugstr_a(sn), lParam2);
 369
 370     lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 371     if (lpDrv == NULL) {cause = "OOM"; goto exit;}
 372
 373     /* FIXME: shall we do some black magic here on sn ?
 374      *  drivers32 => drivers
 375      *  mci32 => mci
 376      * ...
 377      */
 378     lpDrv->d.d16.hDriver16 = OpenDriver16(fn, sn, lParam2);
 379     if (lpDrv->d.d16.hDriver16 == 0) {cause = "Not a 16 bit driver"; goto exit;}
 380     lpDrv->dwFlags = WINE_GDF_16BIT;
 381
 382     if (!DRIVER_AddToList(lpDrv, 0, lParam2)) {cause = "load failed"; goto exit;}
 383
 384     TRACE("=> %p\n", lpDrv);
 385     return lpDrv;
 386  exit:
 387     HeapFree(GetProcessHeap(), 0, lpDrv);
 388     TRACE("Unable to load 32 bit module %s: %s\n", debugstr_a(fn), cause);
 389     return NULL;
 390 }
 391
 392 /**************************************************************************
 393  *                              OpenDriverA                     [WINMM.@]
 394  *                              DrvOpenA                        [WINMM.@]
 395  * (0,1,DRV_LOAD  ,0       ,0)
 396  * (0,1,DRV_ENABLE,0       ,0)
 397  * (0,1,DRV_OPEN  ,buf[256],0)
 398  */
 399 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
 400 {
 401     LPWINE_DRIVER       lpDrv = NULL;
 402     char                libName[128];
 403     LPCSTR              lsn = lpSectionName;
 404
 405     TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
 406
 407     if (lsn == NULL) {
 408         lstrcpynA(libName, lpDriverName, sizeof(libName));
 409
 410         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 411             goto the_end;
 412         lsn = "Drivers32";
 413     }
 414     if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
 415         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
 416         goto the_end;
 417
 418     if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
 419         TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
 420  the_end:
 421     if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
 422     return (DWORD)lpDrv;
 423 }
 424
 425 /**************************************************************************
 426  *                              OpenDriver                      [WINMM.@]
 427  *                              DrvOpen                         [WINMM.@]
 428  */
 429 HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
 430 {
 431     LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
 432     LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
 433     HDRVR               ret = OpenDriverA(dn, sn, lParam);
 434
 435     if (dn) HeapFree(GetProcessHeap(), 0, dn);
 436     if (sn) HeapFree(GetProcessHeap(), 0, sn);
 437     return ret;
 438 }
 439
 440 /**************************************************************************
 441  *                      CloseDriver                             [WINMM.@]
 442  *                      DrvClose                                [WINMM.@]
 443  */
 444 LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 445 {
 446     LPWINE_DRIVER       lpDrv;
 447
 448     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 449
 450     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 451         if (lpDrv->dwFlags & WINE_GDF_16BIT)
 452             CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
 453         else
 454             DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
 455         if (DRIVER_RemoveFromList(lpDrv)) {
 456             HeapFree(GetProcessHeap(), 0, lpDrv);
 457             return TRUE;
 458         }
 459     }
 460     WARN("Failed to close driver\n");
 461     return FALSE;
 462 }
 463
 464 /**************************************************************************
 465  *                              GetDriverFlags          [WINMM.@]
 466  * [in] hDrvr handle to the driver
 467  *
 468  * Returns:
 469  *      0x00000000 if hDrvr is an invalid handle
 470  *      0x80000000 if hDrvr is a valid 32 bit driver
 471  *      0x90000000 if hDrvr is a valid 16 bit driver
 472  *
 473  * native WINMM doesn't return those flags
 474  *      0x80000000 for a valid 32 bit driver and that's it
 475  *      (I may have mixed up the two flags :-(
 476  */
 477 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
 478 {
 479     LPWINE_DRIVER       lpDrv;
 480     DWORD               ret = 0;
 481
 482     TRACE("(%04x)\n", hDrvr);
 483
 484     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 485         ret = WINE_GDF_EXIST | lpDrv->dwFlags;
 486     }
 487     return ret;
 488 }
 489
 490 /**************************************************************************
 491  *                              GetDriverModuleHandle   [WINMM.@]
 492  *                              DrvGetModuleHandle      [WINMM.@]
 493  */
 494 HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
 495 {
 496     LPWINE_DRIVER       lpDrv;
 497     HMODULE             hModule = 0;
 498
 499     TRACE("(%04x);\n", hDrvr);
 500
 501     if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
 502         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
 503             hModule = lpDrv->d.d32.hModule;
 504     }
 505     TRACE("=> %04x\n", hModule);
 506     return hModule;
 507 }
 508
 509 /**************************************************************************
 510  *                              DrvOpen                 [MMSYSTEM.1100]
 511  */
 512 HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
 513 {
 514     return OpenDriver16(lpDriverName, lpSectionName, lParam);
 515 }
 516
 517 /**************************************************************************
 518  *                              DrvClose                [MMSYSTEM.1101]
 519  */
 520 LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
 521 {
 522     return CloseDriver16(hDrv, lParam1, lParam2);
 523 }
 524
 525 /**************************************************************************
 526  *                              DrvSendMessage          [MMSYSTEM.1102]
 527  */
 528 LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
 529                                 LPARAM lParam2)
 530 {
 531     return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
 532 }
 533
 534 /**************************************************************************
 535  *                              DrvGetModuleHandle      [MMSYSTEM.1103]
 536  */
 537 HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
 538 {
 539     return GetDriverModuleHandle16(hDrv);
 540 }
 541
 542 /**************************************************************************
 543  *                              DrvDefDriverProc        [MMSYSTEM.1104]
 544  */
 545 LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
 546                                   DWORD dwParam1, DWORD dwParam2)
 547 {
 548     return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
 549 }
 550
 551 /**************************************************************************
 552  *                              DefDriverProc                     [WINMM.@]
 553  *                              DrvDefDriverProc                  [WINMM.@]
 554  */
 555 LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
 556                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
 557 {
 558     switch (Msg) {
 559     case DRV_LOAD:
 560     case DRV_FREE:
 561     case DRV_ENABLE:
 562     case DRV_DISABLE:
 563         return 1;
 564     case DRV_INSTALL:
 565     case DRV_REMOVE:
 566         return DRV_SUCCESS;
 567     default:
 568         return 0;
 569     }
 570 }
 571
 572 /**************************************************************************
 573  *                              DriverProc                      [MMSYSTEM.6]
 574  */
 575 LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
 576                             DWORD dwParam1, DWORD dwParam2)
 577 {
 578     TRACE("dwDevID=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\n",
 579           dwDevID, hDrv, wMsg, dwParam1, dwParam2);
 580
 581     return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
 582 }
 583