kernel.c File Reference

#include "mmdrv.h"
#include <winuser.h>
#include <debug.h>

Include dependency graph for kernel.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
MMRESULT	CobbleDeviceName (DeviceType device_type, UINT device_id, PWCHAR out_device_name)
MMRESULT	OpenKernelDevice (DeviceType device_type, UINT device_id, DWORD access, HANDLE *handle)
void	CloseKernelDevice (HANDLE device_handle)
MMRESULT	SetDeviceData (HANDLE device_handle, DWORD ioctl, PBYTE input_buffer, DWORD buffer_size)
MMRESULT	GetDeviceData (HANDLE device_handle, DWORD ioctl, PBYTE output_buffer, DWORD buffer_size)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 16 of file kernel.c.

Function Documentation

CloseKernelDevice()

void CloseKernelDevice

(

HANDLE

device_handle

)

Definition at line 132 of file kernel.c.

{
    CloseHandle(device_handle);
}

Referenced by CloseDevice(), and GetDeviceCapabilities().

CobbleDeviceName()

MMRESULT CobbleDeviceName	(	DeviceType	device_type,
		UINT	device_id,
		PWCHAR	out_device_name
	)

Definition at line 28 of file kernel.c.

{
    WCHAR base_device_name[MAX_DEVICE_NAME_LENGTH];
 
    /* Work out the base name from the device type */
 
    switch ( device_type )
    {
        case WaveOutDevice :
            wsprintf(base_device_name, L"%ls", WAVE_OUT_DEVICE_NAME);
            break;
 
        case WaveInDevice :
            wsprintf(base_device_name, L"%ls", WAVE_IN_DEVICE_NAME);
            break;
 
        case MidiOutDevice :
            wsprintf(base_device_name, L"%ls", MIDI_OUT_DEVICE_NAME);
            break;
 
        case MidiInDevice :
            wsprintf(base_device_name, L"%ls", MIDI_IN_DEVICE_NAME);
            break;
 
        case AuxDevice :
            wsprintf(base_device_name, L"%ls", AUX_DEVICE_NAME);
            break;
 
        default :
            return MMSYSERR_BADDEVICEID;
    };
 
    /* Now append the device number, removing the leading \Device */
 
    wsprintf(out_device_name,
             L"\\\\.%ls%d",
             base_device_name + strlen("\\Device"),
             device_id);
 
    return MMSYSERR_NOERROR;
}

Referenced by OpenKernelDevice().

GetDeviceData()

MMRESULT GetDeviceData	(	HANDLE	device_handle,
		DWORD	ioctl,
		PBYTE	output_buffer,
		DWORD	buffer_size
	)

Definition at line 152 of file kernel.c.

{
    OVERLAPPED overlap;
    DWORD bytes_returned;
    BOOL success;
    DWORD transfer;
 
    DPRINT("GetDeviceData\n");
 
    memset(&overlap, 0, sizeof(overlap));
 
    overlap.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 
    if ( ! overlap.hEvent )
        return MMSYSERR_NOMEM;
 
    success = DeviceIoControl(device_handle,
                              ioctl,
                              NULL,
                              0,
                              output_buffer,
                              buffer_size,
                              &bytes_returned,
                              &overlap);
 
    if ( ! success )
    {
        if ( GetLastError() == ERROR_IO_PENDING )
        {
            if ( ! GetOverlappedResult(device_handle, &overlap, &transfer, TRUE) )
            {
                CloseHandle(overlap.hEvent);
                return ErrorToMmResult(GetLastError());
            }
        }
        else
        {
            CloseHandle(overlap.hEvent);
            return ErrorToMmResult(GetLastError());
        }
    }
 
    while ( TRUE )
    {
        SetEvent(overlap.hEvent);
 
        if ( WaitForSingleObjectEx(overlap.hEvent, 0, TRUE) != WAIT_IO_COMPLETION )
        {
            break;
        }
    }
 
    CloseHandle(overlap.hEvent);
 
    return MMSYSERR_NOERROR;
}

OpenKernelDevice()

MMRESULT OpenKernelDevice	(	DeviceType	device_type,
		UINT	device_id,
		DWORD	access,
		HANDLE *	handle
	)

Definition at line 84 of file kernel.c.

{
    MMRESULT result;
    WCHAR device_name[MAX_DEVICE_NAME_LENGTH];
    DWORD open_flags = 0;
 
    ASSERT(handle);
 
    /* Glue the base device name and the ID together */
 
    result = CobbleDeviceName(device_type, device_id, device_name);
 
    DPRINT("Opening kernel device %ls\n", device_name);
 
    if ( result != MMSYSERR_NOERROR )
        return result;
 
    /* We want overlapped I/O when writing */
 
    if ( access != GENERIC_READ )
        open_flags = FILE_FLAG_OVERLAPPED;
 
    /* Now try opening... */
 
    *handle = CreateFile(device_name,
                         access,
                         FILE_SHARE_WRITE,
                         NULL,
                         OPEN_EXISTING,
                         open_flags,
                         NULL);
 
    if ( *handle == INVALID_HANDLE_VALUE )
        return ErrorToMmResult(GetLastError());
 
    return MMSYSERR_NOERROR;
}

Referenced by GetDeviceCapabilities(), GetDeviceCount(), and OpenDevice().

SetDeviceData()

MMRESULT SetDeviceData	(	HANDLE	device_handle,
		DWORD	ioctl,
		PBYTE	input_buffer,
		DWORD	buffer_size
	)

Definition at line 139 of file kernel.c.

{
    DPRINT("SetDeviceData\n");
    /* TODO */
    return 0;
}

Referenced by ProcessSessionThreadRequest().