wined3d: Rename "NumberOfSwapChains" to "swapchain_count".
[wine] / dlls / mmsystem.dll16 / driver.c
1 /*
2  * WINE Drivers functions
3  *
4  * Copyright 1994 Martin Ayotte
5  * Copyright 1998 Marcus Meissner
6  * Copyright 1999,2000 Eric Pouech
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  *
22  * TODO:
23  *      - LoadModule count and clean up is not handled correctly (it's not a
24  *        problem as long as FreeLibrary is not working correctly)
25  */
26
27 #include <stdarg.h>
28 #include <string.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wine/winbase16.h"
33 #include "wingdi.h"
34 #include "winuser.h"
35 #include "wownt32.h"
36 #include "mmddk.h"
37 #include "wine/mmsystem16.h"
38 #include "wine/debug.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(driver);
41
42 typedef struct tagWINE_DRIVER
43 {
44     /* as usual LPWINE_DRIVER == hDriver32 */
45     HDRVR16                     hDriver16;
46     HMODULE16                   hModule16;
47     DRIVERPROC16                lpDrvProc;
48     DWORD                       dwDriverID;
49     struct tagWINE_DRIVER*      lpPrevItem;
50     struct tagWINE_DRIVER*      lpNextItem;
51 } WINE_DRIVER, *LPWINE_DRIVER;
52
53 static LPWINE_DRIVER    lpDrvItemList = NULL;
54
55
56 /**************************************************************************
57  *                      DRIVER_GetNumberOfModuleRefs            [internal]
58  *
59  * Returns the number of open drivers which share the same module.
60  */
61 static  WORD    DRIVER_GetNumberOfModuleRefs(LPWINE_DRIVER lpNewDrv)
62 {
63     LPWINE_DRIVER       lpDrv;
64     WORD                count = 0;
65
66     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
67         if (lpDrv->hModule16 == lpNewDrv->hModule16) {
68             count++;
69         }
70     }
71     return count;
72 }
73
74 /**************************************************************************
75  *                              DRIVER_FindFromHDrvr16          [internal]
76  *
77  * From a hDrvr being 16 bits, returns the WINE internal structure.
78  */
79 static  LPWINE_DRIVER   DRIVER_FindFromHDrvr16(HDRVR16 hDrvr)
80 {
81     LPWINE_DRIVER       lpDrv;
82
83     for (lpDrv = lpDrvItemList; lpDrv; lpDrv = lpDrv->lpNextItem) {
84         if (lpDrv->hDriver16 == hDrvr) {
85             break;
86         }
87     }
88     return lpDrv;
89 }
90
91 /**************************************************************************
92  *                              DRIVER_SendMessage              [internal]
93  */
94 static inline LRESULT DRIVER_SendMessage(LPWINE_DRIVER lpDrv, UINT16 msg,
95                                          LPARAM lParam1, LPARAM lParam2)
96 {
97     WORD args[8];
98     DWORD ret;
99
100     TRACE("Before CallDriverProc proc=%p driverID=%08x wMsg=%04x p1=%08lx p2=%08lx\n",
101           lpDrv->lpDrvProc, lpDrv->dwDriverID, msg, lParam1, lParam2);
102
103     args[7] = HIWORD(lpDrv->dwDriverID);
104     args[6] = LOWORD(lpDrv->dwDriverID);
105     args[5] = lpDrv->hDriver16;
106     args[4] = msg;
107     args[3] = HIWORD(lParam1);
108     args[2] = LOWORD(lParam1);
109     args[1] = HIWORD(lParam2);
110     args[0] = LOWORD(lParam2);
111     WOWCallback16Ex( (DWORD)lpDrv->lpDrvProc, WCB16_PASCAL, sizeof(args), args, &ret );
112     return ret;
113 }
114
115 /**************************************************************************
116  *              DrvSendMessage (MMSYSTEM.1102)
117  */
118 LRESULT WINAPI DrvSendMessage16(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1, LPARAM lParam2)
119 {
120     LPWINE_DRIVER       lpDrv;
121     LRESULT             retval = 0;
122
123     TRACE("(%04x, %04X, %08lX, %08lX)\n", hDriver, msg, lParam1, lParam2);
124
125     if ((lpDrv = DRIVER_FindFromHDrvr16(hDriver)) != NULL) {
126         retval = DRIVER_SendMessage(lpDrv, msg, lParam1, lParam2);
127     } else {
128         WARN("Bad driver handle %u\n", hDriver);
129     }
130
131     TRACE("retval = %ld\n", retval);
132     return retval;
133 }
134
135 /**************************************************************************
136  *                              DRIVER_RemoveFromList           [internal]
137  *
138  * Generates all the logic to handle driver closure / deletion
139  * Removes a driver struct to the list of open drivers.
140  */
141 static  BOOL    DRIVER_RemoveFromList(LPWINE_DRIVER lpDrv)
142 {
143     lpDrv->dwDriverID = 0;
144     if (DRIVER_GetNumberOfModuleRefs(lpDrv) == 1) {
145         DRIVER_SendMessage(lpDrv, DRV_DISABLE, 0L, 0L);
146         DRIVER_SendMessage(lpDrv, DRV_FREE,    0L, 0L);
147     }
148
149     if (lpDrv->lpPrevItem)
150         lpDrv->lpPrevItem->lpNextItem = lpDrv->lpNextItem;
151     else
152         lpDrvItemList = lpDrv->lpNextItem;
153     if (lpDrv->lpNextItem)
154         lpDrv->lpNextItem->lpPrevItem = lpDrv->lpPrevItem;
155
156     return TRUE;
157 }
158
159 /**************************************************************************
160  *                              DRIVER_AddToList                [internal]
161  *
162  * Adds a driver struct to the list of open drivers.
163  * Generates all the logic to handle driver creation / open.
164  */
165 static  BOOL    DRIVER_AddToList(LPWINE_DRIVER lpNewDrv, LPARAM lParam1, LPARAM lParam2)
166 {
167     /* First driver to be loaded for this module, need to load correctly the module */
168     if (DRIVER_GetNumberOfModuleRefs(lpNewDrv) == 0) {
169         if (DRIVER_SendMessage(lpNewDrv, DRV_LOAD, 0L, 0L) != DRV_SUCCESS) {
170             TRACE("DRV_LOAD failed on driver %p\n", lpNewDrv);
171             return FALSE;
172         }
173         /* returned value is not checked */
174         DRIVER_SendMessage(lpNewDrv, DRV_ENABLE, 0L, 0L);
175     }
176
177     lpNewDrv->lpNextItem = NULL;
178     if (lpDrvItemList == NULL) {
179         lpDrvItemList = lpNewDrv;
180         lpNewDrv->lpPrevItem = NULL;
181     } else {
182         LPWINE_DRIVER   lpDrv = lpDrvItemList;  /* find end of list */
183         while (lpDrv->lpNextItem != NULL)
184             lpDrv = lpDrv->lpNextItem;
185
186         lpDrv->lpNextItem = lpNewDrv;
187         lpNewDrv->lpPrevItem = lpDrv;
188     }
189     /* Now just open a new instance of a driver on this module */
190     lpNewDrv->dwDriverID = DRIVER_SendMessage(lpNewDrv, DRV_OPEN, lParam1, lParam2);
191
192     if (lpNewDrv->dwDriverID == 0) {
193         TRACE("DRV_OPEN failed on driver %p\n", lpNewDrv);
194         DRIVER_RemoveFromList(lpNewDrv);
195         return FALSE;
196     }
197
198     return TRUE;
199 }
200
201 /**************************************************************************
202  *                              DRIVER_TryOpenDriver16          [internal]
203  *
204  * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName.
205  */
206 static  LPWINE_DRIVER   DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam2)
207 {
208     static      WORD    DRIVER_hDrvr16Counter /* = 0 */;
209     LPWINE_DRIVER       lpDrv = NULL;
210     HMODULE16           hModule;
211     DRIVERPROC16        lpProc;
212     LPCSTR              lpSFN;
213     LPSTR               ptr;
214
215     TRACE("('%s', %08lX);\n", lpFileName, lParam2);
216
217     if (strlen(lpFileName) < 1) return lpDrv;
218
219     if ((lpSFN = strrchr(lpFileName, '\\')) == NULL)
220         lpSFN = lpFileName;
221     else
222         lpSFN++;
223     if ((ptr = strchr(lpFileName, ' ')) != NULL) {
224         *ptr++ = '\0';
225         while (*ptr == ' ') ptr++;
226         if (*ptr == '\0') ptr = NULL;
227     }
228
229     if ((hModule = LoadLibrary16(lpFileName)) < 32) goto exit;
230     if ((lpProc = (DRIVERPROC16)GetProcAddress16(hModule, "DRIVERPROC")) == NULL)
231         goto exit;
232
233     if ((lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER))) == NULL)
234         goto exit;
235
236     lpDrv->dwDriverID  = 0;
237     while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter));
238     lpDrv->hDriver16   = DRIVER_hDrvr16Counter;
239     lpDrv->hModule16   = hModule;
240     lpDrv->lpDrvProc   = lpProc;
241
242     if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2)) goto exit;
243
244     return lpDrv;
245  exit:
246     TRACE("Unable to load 16 bit module (%s): %04x\n", lpFileName, hModule);
247     if (hModule >= 32)  FreeLibrary16(hModule);
248     HeapFree(GetProcessHeap(), 0, lpDrv);
249     return NULL;
250 }
251
252 /**************************************************************************
253  *              DrvOpen (MMSYSTEM.1100)
254  */
255 HDRVR16 WINAPI DrvOpen16(LPCSTR lpDriverName, LPCSTR lpSectionName, LPARAM lParam2)
256 {
257     LPWINE_DRIVER       lpDrv = NULL;
258     char                drvName[128];
259
260     TRACE("(%s, %s, %08lX);\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName), lParam2);
261
262     if (!lpDriverName || !*lpDriverName) return 0;
263
264     if (lpSectionName == NULL) {
265         strcpy(drvName, lpDriverName);
266
267         if ((lpDrv = DRIVER_TryOpenDriver16(drvName, lParam2)))
268             goto the_end;
269         /* in case hDriver is NULL, search in Drivers section */
270         lpSectionName = "Drivers";
271     }
272     if (GetPrivateProfileStringA(lpSectionName, lpDriverName, "",
273                                  drvName, sizeof(drvName), "SYSTEM.INI") > 0) {
274         lpDrv = DRIVER_TryOpenDriver16(drvName, lParam2);
275     }
276     if (!lpDrv) {
277         TRACE("Failed to open driver %s from system.ini file, section %s\n", debugstr_a(lpDriverName), debugstr_a(lpSectionName));
278         return 0;
279     }
280  the_end:
281     TRACE("=> %04x / %p\n", lpDrv->hDriver16, lpDrv);
282     return lpDrv->hDriver16;
283 }
284
285 /**************************************************************************
286  *              DrvClose16 (MMSYSTEM.1101)
287  */
288 LRESULT WINAPI DrvClose16(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
289 {
290     LPWINE_DRIVER       lpDrv;
291
292     TRACE("(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
293
294     if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
295         DRIVER_SendMessage(lpDrv, DRV_CLOSE, lParam1, lParam2);
296
297         if (DRIVER_RemoveFromList(lpDrv)) {
298             HeapFree(GetProcessHeap(), 0, lpDrv);
299             return TRUE;
300         }
301     }
302     WARN("Failed to close driver\n");
303     return FALSE;
304 }
305
306 /**************************************************************************
307  *              DrvGetModuleHandle (MMSYSTEM.1103)
308  */
309 HMODULE16 WINAPI DrvGetModuleHandle16(HDRVR16 hDrvr)
310 {
311     LPWINE_DRIVER       lpDrv;
312     HMODULE16           hModule = 0;
313
314     TRACE("(%04x);\n", hDrvr);
315
316     if ((lpDrv = DRIVER_FindFromHDrvr16(hDrvr)) != NULL) {
317         hModule = lpDrv->hModule16;
318     }
319     TRACE("=> %04x\n", hModule);
320     return hModule;
321 }
322
323 /**************************************************************************
324  *              DrvDefDriverProc (MMSYSTEM.1104)
325  */
326 LRESULT WINAPI DrvDefDriverProc16(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
327                                   LPARAM lParam1, LPARAM lParam2)
328 {
329     TRACE("devID=0x%08x hDrv=0x%04x wMsg=%04x lP1=0x%08lx lP2=0x%08lx\n",
330           dwDevID, hDriv, wMsg, lParam1, lParam2);
331
332     switch(wMsg) {
333     case DRV_LOAD:
334     case DRV_FREE:
335     case DRV_ENABLE:
336     case DRV_DISABLE:
337         return (LRESULT)1L;
338     case DRV_OPEN:
339     case DRV_CLOSE:
340     case DRV_QUERYCONFIGURE:
341         return (LRESULT)0L;
342     case DRV_CONFIGURE:
343         MessageBoxA(0, "Driver isn't configurable !", "Wine Driver", MB_OK);
344         return (LRESULT)0L;
345     case DRV_INSTALL:
346     case DRV_REMOVE:
347         return DRV_SUCCESS;
348     default:
349         return (LRESULT)0L;
350     }
351 }
352
353 /**************************************************************************
354  *              DriverProc (MMSYSTEM.6)
355  */
356 LRESULT WINAPI DriverProc16(DWORD dwDevID, HDRVR16 hDrv, WORD wMsg,
357                             DWORD dwParam1, DWORD dwParam2)
358 {
359     return DrvDefDriverProc16(dwDevID, hDrv, wMsg, dwParam1, dwParam2);
360 }