Ignore:
Timestamp:
Sep 5, 2001, 12:30:21 PM (24 years ago)
Author:
bird
Message:

Added Missing $Id:$ keyword.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/driver.c

    r5433 r6639  
    11/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    22
    3 /*
     3/* $Id: driver.c,v 1.2 2001-09-05 10:30:21 bird Exp $
     4 *
    45 * WINE Drivers functions
    56 *
    … …  
    3233DEFAULT_DEBUG_CHANNEL(driver);
    3334
    34 static LPWINE_DRIVER    lpDrvItemList = NULL;
     35static LPWINE_DRIVER    lpDrvItemList = NULL;
    3536
    3637/* TODO list :
    37  *      - LoadModule count and clean up is not handled correctly (it's not a
    38  *        problem as long as FreeLibrary is not working correctly)
    39  */
    40 
    41 /**************************************************************************
    42  *                      DRIVER_GetNumberOfModuleRefs            [internal]
     38 *  - LoadModule count and clean up is not handled correctly (it's not a
     39 *    problem as long as FreeLibrary is not working correctly)
     40 */
     41
     42/**************************************************************************
     43 *          DRIVER_GetNumberOfModuleRefs        [internal]
    4344 *
    4445 * Returns the number of open drivers which share the same module.
    4546 */
    46 static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
    47 {
    48     LPWINE_DRIVER       lpDrv;
    49     WORD                count = 0;
     47static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
     48{
     49    LPWINE_DRIVER   lpDrv;
     50    WORD        count = 0;
    5051
    5152    if (lpNewDrv->dwFlags & WINE_GDF_16BIT) ERR("OOOch");
    5253    for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
    53         if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
    54             lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
    55             count++;
    56         }
     54    if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
     55        lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
     56        count++;
     57    }
    5758    }
    5859    return count;
    … …  
    6061
    6162/**************************************************************************
    62  *                              DRIVER_FindFromHDrvr            [internal]
    63  * 
     63 *              DRIVER_FindFromHDrvr        [internal]
     64 *
    6465 * From a hDrvr being 32 bits, returns the WINE internal structure.
    6566 */
    66 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
    67 {   
    68     LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
     67LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
     68{
     69    LPWINE_DRIVER   d = (LPWINE_DRIVER)hDrvr;
    6970
    7071    if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
    71         return d;
     72    return d;
    7273    }
    7374    return NULL;
    … …  
    7677#ifndef __WIN32OS2__
    7778/**************************************************************************
    78  *                              DRIVER_MapMsg32To16             [internal]
     79 *              DRIVER_MapMsg32To16     [internal]
    7980 *
    8081 * Map a 32 bit driver message to a 16 bit driver message.
    … …  
    8687static int DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
    8788{
    88     int ret = -1;
    89    
     89    int ret = -1;
     90
    9091    switch (wMsg) {
    9192    case DRV_LOAD:
    … …  
    9697    case DRV_REMOVE:
    9798    case DRV_EXITSESSION:
    98     case DRV_EXITAPPLICATION:   
     99    case DRV_EXITAPPLICATION:
    99100    case DRV_POWER:
    100     case DRV_CLOSE:     /* should be 0/0 */
    101     case DRV_OPEN:      /* pass thru */
    102         /* lParam1 and lParam2 are not used */
    103         ret = 0;
    104         break;
    105         break;
     101    case DRV_CLOSE: /* should be 0/0 */
     102    case DRV_OPEN:  /* pass thru */
     103    /* lParam1 and lParam2 are not used */
     104    ret = 0;
     105    break;
     106    break;
    106107    case DRV_CONFIGURE:
    107108    case DRV_INSTALL:
    108         /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
    109          * lParam2 is a pointer to DRVCONFIGINFO
    110         */
    111         if (*lParam2) {
    112             LPDRVCONFIGINFO16   dci16 = (LPDRVCONFIGINFO16)SEGPTR_ALLOC(sizeof(DRVCONFIGINFO16));
    113             LPDRVCONFIGINFO     dci32 = (LPDRVCONFIGINFO)(*lParam2);
    114            
    115             if (dci16) {
    116                 LPSTR   str1, str2;
    117                
    118                 dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
    119                
    120                 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL &&
    121                     (str2 = SEGPTR_STRDUP(str1)) != NULL) {
    122                     dci16->lpszDCISectionName = SEGPTR_GET(str2);
    123                     if (!HeapFree(GetProcessHeap(), 0, str1))
    124                         FIXME("bad free line=%d\n", __LINE__);
    125                 } else {
    126                     return -2;
    127                 }
    128                 if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL &&
    129                     (str2 = SEGPTR_STRDUP(str1)) != NULL) {
    130                     dci16->lpszDCIAliasName = SEGPTR_GET(str2);
    131                     if (!HeapFree(GetProcessHeap(), 0, str1))
    132                         FIXME("bad free line=%d\n", __LINE__);
    133                 } else {
    134                     return -2;
    135                 }
    136             } else {
    137                 return -2;
    138             }
    139             *lParam2 = (LPARAM)SEGPTR_GET(dci16);
    140             ret = 1;
    141         } else {
    142             ret = 0;
    143         }
    144         break;
     109    /* lParam1 is a handle to a window (conf) or to a driver (inst) or not used,
     110     * lParam2 is a pointer to DRVCONFIGINFO
     111    */
     112    if (*lParam2) {
     113            LPDRVCONFIGINFO16   dci16 = (LPDRVCONFIGINFO16)SEGPTR_ALLOC(sizeof(DRVCONFIGINFO16));
     114            LPDRVCONFIGINFO dci32 = (LPDRVCONFIGINFO)(*lParam2);
     115
     116        if (dci16) {
     117        LPSTR   str1, str2;
     118
     119        dci16->dwDCISize = sizeof(DRVCONFIGINFO16);
     120
     121        if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCISectionName)) != NULL &&
     122            (str2 = SEGPTR_STRDUP(str1)) != NULL) {
     123            dci16->lpszDCISectionName = SEGPTR_GET(str2);
     124            if (!HeapFree(GetProcessHeap(), 0, str1))
     125            FIXME("bad free line=%d\n", __LINE__);
     126        } else {
     127            return -2;
     128        }
     129        if ((str1 = HEAP_strdupWtoA(GetProcessHeap(), 0, dci32->lpszDCIAliasName)) != NULL &&
     130            (str2 = SEGPTR_STRDUP(str1)) != NULL) {
     131            dci16->lpszDCIAliasName = SEGPTR_GET(str2);
     132            if (!HeapFree(GetProcessHeap(), 0, str1))
     133            FIXME("bad free line=%d\n", __LINE__);
     134        } else {
     135            return -2;
     136        }
     137        } else {
     138        return -2;
     139        }
     140        *lParam2 = (LPARAM)SEGPTR_GET(dci16);
     141        ret = 1;
     142    } else {
     143        ret = 0;
     144    }
     145    break;
    145146    default:
    146         if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
    147            FIXME("Unknown message 0x%04x\n", wMsg);
    148         }
    149         ret = 0;
     147    if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
     148       FIXME("Unknown message 0x%04x\n", wMsg);
     149    }
     150    ret = 0;
    150151    }
    151152    return ret;
    … …  
    153154
    154155/**************************************************************************
    155  *                              DRIVER_UnMapMsg32To16           [internal]
     156 *              DRIVER_UnMapMsg32To16       [internal]
    156157 *
    157158 * UnMap a 32 bit driver message to a 16 bit driver message.
    … …  
    162163static int DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
    163164{
    164     int ret = -1;
    165    
     165    int ret = -1;
     166
    166167    switch (wMsg) {
    167168    case DRV_LOAD:
    … …  
    176177    case DRV_OPEN:
    177178    case DRV_CLOSE:
    178         /* lParam1 and lParam2 are not used */
    179         break;
    180     case DRV_CONFIGURE: 
     179    /* lParam1 and lParam2 are not used */
     180    break;
     181    case DRV_CONFIGURE:
    181182    case DRV_INSTALL:
    182         /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
    183         if (lParam2) {
    184             LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
    185            
    186             if (!SEGPTR_FREE(MapSL(dci16->lpszDCISectionName)))
    187                 FIXME("bad free line=%d\n", __LINE__);
    188             if (!SEGPTR_FREE(MapSL(dci16->lpszDCIAliasName)))
    189                 FIXME("bad free line=%d\n", __LINE__);
    190             if (!SEGPTR_FREE(dci16))
    191                 FIXME("bad free line=%d\n", __LINE__);
    192         }
    193         ret = 0;
    194         break;
     183    /* lParam1 is a handle to a window (or not used), lParam2 is a pointer to DRVCONFIGINFO, lParam2 */
     184    if (lParam2) {
     185        LPDRVCONFIGINFO16   dci16 = MapSL(lParam2);
     186
     187        if (!SEGPTR_FREE(MapSL(dci16->lpszDCISectionName)))
     188        FIXME("bad free line=%d\n", __LINE__);
     189        if (!SEGPTR_FREE(MapSL(dci16->lpszDCIAliasName)))
     190        FIXME("bad free line=%d\n", __LINE__);
     191        if (!SEGPTR_FREE(dci16))
     192        FIXME("bad free line=%d\n", __LINE__);
     193    }
     194    ret = 0;
     195    break;
    195196    default:
    196         if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
    197             FIXME("Unknown message 0x%04x\n", wMsg);
    198         }
    199         ret = 0;
     197    if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
     198        FIXME("Unknown message 0x%04x\n", wMsg);
     199    }
     200    ret = 0;
    200201    }
    201202    return ret;
    … …  
    204205
    205206/**************************************************************************
    206  *                              DRIVER_SendMessage              [internal]
    207  */
    208 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg, 
    209                                         LPARAM lParam1, LPARAM lParam2)
     207 *              DRIVER_SendMessage      [internal]
     208 */
     209static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
     210                    LPARAM lParam1, LPARAM lParam2)
    210211{
    211212#ifndef __WIN32OS2__
    212213    if (lpDrv->dwFlags & WINE_GDF_16BIT) {
    213         LRESULT         ret;
    214         int             map = 0;
    215         TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
    216               lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
    217 
    218         if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
    219             ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
    220             if (map == 1)
    221                 DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
    222         } else {
    223             ret = 0;
    224         }
    225         return ret;
     214    LRESULT     ret;
     215    int     map = 0;
     216    TRACE("Before sdm16 call hDrv=%04x wMsg=%04x p1=%08lx p2=%08lx\n",
     217          lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
     218
     219    if ((map = DRIVER_MapMsg32To16(msg, &lParam1, &lParam2)) >= 0) {
     220        ret = SendDriverMessage16(lpDrv->d.d16.hDriver16, msg, lParam1, lParam2);
     221        if (map == 1)
     222        DRIVER_UnMapMsg32To16(msg, lParam1, lParam2);
     223    } else {
     224        ret = 0;
     225    }
     226    return ret;
    226227    }
    227228#endif
    228     TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n", 
    229           lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
     229    TRACE("Before func32 call proc=%p driverID=%08lx hDrv=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
     230      lpDrv->d.d32.lpDrvProc, lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
    230231    return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
    231232}
    232233
    233234/**************************************************************************
    234  *                              SendDriverMessage               [WINMM.19]
     235 *              SendDriverMessage       [WINMM.19]
    235236 */
    236237LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
    237                                 LPARAM lParam2)
    238 {
    239     LPWINE_DRIVER       lpDrv;
    240     LRESULT             retval = 0;
    241    
     238                LPARAM lParam2)
     239{
     240    LPWINE_DRIVER   lpDrv;
     241    LRESULT         retval = 0;
     242
    242243    TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
    243    
     244
    244245    if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
    245         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
     246    retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
    246247    } else {
    247         WARN("Bad driver handle %u\n", hDriver);
     248    WARN("Bad driver handle %u\n", hDriver);
    248249    }
    249250    TRACE("retval = %ld\n", retval);
    250    
     251
    251252    return retval;
    252253}
    253254
    254255/**************************************************************************
    255  *                              DRIVER_RemoveFromList           [internal]
     256 *              DRIVER_RemoveFromList       [internal]
    256257 *
    257258 * Generates all the logic to handle driver closure / deletion
    258259 * Removes a driver struct to the list of open drivers.
    259260 */
    260 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
     261static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
    261262{
    262263    if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
    263         if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
    264             DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
    265             DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
    266         }
    267     }
    268    
     264    if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
     265        DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
     266        DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
     267    }
     268    }
     269
    269270    if (lpDrv->lpPrevItem)
    270         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
     271    lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
    271272    else
    272         lpDrvItemList = lpDrv->lpNextItem;
     273    lpDrvItemList = lpDrv->lpNextItem;
    273274    if (lpDrv->lpNextItem)
    274         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
     275    lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
    275276
    276277    return TRUE;
    … …  
    278279
    279280/**************************************************************************
    280  *                              DRIVER_AddToList                [internal]
     281 *              DRIVER_AddToList        [internal]
    281282 *
    282283 * Adds a driver struct to the list of open drivers.
    283284 * Generates all the logic to handle driver creation / open.
    284285 */
    285 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
     286static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
    286287{
    287288    lpNewDrv->dwMagic = WINE_DI_MAGIC;
    288289    /* First driver to be loaded for this module, need to load correctly the module */
    289290    if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
    290         if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
    291             if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
    292                 TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
    293                 return FALSE;
    294             }
    295             /* returned value is not checked */
    296             DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
    297         }
     291    if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
     292        if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
     293        TRACE("DRV_LOAD failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
     294        return FALSE;
     295        }
     296        /* returned value is not checked */
     297        DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
     298    }
    298299    }
    299300
    300301    lpNewDrv->lpNextItem = NULL;
    301302    if (lpDrvItemList == NULL) {
    302         lpDrvItemList = lpNewDrv;
    303         lpNewDrv->lpPrevItem = NULL;
     303    lpDrvItemList = lpNewDrv;
     304    lpNewDrv->lpPrevItem = NULL;
    304305    } else {
    305         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
    306         while (lpDrv->lpNextItem != NULL)
    307             lpDrv = lpDrv->lpNextItem;
    308        
    309         lpDrv->lpNextItem = lpNewDrv;
    310         lpNewDrv->lpPrevItem = lpDrv;
     306    LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
     307    while (lpDrv->lpNextItem != NULL)
     308        lpDrv = lpDrv->lpNextItem;
     309
     310    lpDrv->lpNextItem = lpNewDrv;
     311    lpNewDrv->lpPrevItem = lpDrv;
    311312    }
    312313
    313314    if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
    314         /* Now just open a new instance of a driver on this module */
    315         lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
    316 
    317         if (lpNewDrv->d.d32.dwDriverID == 0) {
    318             TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
    319             DRIVER_RemoveFromList(lpNewDrv);
    320             return FALSE;
    321         }
     315    /* Now just open a new instance of a driver on this module */
     316    lpNewDrv->d.d32.dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
     317
     318    if (lpNewDrv->d.d32.dwDriverID == 0) {
     319        TRACE("DRV_OPEN failed on driver 0x%08lx\n", (DWORD)lpNewDrv);
     320        DRIVER_RemoveFromList(lpNewDrv);
     321        return FALSE;
     322    }
    322323    }
    323324    return TRUE;
    … …  
    325326
    326327/**************************************************************************
    327  *                              DRIVER_GetLibName               [internal]
    328  *
    329  */
    330 BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
     328 *              DRIVER_GetLibName       [internal]
     329 *
     330 */
     331BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
    331332{
    332333    /* should also do some registry diving */
    … …  
    335336
    336337/**************************************************************************
    337  *                              DRIVER_TryOpenDriver32          [internal]
     338 *              DRIVER_TryOpenDriver32      [internal]
    338339 *
    339340 * Tries to load a 32 bit driver whose DLL's (module) name is fn
    340341 */
    341 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
    342 {
    343     LPWINE_DRIVER       lpDrv = NULL;
    344     HMODULE             hModule = 0;
    345     LPSTR               ptr;
    346     LPCSTR              cause = 0;
     342LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
     343{
     344    LPWINE_DRIVER   lpDrv = NULL;
     345    HMODULE     hModule = 0;
     346    LPSTR       ptr;
     347    LPCSTR      cause = 0;
    347348
    348349    TRACE("('%s', %08lX);\n", fn, lParam2);
    349    
     350
    350351    if ((ptr = strchr(fn, ' ')) != NULL) {
    351         *ptr++ = '\0';
    352         while (*ptr == ' ') ptr++;
    353         if (*ptr == '\0') ptr = NULL;
     352    *ptr++ = '\0';
     353    while (*ptr == ' ') ptr++;
     354    if (*ptr == '\0') ptr = NULL;
    354355    }
    355356
    … …  
    378379#ifdef __WIN32OS2__
    379380/**************************************************************************
    380  *                              DRIVER_OpenDriverA                      [internal]
     381 *              DRIVER_OpenDriverA              [internal]
    381382 * (0,1,DRV_LOAD  ,0       ,0)
    382383 * (0,1,DRV_ENABLE,0       ,0)
    … …  
    384385 *
    385386 */
    386 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
     387static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
    387388{
    388389  LPWINE_DRIVER lpDrv = NULL;
    389   char          drvName[128];
     390  char      drvName[128];
    390391  LPCSTR        cause = 0;
    391  
     392
    392393  TRACE("Entering DRIVER_OpenDriverA: lpDriverName: %s lpSectionName: %s\n",lpDriverName,lpSectionName);
    393394
    … …  
    396397
    397398  if (lpSectionName == NULL) {
    398         lstrcpynA(drvName, lpDriverName, sizeof(drvName));
    399         lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
    400         if (!lpDrv) {
     399    lstrcpynA(drvName, lpDriverName, sizeof(drvName));
     400    lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
     401    if (!lpDrv) {
    401402      if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
    402403                                   sizeof(drvName), "SYSTEM.INI")) {
    403404
    404                 lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);               
     405        lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
    405406      }
    406         }
     407    }
    407408  } else {/* of if (lpSectionName == NULL) */
    408409    //dprintf(("driver name %x '%s'\n",drvName,drvName));
    409     drvName[0]=0;   
    410 
    411         if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
     410    drvName[0]=0;
     411
     412    if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
    412413                                 sizeof(drvName)-1, "SYSTEM.INI")) {
    413414#if 0
    414415      dprintf(("driver name %x '%s'\n",drvName,drvName));
    415 #endif     
     416#endif
    416417      lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
    417         }/* GetPrivate... */
     418    }/* GetPrivate... */
    418419  }
    419420  if (!lpDrv)
    420         TRACE("OpenDriverA: Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
    421 
    422   else 
    423         TRACE("OpenDriverA success: Driver handle => %08x\n", lpDrv);
     421    TRACE("OpenDriverA: Failed to open driver %s from section %s\n", lpDriverName, lpSectionName);
     422
     423  else
     424    TRACE("OpenDriverA success: Driver handle => %08x\n", lpDrv);
    424425
    425426  return lpDrv;
    … …  
    432433#else
    433434/**************************************************************************
    434  *                              DRIVER_TryOpenDriver16          [internal]
     435 *              DRIVER_TryOpenDriver16      [internal]
    435436 *
    436437 * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
    437438 */
    438 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
    439 {
    440     LPWINE_DRIVER       lpDrv = NULL;
    441     LPCSTR              cause = 0;
     439static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
     440{
     441    LPWINE_DRIVER   lpDrv = NULL;
     442    LPCSTR      cause = 0;
    442443
    443444    TRACE("('%s', %08lX);\n", sn, lParam2);
    444    
     445
    445446    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
    446447    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
    447448
    448449    /* FIXME: shall we do some black magic here on sn ?
    449      *  drivers32 => drivers
    450      *  mci32 => mci
     450     *  drivers32 => drivers
     451     *  mci32 => mci
    451452     * ...
    452453     */
    … …  
    467468
    468469/**************************************************************************
    469  *                              OpenDriverA                     [WINMM.15]
     470 *              OpenDriverA             [WINMM.15]
    470471 * (0,1,DRV_LOAD  ,0       ,0)
    471472 * (0,1,DRV_ENABLE,0       ,0)
    472473 * (0,1,DRV_OPEN  ,buf[256],0)
    473474 */
    474 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2) 
    475 {
    476     LPWINE_DRIVER       lpDrv = NULL;
    477     char                libName[128];
    478     LPCSTR              lsn = lpSectionName;
     475HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
     476{
     477    LPWINE_DRIVER   lpDrv = NULL;
     478    char        libName[128];
     479    LPCSTR      lsn = lpSectionName;
    479480
    480481    TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
    481    
     482
    482483    if (lsn == NULL) {
    483         lstrcpynA(libName, lpDriverName, sizeof(libName));
    484 
    485         if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
    486             goto the_end;
    487         lsn = "Drivers32";
     484    lstrcpynA(libName, lpDriverName, sizeof(libName));
     485
     486    if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
     487        goto the_end;
     488    lsn = "Drivers32";
    488489    }
    489490    if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
    490         (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
    491         goto the_end;
     491    (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
     492    goto the_end;
    492493
    493494    if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
    494         TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
     495    TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
    495496
    496497 the_end:
    497     if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
     498    if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
    498499    return (DWORD)lpDrv;
    499500}
    500501
    501502/**************************************************************************
    502  *                              OpenDriverW                     [WINMM.15]
     503 *              OpenDriverW             [WINMM.15]
    503504 */
    504505HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
    505506{
    506     LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
    507     LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
    508     HDRVR               ret = OpenDriverA(dn, sn, lParam);
    509    
     507    LPSTR       dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
     508    LPSTR       sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
     509    HDRVR       ret = OpenDriverA(dn, sn, lParam);
     510
    510511    if (dn) HeapFree(GetProcessHeap(), 0, dn);
    511512    if (sn) HeapFree(GetProcessHeap(), 0, sn);
    … …  
    514515
    515516/**************************************************************************
    516  *                      CloseDriver                             [WINMM.4]
     517 *          CloseDriver             [WINMM.4]
    517518 */
    518519LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
    519520{
    520     LPWINE_DRIVER       lpDrv;
     521    LPWINE_DRIVER   lpDrv;
    521522
    522523    TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
    523    
     524
    524525    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    525526#ifndef __WIN32OS2__
    526         if (lpDrv->dwFlags & WINE_GDF_16BIT)
    527             CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
    528         else
     527    if (lpDrv->dwFlags & WINE_GDF_16BIT)
     528        CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
     529    else
    529530#endif
    530             DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
    531         if (DRIVER_RemoveFromList(lpDrv)) {
    532             HeapFree(GetProcessHeap(), 0, lpDrv);
    533             return TRUE;
    534         }
     531        DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
     532    if (DRIVER_RemoveFromList(lpDrv)) {
     533        HeapFree(GetProcessHeap(), 0, lpDrv);
     534        return TRUE;
     535    }
    535536    }
    536537    WARN("Failed to close driver\n");
    … …  
    539540
    540541/**************************************************************************
    541  *                              GetDriverFlags          [WINMM.13]
     542 *              GetDriverFlags      [WINMM.13]
    542543 * [in] hDrvr handle to the driver
    543544 *
    544545 * Returns:
    545  *      0x00000000 if hDrvr is an invalid handle
    546  *      0x80000000 if hDrvr is a valid 32 bit driver
    547  *      0x90000000 if hDrvr is a valid 16 bit driver
     546 *  0x00000000 if hDrvr is an invalid handle
     547 *  0x80000000 if hDrvr is a valid 32 bit driver
     548 *  0x90000000 if hDrvr is a valid 16 bit driver
    548549 *
    549550 * native WINMM doesn't return those flags
    550  *      0x80000000 for a valid 32 bit driver and that's it
    551  *      (I may have mixed up the two flags :-(
    552  */
    553 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
    554 {
    555     LPWINE_DRIVER       lpDrv;
    556     DWORD               ret = 0;
     551 *  0x80000000 for a valid 32 bit driver and that's it
     552 *  (I may have mixed up the two flags :-(
     553 */
     554DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
     555{
     556    LPWINE_DRIVER   lpDrv;
     557    DWORD       ret = 0;
    557558
    558559    TRACE("(%04x)\n", hDrvr);
    559560
    560561    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    561         ret = WINE_GDF_EXIST | lpDrv->dwFlags;
     562    ret = WINE_GDF_EXIST | lpDrv->dwFlags;
    562563    }
    563564    return ret;
    … …  
    565566
    566567/**************************************************************************
    567  *                              GetDriverModuleHandle   [WINMM.14]
     568 *              GetDriverModuleHandle   [WINMM.14]
    568569 */
    569570HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
    570571{
    571     LPWINE_DRIVER       lpDrv;
    572     HMODULE             hModule = 0;
    573    
     572    LPWINE_DRIVER   lpDrv;
     573    HMODULE     hModule = 0;
     574
    574575    TRACE("(%04x);\n", hDrvr);
    575    
     576
    576577    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    577         if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
    578             hModule = lpDrv->d.d32.hModule;
     578    if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
     579        hModule = lpDrv->d.d32.hModule;
    579580    }
    580581    TRACE("=> %04x\n", hModule);
    … …  
    584585#ifndef __WIN32OS2__
    585586/**************************************************************************
    586  *                              DrvOpen                 [MMSYSTEM.1100]
     587 *              DrvOpen             [MMSYSTEM.1100]
    587588 */
    588589HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
    … …  
    592593
    593594/**************************************************************************
    594  *                              DrvClose                [MMSYSTEM.1101]
     595 *              DrvClose            [MMSYSTEM.1101]
    595596 */
    596597LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
    … …  
    600601
    601602/**************************************************************************
    602  *                              DrvSendMessage          [MMSYSTEM.1102]
     603 *              DrvSendMessage      [MMSYSTEM.1102]
    603604 */
    604605LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
    605                                 LPARAM lParam2)
     606                LPARAM lParam2)
    606607{
    607608    return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
    … …  
    609610
    610611/**************************************************************************
    611  *                              DrvGetModuleHandle      [MMSYSTEM.1103]
     612 *              DrvGetModuleHandle  [MMSYSTEM.1103]
    612613 */
    613614HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
    … …  
    617618
    618619/**************************************************************************
    619  *                              DrvDefDriverProc        [MMSYSTEM.1104]
    620  */
    621 LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg, 
    622                                   DWORD dwParam1, DWORD dwParam2)
     620 *              DrvDefDriverProc    [MMSYSTEM.1104]
     621 */
     622LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
     623                  DWORD dwParam1, DWORD dwParam2)
    623624{
    624625    return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
    … …  
    627628
    628629/**************************************************************************
    629  *                              DefDriverProc                     [WINMM.5]
     630 *              DefDriverProc             [WINMM.5]
    630631 */
    631632LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
    632                              UINT Msg, LPARAM lParam1, LPARAM lParam2)
     633                 UINT Msg, LPARAM lParam1, LPARAM lParam2)
    633634{
    634635    switch (Msg) {
    … …  
    648649#ifndef __WIN32OS2__
    649650/**************************************************************************
    650  *                              DriverProc                      [MMSYSTEM.6]
    651  */
    652 LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg, 
    653                             DWORD dwParam1, DWORD dwParam2)
     651 *              DriverProc          [MMSYSTEM.6]
     652 */
     653LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
     654                DWORD dwParam1, DWORD dwParam2)
    654655{
    655656    TRACE("dwDevID=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\n",
    656           dwDevID, hDrv, wMsg, dwParam1, dwParam2);
     657      dwDevID, hDrv, wMsg, dwParam1, dwParam2);
    657658
    658659    return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
    … …  
    662663#ifdef __WIN32OS2__
    663664/**************************************************************************
    664  *                              DriverCallback                  [MMSYSTEM.31]
    665  */
    666 BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, 
    667                            UINT wMsg, DWORD dwUser, DWORD dwParam1,
    668                            DWORD dwParam2)
     665 *              DriverCallback          [MMSYSTEM.31]
     666 */
     667BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
     668               UINT wMsg, DWORD dwUser, DWORD dwParam1,
     669               DWORD dwParam2)
    669670{
    670671    TRACE("DriverCallback (%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
    671           dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
     672      dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
    672673
    673674    switch (uFlags & DCB_TYPEMASK) {
    674675    case DCB_NULL:
    675         TRACE("Null !\n");
    676         if (dwCallBack)
    677             WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
    678         break;
     676    TRACE("Null !\n");
     677    if (dwCallBack)
     678        WARN("uFlags=%04X has null DCB value, but dwCallBack=%08lX is not null !\n", uFlags, dwCallBack);
     679    break;
    679680    case DCB_WINDOW:
    680         TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
    681         if (!IsWindow(dwCallBack))
    682             return FALSE;
    683         PostMessageA((HWND)dwCallBack, wMsg, hDev, dwParam1);
    684         break;
     681    TRACE("Window(%04lX) handle=%04X!\n", dwCallBack, hDev);
     682    if (!IsWindow(dwCallBack))
     683        return FALSE;
     684    PostMessageA((HWND)dwCallBack, wMsg, hDev, dwParam1);
     685    break;
    685686    case DCB_TASK: /* aka DCB_THREAD */
    686         TRACE("Task(%04lx) !\n", dwCallBack);
    687         PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
    688         break;
     687    TRACE("Task(%04lx) !\n", dwCallBack);
     688    PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
     689    break;
    689690    case DCB_FUNCTION:
    690         TRACE("Function (32 bit) !\n");
    691         ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
    692         break;
     691    TRACE("Function (32 bit) !\n");
     692    ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
     693    break;
    693694    case DCB_EVENT:
    694         TRACE("Event(%08lx) !\n", dwCallBack);
    695         SetEvent((HANDLE)dwCallBack);
    696         break;
     695    TRACE("Event(%08lx) !\n", dwCallBack);
     696    SetEvent((HANDLE)dwCallBack);
     697    break;
    697698    case 6: /* I would dub it DCB_MMTHREADSIGNAL */
    698         /* this is an undocumented DCB_ value used for mmThreads
    699         * loword of dwCallBack contains the handle of the lpMMThd block
    700         * which dwSignalCount has to be incremented
    701         */
    702         {
     699    /* this is an undocumented DCB_ value used for mmThreads
     700    * loword of dwCallBack contains the handle of the lpMMThd block
     701    * which dwSignalCount has to be incremented
     702    */
     703    {
    703704#ifdef __WIN32OS2__
    704             WINE_MMTHREAD*      lpMMThd = (WINE_MMTHREAD*)dwCallBack;
     705        WINE_MMTHREAD*  lpMMThd = (WINE_MMTHREAD*)dwCallBack;
    705706#else
    706             WINE_MMTHREAD*      lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
     707        WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
    707708#endif
    708709
    709             TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
    710             /* same as mmThreadSignal16 */
    711             InterlockedIncrement(&lpMMThd->dwSignalCount);
    712             SetEvent(lpMMThd->hEvent);
    713             /* some other stuff on lpMMThd->hVxD */
    714         }
    715         break; 
     710        TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
     711        /* same as mmThreadSignal16 */
     712        InterlockedIncrement(&lpMMThd->dwSignalCount);
     713        SetEvent(lpMMThd->hEvent);
     714        /* some other stuff on lpMMThd->hVxD */
     715    }
     716    break;
    716717#if 0
    717718    case 4:
    718         /* this is an undocumented DCB_ value for... I don't know */
    719         break;
     719    /* this is an undocumented DCB_ value for... I don't know */
     720    break;
    720721#endif
    721722    default:
    722         WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
    723         return FALSE;
     723    WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
     724    return FALSE;
    724725    }
    725726    TRACE("Done\n");
Note: See TracChangeset for help on using the changeset viewer.