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