Changeset 6712 for trunk/src/winmm


Ignore:
Timestamp:
Sep 15, 2001, 11:47:44 AM (24 years ago)
Author:
sandervl
Message:

restored old version

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/winmm/driver.c

    r6639 r6712  
    11/* -*- tab-width: 8; c-basic-offset: 4 -*- */
    22
    3 /* $Id: driver.c,v 1.2 2001-09-05 10:30:21 bird Exp $
    4  *
     3/*
    54 * WINE Drivers functions
    65 *
    … …  
    3332DEFAULT_DEBUG_CHANNEL(driver);
    3433
    35 static LPWINE_DRIVER    lpDrvItemList = NULL;
     34static LPWINE_DRIVER    lpDrvItemList = NULL;
    3635
    3736/* TODO list :
    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]
     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]
    4443 *
    4544 * Returns the number of open drivers which share the same module.
    4645 */
    47 static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
    48 {
    49     LPWINE_DRIVER   lpDrv;
    50     WORD        count = 0;
     46static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
     47{
     48    LPWINE_DRIVER       lpDrv;
     49    WORD                count = 0;
    5150
    5251    if (lpNewDrv->dwFlags & WINE_GDF_16BIT) ERR("OOOch");
    5352    for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
    54     if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
    55         lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
    56         count++;
    57     }
     53        if (!(lpDrv->dwFlags & WINE_GDF_16BIT) &&
     54            lpDrv->d.d32.hModule == lpNewDrv->d.d32.hModule) {
     55            count++;
     56        }
    5857    }
    5958    return count;
    … …  
    6160
    6261/**************************************************************************
    63  *              DRIVER_FindFromHDrvr        [internal]
    64  *
     62 *                              DRIVER_FindFromHDrvr            [internal]
     63 * 
    6564 * From a hDrvr being 32 bits, returns the WINE internal structure.
    6665 */
    67 LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
    68 {
    69     LPWINE_DRIVER   d = (LPWINE_DRIVER)hDrvr;
     66LPWINE_DRIVER   DRIVER_FindFromHDrvr(HDRVR hDrvr)
     67{   
     68    LPWINE_DRIVER       d = (LPWINE_DRIVER)hDrvr;
    7069
    7170    if (hDrvr && HeapValidate(GetProcessHeap(), 0, d) && d->dwMagic == WINE_DI_MAGIC) {
    72     return d;
     71        return d;
    7372    }
    7473    return NULL;
    … …  
    7776#ifndef __WIN32OS2__
    7877/**************************************************************************
    79  *              DRIVER_MapMsg32To16     [internal]
     78 *                              DRIVER_MapMsg32To16             [internal]
    8079 *
    8180 * Map a 32 bit driver message to a 16 bit driver message.
    … …  
    8786static int DRIVER_MapMsg32To16(WORD wMsg, DWORD* lParam1, DWORD* lParam2)
    8887{
    89     int ret = -1;
    90 
     88    int ret = -1;
     89   
    9190    switch (wMsg) {
    9291    case DRV_LOAD:
    … …  
    9796    case DRV_REMOVE:
    9897    case DRV_EXITSESSION:
    99     case DRV_EXITAPPLICATION:
     98    case DRV_EXITAPPLICATION:   
    10099    case DRV_POWER:
    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;
     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;
    107106    case DRV_CONFIGURE:
    108107    case DRV_INSTALL:
    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;
     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;
    146145    default:
    147     if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
    148        FIXME("Unknown message 0x%04x\n", wMsg);
    149     }
    150     ret = 0;
     146        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
     147           FIXME("Unknown message 0x%04x\n", wMsg);
     148        }
     149        ret = 0;
    151150    }
    152151    return ret;
    … …  
    154153
    155154/**************************************************************************
    156  *              DRIVER_UnMapMsg32To16       [internal]
     155 *                              DRIVER_UnMapMsg32To16           [internal]
    157156 *
    158157 * UnMap a 32 bit driver message to a 16 bit driver message.
    … …  
    163162static int DRIVER_UnMapMsg32To16(WORD wMsg, DWORD lParam1, DWORD lParam2)
    164163{
    165     int ret = -1;
    166 
     164    int ret = -1;
     165   
    167166    switch (wMsg) {
    168167    case DRV_LOAD:
    … …  
    177176    case DRV_OPEN:
    178177    case DRV_CLOSE:
    179     /* lParam1 and lParam2 are not used */
    180     break;
    181     case DRV_CONFIGURE:
     178        /* lParam1 and lParam2 are not used */
     179        break;
     180    case DRV_CONFIGURE: 
    182181    case DRV_INSTALL:
    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;
     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;
    196195    default:
    197     if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
    198         FIXME("Unknown message 0x%04x\n", wMsg);
    199     }
    200     ret = 0;
     196        if (!((wMsg >= 0x800 && wMsg < 0x900) || (wMsg >= 0x4000 && wMsg < 0x4100))) {
     197            FIXME("Unknown message 0x%04x\n", wMsg);
     198        }
     199        ret = 0;
    201200    }
    202201    return ret;
    … …  
    205204
    206205/**************************************************************************
    207  *              DRIVER_SendMessage      [internal]
    208  */
    209 static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg,
    210                     LPARAM lParam1, LPARAM lParam2)
     206 *                              DRIVER_SendMessage              [internal]
     207 */
     208static LRESULT inline DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT msg, 
     209                                        LPARAM lParam1, LPARAM lParam2)
    211210{
    212211#ifndef __WIN32OS2__
    213212    if (lpDrv->dwFlags & WINE_GDF_16BIT) {
    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);
     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;
     226    }
     227#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);
     230    return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
     231}
     232
     233/**************************************************************************
     234 *                              SendDriverMessage               [WINMM.19]
     235 */
     236LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
     237                                 LPARAM lParam2)
     238{
     239    LPWINE_DRIVER       lpDrv;
     240    LRESULT             retval = 0;
     241   
     242    TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
     243   
     244    if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
     245        retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
    223246    } else {
    224         ret = 0;
    225     }
    226     return ret;
    227     }
    228 #endif
    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);
    231     return lpDrv->d.d32.lpDrvProc(lpDrv->d.d32.dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
    232 }
    233 
    234 /**************************************************************************
    235  *              SendDriverMessage       [WINMM.19]
    236  */
    237 LRESULT WINAPI SendDriverMessage(HDRVR hDriver, UINT msg, LPARAM lParam1,
    238                  LPARAM lParam2)
    239 {
    240     LPWINE_DRIVER   lpDrv;
    241     LRESULT         retval = 0;
    242 
    243     TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
    244 
    245     if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
    246     retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
    247     } else {
    248     WARN("Bad driver handle %u\n", hDriver);
     247        WARN("Bad driver handle %u\n", hDriver);
    249248    }
    250249    TRACE("retval = %ld\n", retval);
    251 
     250   
    252251    return retval;
    253252}
    254253
    255254/**************************************************************************
    256  *              DRIVER_RemoveFromList       [internal]
     255 *                              DRIVER_RemoveFromList           [internal]
    257256 *
    258257 * Generates all the logic to handle driver closure / deletion
    259258 * Removes a driver struct to the list of open drivers.
    260259 */
    261 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
     260static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
    262261{
    263262    if (!(lpDrv->dwFlags & WINE_GDF_16BIT)) {
    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 
     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   
    270269    if (lpDrv->lpPrevItem)
    271     lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
     270        lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
    272271    else
    273     lpDrvItemList = lpDrv->lpNextItem;
     272        lpDrvItemList = lpDrv->lpNextItem;
    274273    if (lpDrv->lpNextItem)
    275     lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
     274        lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
    276275
    277276    return TRUE;
    … …  
    279278
    280279/**************************************************************************
    281  *              DRIVER_AddToList        [internal]
     280 *                              DRIVER_AddToList                [internal]
    282281 *
    283282 * Adds a driver struct to the list of open drivers.
    284283 * Generates all the logic to handle driver creation / open.
    285284 */
    286 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
     285static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
    287286{
    288287    lpNewDrv->dwMagic = WINE_DI_MAGIC;
    289288    /* First driver to be loaded for this module, need to load correctly the module */
    290289    if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
    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     }
     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        }
    299298    }
    300299
    301300    lpNewDrv->lpNextItem = NULL;
    302301    if (lpDrvItemList == NULL) {
    303     lpDrvItemList = lpNewDrv;
    304     lpNewDrv->lpPrevItem = NULL;
     302        lpDrvItemList = lpNewDrv;
     303        lpNewDrv->lpPrevItem = NULL;
    305304    } else {
    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;
     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;
    312311    }
    313312
    314313    if (!(lpNewDrv->dwFlags & WINE_GDF_16BIT)) {
    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     }
     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        }
    323322    }
    324323    return TRUE;
    … …  
    326325
    327326/**************************************************************************
    328  *              DRIVER_GetLibName       [internal]
    329  *
    330  */
    331 BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
     327 *                              DRIVER_GetLibName               [internal]
     328 *
     329 */
     330BOOL    DRIVER_GetLibName(LPCSTR keyName, LPCSTR sectName, LPSTR buf, int sz)
    332331{
    333332    /* should also do some registry diving */
    … …  
    336335
    337336/**************************************************************************
    338  *              DRIVER_TryOpenDriver32      [internal]
     337 *                              DRIVER_TryOpenDriver32          [internal]
    339338 *
    340339 * Tries to load a 32 bit driver whose DLL's (module) name is fn
    341340 */
    342 LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
    343 {
    344     LPWINE_DRIVER   lpDrv = NULL;
    345     HMODULE     hModule = 0;
    346     LPSTR       ptr;
    347     LPCSTR      cause = 0;
     341LPWINE_DRIVER   DRIVER_TryOpenDriver32(LPCSTR fn, LPARAM lParam2)
     342{
     343    LPWINE_DRIVER       lpDrv = NULL;
     344    HMODULE             hModule = 0;
     345    LPSTR               ptr;
     346    LPCSTR              cause = 0;
    348347
    349348    TRACE("('%s', %08lX);\n", fn, lParam2);
    350 
     349   
    351350    if ((ptr = strchr(fn, ' ')) != NULL) {
    352     *ptr++ = '\0';
    353     while (*ptr == ' ') ptr++;
    354     if (*ptr == '\0') ptr = NULL;
     351        *ptr++ = '\0';
     352        while (*ptr == ' ') ptr++;
     353        if (*ptr == '\0') ptr = NULL;
    355354    }
    356355
    … …  
    379378#ifdef __WIN32OS2__
    380379/**************************************************************************
    381  *              DRIVER_OpenDriverA              [internal]
     380 *                              DRIVER_OpenDriverA                      [internal]
    382381 * (0,1,DRV_LOAD  ,0       ,0)
    383382 * (0,1,DRV_ENABLE,0       ,0)
    … …  
    385384 *
    386385 */
    387 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
     386static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
    388387{
    389388  LPWINE_DRIVER lpDrv = NULL;
    390   char      drvName[128];
     389  char          drvName[128];
    391390  LPCSTR        cause = 0;
    392 
     391 
    393392  TRACE("Entering DRIVER_OpenDriverA: lpDriverName: %s lpSectionName: %s\n",lpDriverName,lpSectionName);
    394393
    … …  
    397396
    398397  if (lpSectionName == NULL) {
    399     lstrcpynA(drvName, lpDriverName, sizeof(drvName));
    400     lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
    401     if (!lpDrv) {
     398        lstrcpynA(drvName, lpDriverName, sizeof(drvName));
     399        lpDrv = DRIVER_TryOpenDriver32(lpDriverName, lParam);
     400        if (!lpDrv) {
    402401      if (GetPrivateProfileStringA("Drivers32", lpDriverName, "", drvName,
    403402                                   sizeof(drvName), "SYSTEM.INI")) {
    404403
    405         lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
     404                lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);               
    406405      }
    407     }
     406        }
    408407  } else {/* of if (lpSectionName == NULL) */
    409408    //dprintf(("driver name %x '%s'\n",drvName,drvName));
    410     drvName[0]=0;
    411 
    412     if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
     409    drvName[0]=0;   
     410
     411        if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "", drvName,
    413412                                 sizeof(drvName)-1, "SYSTEM.INI")) {
    414413#if 0
    415414      dprintf(("driver name %x '%s'\n",drvName,drvName));
    416 #endif
     415#endif     
    417416      lpDrv = DRIVER_TryOpenDriver32(drvName, lParam);
    418     }/* GetPrivate... */
     417        }/* GetPrivate... */
    419418  }
    420419  if (!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);
     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);
    425424
    426425  return lpDrv;
    … …  
    433432#else
    434433/**************************************************************************
    435  *              DRIVER_TryOpenDriver16      [internal]
     434 *                              DRIVER_TryOpenDriver16          [internal]
    436435 *
    437436 * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
    438437 */
    439 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
    440 {
    441     LPWINE_DRIVER   lpDrv = NULL;
    442     LPCSTR      cause = 0;
     438static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR fn, LPCSTR sn, LPARAM lParam2)
     439{
     440    LPWINE_DRIVER       lpDrv = NULL;
     441    LPCSTR              cause = 0;
    443442
    444443    TRACE("('%s', %08lX);\n", sn, lParam2);
    445 
     444   
    446445    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
    447446    if (lpDrv == NULL) {cause = "OOM"; goto exit;}
    448447
    449448    /* FIXME: shall we do some black magic here on sn ?
    450      *  drivers32 => drivers
    451      *  mci32 => mci
     449     *  drivers32 => drivers
     450     *  mci32 => mci
    452451     * ...
    453452     */
    … …  
    468467
    469468/**************************************************************************
    470  *              OpenDriverA             [WINMM.15]
     469 *                              OpenDriverA                     [WINMM.15]
    471470 * (0,1,DRV_LOAD  ,0       ,0)
    472471 * (0,1,DRV_ENABLE,0       ,0)
    473472 * (0,1,DRV_OPEN  ,buf[256],0)
    474473 */
    475 HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
    476 {
    477     LPWINE_DRIVER   lpDrv = NULL;
    478     char        libName[128];
    479     LPCSTR      lsn = lpSectionName;
     474HDRVR WINAPI OpenDriverA(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2) 
     475{
     476    LPWINE_DRIVER       lpDrv = NULL;
     477    char                libName[128];
     478    LPCSTR              lsn = lpSectionName;
    480479
    481480    TRACE("(%s, %s, 0x%08lx);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
    482 
     481   
    483482    if (lsn == NULL) {
    484     lstrcpynA(libName, lpDriverName, sizeof(libName));
    485 
    486     if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
    487         goto the_end;
    488     lsn = "Drivers32";
     483        lstrcpynA(libName, lpDriverName, sizeof(libName));
     484
     485        if ((lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
     486            goto the_end;
     487        lsn = "Drivers32";
    489488    }
    490489    if (DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) &&
    491     (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
    492     goto the_end;
     490        (lpDrv = DRIVER_TryOpenDriver32(libName, lParam2)))
     491        goto the_end;
    493492
    494493    if (!(lpDrv = DRIVER_TryOpenDriver16(lpDriverName, lpSectionName, lParam2)))
    495     TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
     494        TRACE("Failed to open driver %s from system.ini file, section %s\n", lpDriverName, lpSectionName);
    496495
    497496 the_end:
    498     if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
     497    if (lpDrv)  TRACE("=> %08lx\n", (DWORD)lpDrv);
    499498    return (DWORD)lpDrv;
    500499}
    501500
    502501/**************************************************************************
    503  *              OpenDriverW             [WINMM.15]
     502 *                              OpenDriverW                     [WINMM.15]
    504503 */
    505504HDRVR WINAPI OpenDriverW(LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
    506505{
    507     LPSTR       dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
    508     LPSTR       sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
    509     HDRVR       ret = OpenDriverA(dn, sn, lParam);
    510 
     506    LPSTR               dn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpDriverName);
     507    LPSTR               sn = HEAP_strdupWtoA(GetProcessHeap(), 0, lpSectionName);
     508    HDRVR               ret = OpenDriverA(dn, sn, lParam);
     509   
    511510    if (dn) HeapFree(GetProcessHeap(), 0, dn);
    512511    if (sn) HeapFree(GetProcessHeap(), 0, sn);
    … …  
    515514
    516515/**************************************************************************
    517  *          CloseDriver             [WINMM.4]
     516 *                      CloseDriver                             [WINMM.4]
    518517 */
    519518LRESULT WINAPI CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
    520519{
    521     LPWINE_DRIVER   lpDrv;
     520    LPWINE_DRIVER       lpDrv;
    522521
    523522    TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
    524 
     523   
    525524    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    526525#ifndef __WIN32OS2__
    527     if (lpDrv->dwFlags & WINE_GDF_16BIT)
    528         CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
    529     else
     526        if (lpDrv->dwFlags & WINE_GDF_16BIT)
     527            CloseDriver16(lpDrv->d.d16.hDriver16, lParam1, lParam2);
     528        else
    530529#endif
    531         DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
    532     if (DRIVER_RemoveFromList(lpDrv)) {
    533         HeapFree(GetProcessHeap(), 0, lpDrv);
    534         return TRUE;
    535     }
     530            DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
     531        if (DRIVER_RemoveFromList(lpDrv)) {
     532            HeapFree(GetProcessHeap(), 0, lpDrv);
     533            return TRUE;
     534        }
    536535    }
    537536    WARN("Failed to close driver\n");
    … …  
    540539
    541540/**************************************************************************
    542  *              GetDriverFlags      [WINMM.13]
     541 *                              GetDriverFlags          [WINMM.13]
    543542 * [in] hDrvr handle to the driver
    544543 *
    545544 * Returns:
    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
     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
    549548 *
    550549 * native WINMM doesn't return those flags
    551  *  0x80000000 for a valid 32 bit driver and that's it
    552  *  (I may have mixed up the two flags :-(
    553  */
    554 DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
    555 {
    556     LPWINE_DRIVER   lpDrv;
    557     DWORD       ret = 0;
     550 *      0x80000000 for a valid 32 bit driver and that's it
     551 *      (I may have mixed up the two flags :-(
     552 */
     553DWORD   WINAPI GetDriverFlags(HDRVR hDrvr)
     554{
     555    LPWINE_DRIVER       lpDrv;
     556    DWORD               ret = 0;
    558557
    559558    TRACE("(%04x)\n", hDrvr);
    560559
    561560    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    562     ret = WINE_GDF_EXIST | lpDrv->dwFlags;
     561        ret = WINE_GDF_EXIST | lpDrv->dwFlags;
    563562    }
    564563    return ret;
    … …  
    566565
    567566/**************************************************************************
    568  *              GetDriverModuleHandle   [WINMM.14]
     567 *                              GetDriverModuleHandle   [WINMM.14]
    569568 */
    570569HMODULE WINAPI GetDriverModuleHandle(HDRVR hDrvr)
    571570{
    572     LPWINE_DRIVER   lpDrv;
    573     HMODULE     hModule = 0;
    574 
     571    LPWINE_DRIVER       lpDrv;
     572    HMODULE             hModule = 0;
     573   
    575574    TRACE("(%04x);\n", hDrvr);
    576 
     575   
    577576    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    578     if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
    579         hModule = lpDrv->d.d32.hModule;
     577        if (!(lpDrv->dwFlags & WINE_GDF_16BIT))
     578            hModule = lpDrv->d.d32.hModule;
    580579    }
    581580    TRACE("=> %04x\n", hModule);
    … …  
    585584#ifndef __WIN32OS2__
    586585/**************************************************************************
    587  *              DrvOpen             [MMSYSTEM.1100]
     586 *                              DrvOpen                 [MMSYSTEM.1100]
    588587 */
    589588HDRVR16 WINAPI DrvOpen16(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
    … …  
    593592
    594593/**************************************************************************
    595  *              DrvClose            [MMSYSTEM.1101]
     594 *                              DrvClose                [MMSYSTEM.1101]
    596595 */
    597596LRESULT WINAPI DrvClose16(HDRVR16 hDrv, LPARAM lParam1, LPARAM lParam2)
    … …  
    601600
    602601/**************************************************************************
    603  *              DrvSendMessage      [MMSYSTEM.1102]
     602 *                              DrvSendMessage          [MMSYSTEM.1102]
    604603 */
    605604LRESULT WINAPI DrvSendMessage16(HDRVR16 hDrv, WORD msg, LPARAM lParam1,
    606                 LPARAM lParam2)
     605                                LPARAM lParam2)
    607606{
    608607    return SendDriverMessage16(hDrv, msg, lParam1, lParam2);
    … …  
    610609
    611610/**************************************************************************
    612  *              DrvGetModuleHandle  [MMSYSTEM.1103]
     611 *                              DrvGetModuleHandle      [MMSYSTEM.1103]
    613612 */
    614613HANDLE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrv)
    … …  
    618617
    619618/**************************************************************************
    620  *              DrvDefDriverProc    [MMSYSTEM.1104]
    621  */
    622 LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg,
    623                   DWORD dwParam1, DWORD dwParam2)
     619 *                              DrvDefDriverProc        [MMSYSTEM.1104]
     620 */
     621LRESULT WINAPI DrvDefDriverProc16(DWORD dwDriverID, HDRVR16 hDrv, WORD wMsg, 
     622                                  DWORD dwParam1, DWORD dwParam2)
    624623{
    625624    return DefDriverProc16(dwDriverID, hDrv, wMsg, dwParam1, dwParam2);
    … …  
    628627
    629628/**************************************************************************
    630  *              DefDriverProc             [WINMM.5]
     629 *                              DefDriverProc                     [WINMM.5]
    631630 */
    632631LRESULT WINAPI DefDriverProc(DWORD dwDriverIdentifier, HDRVR hDrv,
    633                  UINT Msg, LPARAM lParam1, LPARAM lParam2)
     632                             UINT Msg, LPARAM lParam1, LPARAM lParam2)
    634633{
    635634    switch (Msg) {
    … …  
    649648#ifndef __WIN32OS2__
    650649/**************************************************************************
    651  *              DriverProc          [MMSYSTEM.6]
    652  */
    653 LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
    654                 DWORD dwParam1, DWORD dwParam2)
     650 *                              DriverProc                      [MMSYSTEM.6]
     651 */
     652LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg, 
     653                            DWORD dwParam1, DWORD dwParam2)
    655654{
    656655    TRACE("dwDevID=%08lx hDrv=%04x wMsg=%04x dwParam1=%08lx dwParam2=%08lx\n",
    657       dwDevID, hDrv, wMsg, dwParam1, dwParam2);
     656          dwDevID, hDrv, wMsg, dwParam1, dwParam2);
    658657
    659658    return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
    … …  
    663662#ifdef __WIN32OS2__
    664663/**************************************************************************
    665  *              DriverCallback          [MMSYSTEM.31]
    666  */
    667 BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev,
    668                UINT wMsg, DWORD dwUser, DWORD dwParam1,
    669                DWORD dwParam2)
     664 *                              DriverCallback                  [MMSYSTEM.31]
     665 */
     666BOOL WINAPI DriverCallback(DWORD dwCallBack, UINT uFlags, HDRVR hDev, 
     667                           UINT wMsg, DWORD dwUser, DWORD dwParam1,
     668                           DWORD dwParam2)
    670669{
    671670    TRACE("DriverCallback (%08lX, %04X, %04X, %04X, %08lX, %08lX, %08lX); !\n",
    672       dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
     671          dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
    673672
    674673    switch (uFlags & DCB_TYPEMASK) {
    675674    case DCB_NULL:
    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;
     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;
    680679    case DCB_WINDOW:
    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;
     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;
    686685    case DCB_TASK: /* aka DCB_THREAD */
    687     TRACE("Task(%04lx) !\n", dwCallBack);
    688     PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
    689     break;
     686        TRACE("Task(%04lx) !\n", dwCallBack);
     687        PostThreadMessageA(dwCallBack, wMsg, hDev, dwParam1);
     688        break;
    690689    case DCB_FUNCTION:
    691     TRACE("Function (32 bit) !\n");
    692     ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
    693     break;
     690        TRACE("Function (32 bit) !\n");
     691        ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
     692        break;
    694693    case DCB_EVENT:
    695     TRACE("Event(%08lx) !\n", dwCallBack);
    696     SetEvent((HANDLE)dwCallBack);
    697     break;
     694        TRACE("Event(%08lx) !\n", dwCallBack);
     695        SetEvent((HANDLE)dwCallBack);
     696        break;
    698697    case 6: /* I would dub it DCB_MMTHREADSIGNAL */
    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     {
     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        {
    704703#ifdef __WIN32OS2__
    705         WINE_MMTHREAD*  lpMMThd = (WINE_MMTHREAD*)dwCallBack;
     704            WINE_MMTHREAD*      lpMMThd = (WINE_MMTHREAD*)dwCallBack;
    706705#else
    707         WINE_MMTHREAD*  lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
     706            WINE_MMTHREAD*      lpMMThd = MapSL( MAKESEGPTR(LOWORD(dwCallBack), 0) );
    708707#endif
    709708
    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;
     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; 
    717716#if 0
    718717    case 4:
    719     /* this is an undocumented DCB_ value for... I don't know */
    720     break;
     718        /* this is an undocumented DCB_ value for... I don't know */
     719        break;
    721720#endif
    722721    default:
    723     WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
    724     return FALSE;
     722        WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
     723        return FALSE;
    725724    }
    726725    TRACE("Done\n");
Note: See TracChangeset for help on using the changeset viewer.