driver.c File Reference

#include "winemm.h"

Include dependency graph for driver.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (driver)
static void	DRIVER_Dump (const char *comment)
static unsigned	DRIVER_GetNumberOfModuleRefs (HMODULE hModule, WINE_DRIVER **found)
LPWINE_DRIVER	DRIVER_FindFromHDrvr (HDRVR hDrvr)
static LRESULT	DRIVER_SendMessage (LPWINE_DRIVER lpDrv, UINT msg, LPARAM lParam1, LPARAM lParam2)
LRESULT WINAPI	SendDriverMessage (HDRVR hDriver, UINT msg, LPARAM lParam1, LPARAM lParam2)
static BOOL	DRIVER_RemoveFromList (LPWINE_DRIVER lpDrv)
static BOOL	DRIVER_AddToList (LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
BOOL	DRIVER_GetLibName (LPCWSTR keyName, LPCWSTR sectName, LPWSTR buf, int sz)
LPWINE_DRIVER	DRIVER_TryOpenDriver32 (LPCWSTR fn, LPARAM lParam2)
HDRVR WINAPI	OpenDriverA (LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam)
HDRVR WINAPI	OpenDriver (LPCWSTR lpDriverName, LPCWSTR lpSectionName, LPARAM lParam)
LRESULT WINAPI	CloseDriver (HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
DWORD WINAPI	GetDriverFlags (HDRVR hDrvr)
HMODULE WINAPI	GetDriverModuleHandle (HDRVR hDrvr)
LRESULT WINAPI	DefDriverProc (DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
static const char *	DRIVER_getCallback (DWORD uFlags)
BOOL WINAPI	DriverCallback (DWORD_PTR dwCallBack, DWORD uFlags, HDRVR hDev, DWORD wMsg, DWORD_PTR dwUser, DWORD_PTR dwParam1, DWORD_PTR dwParam2)
void	DRIVER_UnloadAll (void)

Variables
static CRITICAL_SECTION	mmdriver_lock = { &mmdriver_lock_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	mmdriver_lock_debug
static LPWINE_DRIVER	lpDrvItemList
static const WCHAR	HKLM_BASE []

Function Documentation

CloseDriver()

LRESULT WINAPI CloseDriver	(	HDRVR	hDrvr,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 462 of file driver.c.

{
    BOOL ret;
    LPWINE_DRIVER   lpDrv;
 
    TRACE("(%p, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 
    DRIVER_Dump("BEFORE:");
 
    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL)
    {
        LPWINE_DRIVER lpDrv0;
 
        DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
 
        DRIVER_RemoveFromList(lpDrv);
 
        if (lpDrv->dwFlags & WINE_GDF_SESSION)
            FIXME("WINE_GDF_SESSION: Shouldn't happen (%p)\n", lpDrv);
        /* if driver has an opened session instance, we have to close it too */
        if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, &lpDrv0) == 1 &&
            (lpDrv0->dwFlags & WINE_GDF_SESSION))
        {
            DRIVER_SendMessage(lpDrv0, DRV_CLOSE, 0, 0);
            DRIVER_RemoveFromList(lpDrv0);
            FreeLibrary(lpDrv0->hModule);
            HeapFree(GetProcessHeap(), 0, lpDrv0);
        }
        FreeLibrary(lpDrv->hModule);
 
        HeapFree(GetProcessHeap(), 0, lpDrv);
        ret = TRUE;
    }
    else
    {
        WARN("Failed to close driver\n");
        ret = FALSE;
    }
 
    DRIVER_Dump("AFTER:");
 
    return ret;
}

Referenced by acmDriverClose(), DRIVER_TryOpenDriver32(), DRIVER_UnloadAll(), ICClose(), ICOpen(), MCI_UnLoadMciDriver(), MCIWndProc(), MMDRV_Exit(), and MMDRV_Install().

DefDriverProc()

LRESULT WINAPI DefDriverProc	(	DWORD_PTR	dwDriverIdentifier,
		HDRVR	hDrv,
		UINT	Msg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 554 of file driver.c.

{
    switch (Msg) {
    case DRV_LOAD:
    case DRV_FREE:
    case DRV_ENABLE:
    case DRV_DISABLE:
        return 1;
    case DRV_INSTALL:
    case DRV_REMOVE:
        return DRV_SUCCESS;
    default:
        return 0;
    }
}

Referenced by acm_driver_func(), ADPCM_DriverProc(), DriverProc(), G711_DriverProc(), GSM_DriverProc(), MCIAVI_DriverProc(), MCICDA_DriverProc(), MCIMIDI_DriverProc(), MCIQTZ_DriverProc(), MCIWAVE_DriverProc(), MIDIMAP_DriverProc(), MPEG3_DriverProc(), MSRLE32_DriverProc(), PCM_DriverProc(), and WAVEMAP_DriverProc().

DRIVER_AddToList()

static BOOL DRIVER_AddToList ( LPWINE_DRIVER  lpNewDrv, LPARAM  lParam1, LPARAM  lParam2  )

static

Definition at line 187 of file driver.c.

{
    lpNewDrv->dwMagic = WINE_DI_MAGIC;
    /* First driver to be loaded for this module, need to load correctly the module */
    /* first of this driver in list ? */
    if (DRIVER_GetNumberOfModuleRefs(lpNewDrv->hModule, NULL) == 0) {
        if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
            TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
            return FALSE;
        }
        /* returned value is not checked */
        DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
    }
 
    /* Now just open a new instance of a driver on this module */
    lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
 
    if (lpNewDrv->dwDriverID == 0)
    {
        TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
        return FALSE;
    }
 
    EnterCriticalSection( &mmdriver_lock );
 
    lpNewDrv->lpNextItem = NULL;
    if (lpDrvItemList == NULL) {
    lpDrvItemList = lpNewDrv;
    lpNewDrv->lpPrevItem = NULL;
    } else {
    LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
    while (lpDrv->lpNextItem != NULL)
        lpDrv = lpDrv->lpNextItem;
 
    lpDrv->lpNextItem = lpNewDrv;
    lpNewDrv->lpPrevItem = lpDrv;
    }
 
    LeaveCriticalSection( &mmdriver_lock );
    return TRUE;
}

Referenced by DRIVER_TryOpenDriver32(), and OpenDriver().

DRIVER_Dump()

static void DRIVER_Dump ( const char *  comment )

static

Definition at line 40 of file driver.c.

{
#if 0
    LPWINE_DRIVER   lpDrv;
 
    TRACE("%s\n", comment);
 
    EnterCriticalSection( &mmdriver_lock );
 
    for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpDrv->lpNextItem)
    {
        TRACE("%p, magic %04lx, id %p, next %p\n", lpDrv, lpDrv->dwMagic, lpDrv->d.d32.dwDriverID, lpDrv->lpNextItem);
    }
 
    LeaveCriticalSection( &mmdriver_lock );
#endif
}

Referenced by CloseDriver().

DRIVER_FindFromHDrvr()

LPWINE_DRIVER DRIVER_FindFromHDrvr

(

HDRVR

hDrvr

)

Definition at line 89 of file driver.c.

{
    LPWINE_DRIVER d;
 
    __TRY
    {
        d = (LPWINE_DRIVER)hDrvr;
        if (d && d->dwMagic != WINE_DI_MAGIC) d = NULL;
    }
    __EXCEPT_PAGE_FAULT
    {
        return NULL;
    }
    __ENDTRY;
 
    if (d) TRACE("%p -> %p, %p\n", hDrvr, d->lpDrvProc, (void *)d->dwDriverID);
    else TRACE("%p -> NULL\n", hDrvr);
 
    return d;
}

Referenced by CloseDriver(), GetDriverFlags(), GetDriverModuleHandle(), MMDRV_Install(), and SendDriverMessage().

DRIVER_getCallback()

static const char * DRIVER_getCallback ( DWORD  uFlags )

static

Definition at line 574 of file driver.c.

{
    switch(uFlags & DCB_TYPEMASK) {
    case DCB_NULL:     return "null";
    case DCB_WINDOW:   return "window";
    case DCB_TASK:     return "task";
    case DCB_EVENT:    return "event";
    case DCB_FUNCTION: return "32bit function";
    default:           return "UNKNOWN";
    }
}

Referenced by DriverCallback().

DRIVER_GetLibName()

BOOL DRIVER_GetLibName	(	LPCWSTR	keyName,
		LPCWSTR	sectName,
		LPWSTR	buf,
		int	sz
	)

Definition at line 233 of file driver.c.

{
    HKEY    hKey, hSecKey;
    DWORD   bufLen, lRet;
    static const WCHAR wszSystemIni[] = {'S','Y','S','T','E','M','.','I','N','I',0};
    WCHAR       wsznull = '\0';
 
    /* This takes us as far as Windows NT\CurrentVersion */
    lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HKLM_BASE, 0, KEY_QUERY_VALUE, &hKey);
 
    if (lRet == ERROR_SUCCESS)
    {
        /* Now we descend into the section name that we were given */
        lRet = RegOpenKeyExW(hKey, sectName, 0, KEY_QUERY_VALUE, &hSecKey);
 
        if (lRet == ERROR_SUCCESS)
        {
            /* Retrieve the desired value - this is the filename of the lib */
            bufLen = sz;
            lRet = RegQueryValueExW(hSecKey, keyName, 0, 0, (void*)buf, &bufLen);
            RegCloseKey( hSecKey );
        }
 
        RegCloseKey( hKey );
    }
 
    /* Finish up if we've got what we want from the registry */
    if (lRet == ERROR_SUCCESS)
        return TRUE;
 
    /* default to system.ini if we can't find it in the registry,
     * to support native installations where system.ini is still used */
    return GetPrivateProfileStringW(sectName, keyName, &wsznull, buf, sz / sizeof(WCHAR), wszSystemIni);
}

Referenced by MCI_OpenMciDriver(), mciSendStringW(), and OpenDriver().

DRIVER_GetNumberOfModuleRefs()

static unsigned DRIVER_GetNumberOfModuleRefs ( HMODULE  hModule, WINE_DRIVER **  found  )

static

Definition at line 63 of file driver.c.

{
    LPWINE_DRIVER   lpDrv;
    unsigned        count = 0;
 
    EnterCriticalSection( &mmdriver_lock );
 
    if (found) *found = NULL;
    for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem)
    {
    if (lpDrv->hModule == hModule)
        {
            if (found && !*found) *found = lpDrv;
        count++;
    }
    }
 
    LeaveCriticalSection( &mmdriver_lock );
    return count;
}

Referenced by CloseDriver(), DRIVER_AddToList(), DRIVER_RemoveFromList(), and DRIVER_TryOpenDriver32().

DRIVER_RemoveFromList()

static BOOL DRIVER_RemoveFromList ( LPWINE_DRIVER  lpDrv )

static

Definition at line 155 of file driver.c.

{
    /* last of this driver in list ? */
    if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 1) {
        DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
        DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
    }
 
    EnterCriticalSection( &mmdriver_lock );
 
    if (lpDrv->lpPrevItem)
    lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
    else
    lpDrvItemList = lpDrv->lpNextItem;
    if (lpDrv->lpNextItem)
    lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
    /* trash magic number */
    lpDrv->dwMagic ^= 0xa5a5a5a5;
    lpDrv->lpDrvProc = NULL;
    lpDrv->dwDriverID = 0;
 
    LeaveCriticalSection( &mmdriver_lock );
 
    return TRUE;
}

Referenced by CloseDriver().

DRIVER_SendMessage()

static LRESULT DRIVER_SendMessage ( LPWINE_DRIVER  lpDrv, UINT  msg, LPARAM  lParam1, LPARAM  lParam2  )

inlinestatic

Definition at line 113 of file driver.c.

{
    LRESULT     ret = 0;
 
    TRACE("Before call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx\n",
          lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2);
    ret = lpDrv->lpDrvProc(lpDrv->dwDriverID, (HDRVR)lpDrv, msg, lParam1, lParam2);
    TRACE("After  call32 proc=%p drvrID=%08lx hDrv=%p wMsg=%04x p1=%08lx p2=%08lx => %08lx\n",
          lpDrv->lpDrvProc, lpDrv->dwDriverID, lpDrv, msg, lParam1, lParam2, ret);
 
    return ret;
}

Referenced by CloseDriver(), DRIVER_AddToList(), DRIVER_RemoveFromList(), and SendDriverMessage().

DRIVER_TryOpenDriver32()

LPWINE_DRIVER DRIVER_TryOpenDriver32	(	LPCWSTR	fn,
		LPARAM	lParam2
	)

Definition at line 273 of file driver.c.

{
    LPWINE_DRIVER   lpDrv = NULL;
    HMODULE     hModule = 0;
    LPWSTR      ptr;
    LPCSTR      cause = 0;
 
    TRACE("(%s, %08lX);\n", debugstr_w(fn), lParam2);
 
    if ((ptr = strchrW(fn, ' ')) != NULL)
    {
        *ptr++ = '\0';
 
        while (*ptr == ' ')
            ptr++;
 
        if (*ptr == '\0')
            ptr = NULL;
    }
 
    lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER));
 
    if (lpDrv == NULL)
    {
        cause = "OOM";
        goto exit;
    }
 
    if ((hModule = LoadLibraryW(fn)) == 0)
    {
        cause = "Not a 32 bit lib";
        goto exit;
    }
 
    lpDrv->lpDrvProc = (DRIVERPROC)GetProcAddress(hModule, "DriverProc");
 
    if (lpDrv->lpDrvProc == NULL)
    {
        cause = "no DriverProc";
        goto exit;
    }
 
    lpDrv->dwFlags          = 0;
    lpDrv->hModule    = hModule;
    lpDrv->dwDriverID = 0;
 
    /* Win32 installable drivers must support a two phase opening scheme:
     * + first open with NULL as lParam2 (session instance),
     * + then do a second open with the real non null lParam2)
     */
    if (DRIVER_GetNumberOfModuleRefs(lpDrv->hModule, NULL) == 0 && lParam2)
    {
        LPWINE_DRIVER   ret;
 
        if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, 0L))
        {
            cause = "load0 failed";
            goto exit;
        }
        ret = DRIVER_TryOpenDriver32(fn, lParam2);
        if (!ret)
        {
            CloseDriver((HDRVR)lpDrv, 0L, 0L);
            cause = "load1 failed";
            goto exit;
        }
        return ret;
    }
 
    if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2))
    {
        cause = "load failed";
        goto exit;
    }
 
    TRACE("=> %p\n", lpDrv);
    return lpDrv;
 
 exit:
    FreeLibrary(hModule);
    HeapFree(GetProcessHeap(), 0, lpDrv);
    TRACE("Unable to load 32 bit module %s: %s\n", debugstr_w(fn), cause);
    return NULL;
}

Referenced by DRIVER_TryOpenDriver32(), MCI_OpenMciDriver(), and OpenDriver().

DRIVER_UnloadAll()

void DRIVER_UnloadAll

(

void

)

Definition at line 658 of file driver.c.

{
    LPWINE_DRIVER   lpDrv;
    LPWINE_DRIVER   lpNextDrv = NULL;
    unsigned            count = 0;
 
restart:
    EnterCriticalSection( &mmdriver_lock );
 
    for (lpDrv = lpDrvItemList; lpDrv != NULL; lpDrv = lpNextDrv)
    {
        lpNextDrv = lpDrv->lpNextItem;
 
        /* session instances will be unloaded automatically */
        if (!(lpDrv->dwFlags & WINE_GDF_SESSION))
        {
            LeaveCriticalSection( &mmdriver_lock );
            CloseDriver((HDRVR)lpDrv, 0, 0);
            count++;
            /* restart from the beginning of the list */
            goto restart;
        }
    }
 
    LeaveCriticalSection( &mmdriver_lock );
 
    TRACE("Unloaded %u drivers\n", count);
}

Referenced by DllMain().

DriverCallback()

BOOL WINAPI DriverCallback	(	DWORD_PTR	dwCallBack,
		DWORD	uFlags,
		HDRVR	hDev,
		DWORD	wMsg,
		DWORD_PTR	dwUser,
		DWORD_PTR	dwParam1,
		DWORD_PTR	dwParam2
	)

Definition at line 589 of file driver.c.

{
    BOOL ret = FALSE;
    TRACE("(%08lX, %s %04X, %p, %04X, %08lX, %08lX, %08lX)\n",
      dwCallBack, DRIVER_getCallback(uFlags), uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
    if (!dwCallBack)
    return ret;
 
    switch (uFlags & DCB_TYPEMASK) {
    case DCB_NULL:
    /* Native returns FALSE = no notification, not TRUE */
    return ret;
    case DCB_WINDOW:
    ret = PostMessageA((HWND)dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
    break;
    case DCB_TASK: /* aka DCB_THREAD */
    ret = PostThreadMessageA(dwCallBack, wMsg, (WPARAM)hDev, dwParam1);
    break;
    case DCB_FUNCTION:
    ((LPDRVCALLBACK)dwCallBack)(hDev, wMsg, dwUser, dwParam1, dwParam2);
    ret = TRUE;
    break;
    case DCB_EVENT:
    ret = SetEvent((HANDLE)dwCallBack);
    break;
#if 0
        /* FIXME: for now only usable in mmsystem.dll16
         * If needed, should be enabled back
         */
    case 6: /* I would dub it DCB_MMTHREADSIGNAL */
    /* this is an undocumented DCB_ value used for mmThreads
     * loword of dwCallBack contains the handle of the lpMMThd block
     * which dwSignalCount has to be incremented
     */     
        if (pFnGetMMThread16)
    {
        WINE_MMTHREAD*  lpMMThd = pFnGetMMThread16(LOWORD(dwCallBack));
 
        TRACE("mmThread (%04x, %p) !\n", LOWORD(dwCallBack), lpMMThd);
        /* same as mmThreadSignal16 */
        InterlockedIncrement(&lpMMThd->dwSignalCount);
        SetEvent(lpMMThd->hEvent);
        /* some other stuff on lpMMThd->hVxD */
    }
    break;
#endif
#if 0
    case 4:
    /* this is an undocumented DCB_ value for... I don't know */
    break;
#endif
    default:
    WARN("Unknown callback type %d\n", uFlags & DCB_TYPEMASK);
    return FALSE;
    }
    if (ret)
    TRACE("Done\n");
    else
    WARN("Notification failure\n");
    return ret;
}

GetDriverFlags()

DWORD WINAPI GetDriverFlags

(

HDRVR

hDrvr

)

Definition at line 519 of file driver.c.

{
    LPWINE_DRIVER   lpDrv;
    DWORD       ret = 0;
 
    TRACE("(%p)\n", hDrvr);
 
    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
    ret = WINE_GDF_EXIST | (lpDrv->dwFlags & WINE_GDF_EXTERNAL_MASK);
    }
    return ret;
}

GetDriverModuleHandle()

HMODULE WINAPI GetDriverModuleHandle

(

HDRVR

hDrvr

)

Definition at line 536 of file driver.c.

{
    LPWINE_DRIVER   lpDrv;
    HMODULE     hModule = 0;
 
    TRACE("(%p);\n", hDrvr);
 
    if ((lpDrv = DRIVER_FindFromHDrvr(hDrvr)) != NULL) {
        hModule = lpDrv->hModule;
    }
    TRACE("=> %p\n", hModule);
    return hModule;
}

Referenced by MCI_HandleReturnValues().

OpenDriver()

HDRVR WINAPI OpenDriver	(	LPCWSTR	lpDriverName,
		LPCWSTR	lpSectionName,
		LPARAM	lParam
	)

Definition at line 400 of file driver.c.

{
    LPWINE_DRIVER   lpDrv = NULL;
    WCHAR       libName[128];
    LPCWSTR     lsn = lpSectionName;
 
    TRACE("(%s, %s, 0x%08lx);\n", 
          debugstr_w(lpDriverName), debugstr_w(lpSectionName), lParam);
 
    /* If no section name is specified, either the caller is intending on
       opening a driver by filename, or wants to open a user-installable
       driver that has an entry in the Drivers32 key in the registry */
    if (lsn == NULL)
    {
        /* Default registry key */
        static const WCHAR wszDrivers32[] = {'D','r','i','v','e','r','s','3','2',0};
 
        lstrcpynW(libName, lpDriverName, sizeof(libName) / sizeof(WCHAR));
 
        /* Try and open the driver by filename */
        if ( (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)) )
            goto the_end;
 
        /* If we got here, the file wasn't found. So we assume the caller
           wanted a driver specified under the Drivers32 registry key */
        lsn = wszDrivers32;
    }
 
    /* Attempt to locate the driver filename in the registry */
    if ( DRIVER_GetLibName(lpDriverName, lsn, libName, sizeof(libName)) )
    {
        /* Now we have the filename, we can try and load it */
        if ( (lpDrv = DRIVER_TryOpenDriver32(libName, lParam)) )
            goto the_end;
    }
 
    /* now we will try a 16 bit driver (and add all the glue to make it work... which
     * is located in our mmsystem implementation)
     * so ensure, we can load our mmsystem, otherwise just fail
     */
    WINMM_CheckForMMSystem();
#if 0
    if (pFnOpenDriver16 &&
        (lpDrv = pFnOpenDriver16(lpDriverName, lpSectionName, lParam)))
    {
        if (DRIVER_AddToList(lpDrv, 0, lParam)) goto the_end;
        HeapFree(GetProcessHeap(), 0, lpDrv);
    }
    TRACE("Failed to open driver %s from system.ini file, section %s\n", 
          debugstr_w(lpDriverName), debugstr_w(lpSectionName));
#endif
    return 0;
 
 the_end:
    if (lpDrv)  TRACE("=> %p\n", lpDrv);
    return (HDRVR)lpDrv;
}

Referenced by acmDriverOpen(), ICOpen(), MCIWndProc(), MSACM_FormatEnumHelper(), and OpenDriverA().

OpenDriverA()

HDRVR WINAPI OpenDriverA	(	LPCSTR	lpDriverName,
		LPCSTR	lpSectionName,
		LPARAM	lParam
	)

Definition at line 365 of file driver.c.

{
    INT                 len;
    LPWSTR      dn = NULL;
    LPWSTR      sn = NULL;
    HDRVR       ret = 0;
 
    if (lpDriverName)
    {
        len = MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, NULL, 0 );
        dn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
        if (!dn) goto done;
        MultiByteToWideChar( CP_ACP, 0, lpDriverName, -1, dn, len );
    }
 
    if (lpSectionName)
    {
        len = MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, NULL, 0 );
        sn = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
        if (!sn) goto done;
        MultiByteToWideChar( CP_ACP, 0, lpSectionName, -1, sn, len );
    }
 
    ret = OpenDriver(dn, sn, lParam);
 
done:
    HeapFree(GetProcessHeap(), 0, dn);
    HeapFree(GetProcessHeap(), 0, sn);
    return ret;
}

Referenced by JOY_LoadDriver(), and MMDRV_Install().

SendDriverMessage()

LRESULT WINAPI SendDriverMessage	(	HDRVR	hDriver,
		UINT	msg,
		LPARAM	lParam1,
		LPARAM	lParam2
	)

Definition at line 131 of file driver.c.

{
    LPWINE_DRIVER   lpDrv;
    LRESULT         retval = 0;
 
    TRACE("(%p, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
 
    if ((lpDrv = DRIVER_FindFromHDrvr(hDriver)) != NULL) {
    retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
    } else {
    WARN("Bad driver handle %p\n", hDriver);
    }
    TRACE("retval = %ld\n", retval);
 
    return retval;
}

Referenced by joyGetDevCapsW(), joyGetNumDevs(), joyGetPos(), joyGetPosEx(), MCI_SendCommandFrom32(), MCIWndProc(), MSACM_FormatEnumHelper(), MSACM_Message(), and MSVIDEO_SendMessage().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

driver

)

Variable Documentation

HKLM_BASE

const WCHAR HKLM_BASE[]

static

Initial value:

= {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
                                  'W','i','n','d','o','w','s',' ','N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n',0}

Definition at line 37 of file driver.c.

Referenced by DRIVER_GetLibName().

lpDrvItemList

LPWINE_DRIVER lpDrvItemList

static

Definition at line 36 of file driver.c.

Referenced by DRIVER_AddToList(), DRIVER_Dump(), DRIVER_GetNumberOfModuleRefs(), DRIVER_RemoveFromList(), and DRIVER_UnloadAll().

mmdriver_lock

static CRITICAL_SECTION mmdriver_lock = { &mmdriver_lock_debug, -1, 0, 0, 0, 0 }

static

Definition at line 27 of file driver.c.

Referenced by DRIVER_AddToList(), DRIVER_Dump(), DRIVER_GetNumberOfModuleRefs(), DRIVER_RemoveFromList(), and DRIVER_UnloadAll().

mmdriver_lock_debug

CRITICAL_SECTION_DEBUG mmdriver_lock_debug

static

Initial value:

=
{
    0, 0, &mmdriver_lock,
    { &mmdriver_lock_debug.ProcessLocksList, &mmdriver_lock_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": mmdriver_lock") }
}

Definition at line 28 of file driver.c.