windows/driver.c

   1 /*
   2  * Wine Drivers functions
   3  *
   4  * Copyright 1994 Martin Ayotte
   5 */
   6
   7 #include <stdio.h>
   8 #include "windows.h"
   9 #include "win.h"
  10 #include "callback.h"
  11 #include "driver.h"
  12 #include "module.h"
  13 #include "stddebug.h"
  14 #include "debug.h"
  15
  16 LPDRIVERITEM lpDrvItemList = NULL;
  17
  18 void LoadStartupDrivers(void)
  19 {
  20     HDRVR16 hDrv;
  21     char  str[256];
  22     LPSTR ptr;
  23
  24     if (GetPrivateProfileString32A( "drivers", NULL, "", str, sizeof(str),
  25                                  "SYSTEM.INI" ) < 2)
  26     {
  27         fprintf( stderr,
  28                  "LoadStartupDrivers // can't find drivers section in system.ini\n" );
  29         return;
  30     }
  31
  32     ptr = str;
  33     while (lstrlen32A( ptr ) != 0)
  34     {
  35         dprintf_driver( stddeb, "LoadStartupDrivers // str='%s'\n", ptr );
  36         hDrv = OpenDriver( ptr, "drivers", 0L );
  37         dprintf_driver( stddeb, "LoadStartupDrivers // hDrv=%04x\n", hDrv );
  38         ptr += lstrlen32A(ptr) + 1;
  39     }
  40     dprintf_driver( stddeb, "LoadStartupDrivers // end of list !\n" );
  41
  42     return;
  43 }
  44
  45 /**************************************************************************
  46  *                              SendDriverMessage               [USER.251]
  47  */
  48 LRESULT SendDriverMessage(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1,
  49                           LPARAM lParam2)
  50 {
  51     LPDRIVERITEM lpdrv;
  52     LRESULT retval;
  53
  54     dprintf_driver( stddeb, "SendDriverMessage(%04x, %04X, %08lX, %08lX)\n",
  55                     hDriver, msg, lParam1, lParam2 );
  56
  57     lpdrv = (LPDRIVERITEM)GlobalLock16( hDriver );
  58     if (lpdrv == NULL || lpdrv->dis.hDriver != hDriver)
  59     {
  60         GlobalUnlock16( hDriver );
  61         return 0;
  62     }
  63
  64     retval = CallDriverProc( lpdrv->lpDrvProc, 0L /* FIXME */, hDriver, msg,
  65                              lParam1, lParam2 );
  66
  67     dprintf_driver( stddeb, "SendDriverMessage // retval = %ld\n", retval );
  68
  69     GlobalUnlock16( hDriver );
  70     return retval;
  71 }
  72
  73 /**************************************************************************
  74  *                              OpenDriver                      [USER.252]
  75  */
  76 HDRVR16 OpenDriver(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
  77 {
  78     HDRVR16 hDrvr;
  79     LPDRIVERITEM lpdrv, lpnewdrv;
  80     char DrvName[128];
  81     WORD ordinal;
  82
  83     dprintf_driver( stddeb,"OpenDriver('%s', '%s', %08lX);\n",
  84                     lpDriverName, lpSectionName, lParam );
  85
  86     if (lpSectionName == NULL) lpSectionName = "drivers";
  87     GetPrivateProfileString32A( lpSectionName, lpDriverName, "", DrvName,
  88                              sizeof(DrvName), "SYSTEM.INI" );
  89     dprintf_driver( stddeb,"OpenDriver // DrvName='%s'\n", DrvName );
  90     if (lstrlen32A(DrvName) < 1) return 0;
  91
  92     lpdrv = lpDrvItemList;
  93     while (lpdrv)                       /* XXX find it... like this? */
  94     {
  95         if (!lstrcmpi32A( lpDriverName, lpdrv->dis.szAliasName ))
  96         {
  97             lpdrv->count++;
  98             SendDriverMessage( lpdrv->dis.hDriver, DRV_OPEN, 0L, lParam );
  99             return lpdrv->dis.hDriver;
 100         }
 101         lpdrv = lpdrv->lpNextItem;
 102     }
 103
 104     lpdrv = lpDrvItemList;      /* find end of list */
 105     if (lpdrv != NULL)
 106       while (lpdrv->lpNextItem != NULL)
 107         lpdrv = lpdrv->lpNextItem;
 108
 109     hDrvr = GlobalAlloc16( GMEM_MOVEABLE, sizeof(DRIVERITEM) );
 110     lpnewdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 111     if (lpnewdrv == NULL) return 0;
 112     lpnewdrv->dis.length = sizeof( DRIVERINFOSTRUCT16 );
 113     lpnewdrv->dis.hModule = LoadModule16( DrvName, (LPVOID)-1 );
 114     if (!lpnewdrv->dis.hModule)
 115     {
 116         GlobalUnlock16( hDrvr );
 117         GlobalFree16( hDrvr );
 118         return 0;
 119     }
 120     lpnewdrv->dis.hDriver = hDrvr;
 121     lstrcpy32A( lpnewdrv->dis.szAliasName, lpDriverName );
 122     lpnewdrv->count = 1;
 123     ordinal = MODULE_GetOrdinal( lpnewdrv->dis.hModule, "DRIVERPROC" );
 124     if (!ordinal ||
 125         !(lpnewdrv->lpDrvProc = (DRIVERPROC16)MODULE_GetEntryPoint(
 126                                              lpnewdrv->dis.hModule, ordinal )))
 127     {
 128         FreeModule16( lpnewdrv->dis.hModule );
 129         GlobalUnlock16( hDrvr );
 130         GlobalFree16( hDrvr );
 131         return 0;
 132     }
 133
 134     lpnewdrv->lpNextItem = NULL;
 135     if (lpDrvItemList == NULL)
 136     {
 137         lpDrvItemList = lpnewdrv;
 138         lpnewdrv->lpPrevItem = NULL;
 139     }
 140     else
 141     {
 142         lpdrv->lpNextItem = lpnewdrv;
 143         lpnewdrv->lpPrevItem = lpdrv;
 144     }
 145
 146     SendDriverMessage( hDrvr, DRV_LOAD, 0L, lParam );
 147     SendDriverMessage( hDrvr, DRV_ENABLE, 0L, lParam );
 148     SendDriverMessage( hDrvr, DRV_OPEN, 0L, lParam );
 149
 150     dprintf_driver( stddeb, "OpenDriver // hDrvr=%04x loaded !\n", hDrvr );
 151     return hDrvr;
 152 }
 153
 154 /**************************************************************************
 155  *                              CloseDriver                             [USER.253]
 156  */
 157 LRESULT CloseDriver(HDRVR16 hDrvr, LPARAM lParam1, LPARAM lParam2)
 158 {
 159     LPDRIVERITEM lpdrv;
 160
 161     dprintf_driver( stddeb, "CloseDriver(%04x, %08lX, %08lX);\n",
 162                     hDrvr, lParam1, lParam2 );
 163
 164     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 165     if (lpdrv != NULL && lpdrv->dis.hDriver == hDrvr)
 166     {
 167         SendDriverMessage( hDrvr, DRV_CLOSE, lParam1, lParam2 );
 168         if (--lpdrv->count == 0)
 169         {
 170             SendDriverMessage( hDrvr, DRV_DISABLE, lParam1, lParam2 );
 171             SendDriverMessage( hDrvr, DRV_FREE, lParam1, lParam2 );
 172
 173             if (lpdrv->lpPrevItem)
 174               lpdrv->lpPrevItem->lpNextItem = lpdrv->lpNextItem;
 175             else
 176                 lpDrvItemList = lpdrv->lpNextItem;
 177             if (lpdrv->lpNextItem)
 178               lpdrv->lpNextItem->lpPrevItem = lpdrv->lpPrevItem;
 179
 180             FreeModule16( lpdrv->dis.hModule );
 181             GlobalUnlock16( hDrvr );
 182             GlobalFree16( hDrvr );
 183         }
 184
 185         dprintf_driver( stddeb, "CloseDriver // hDrvr=%04x closed !\n",
 186                         hDrvr );
 187         return TRUE;
 188     }
 189     return FALSE;
 190 }
 191
 192 /**************************************************************************
 193  *                              GetDriverModuleHandle   [USER.254]
 194  */
 195 HMODULE16 GetDriverModuleHandle(HDRVR16 hDrvr)
 196 {
 197     LPDRIVERITEM lpdrv;
 198     HMODULE16 hModule = 0;
 199
 200     dprintf_driver( stddeb, "GetDriverModuleHandle(%04x);\n", hDrvr);
 201
 202     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 203     if (lpdrv != NULL && lpdrv->dis.hDriver == hDrvr)
 204     {
 205         hModule = lpdrv->dis.hModule;
 206         GlobalUnlock16( hDrvr );
 207     }
 208     return hModule;
 209 }
 210
 211 /**************************************************************************
 212  *                              DefDriverProc                   [USER.255]
 213  */
 214 LRESULT DefDriverProc(DWORD dwDevID, HDRVR16 hDriv, UINT16 wMsg,
 215                       LPARAM lParam1, LPARAM lParam2)
 216 {
 217     switch(wMsg)
 218     {
 219       case DRV_LOAD:
 220         return (LRESULT)0L;
 221       case DRV_FREE:
 222         return (LRESULT)0L;
 223       case DRV_OPEN:
 224         return (LRESULT)0L;
 225       case DRV_CLOSE:
 226         return (LRESULT)0L;
 227       case DRV_ENABLE:
 228         return (LRESULT)0L;
 229       case DRV_DISABLE:
 230         return (LRESULT)0L;
 231       case DRV_QUERYCONFIGURE:
 232         return (LRESULT)0L;
 233
 234       case DRV_CONFIGURE:
 235         MessageBox16( 0, "Driver isn't configurable !", "Wine Driver", MB_OK );
 236         return (LRESULT)0L;
 237
 238       case DRV_INSTALL:
 239         return (LRESULT)DRVCNF_RESTART;
 240
 241       case DRV_REMOVE:
 242         return (LRESULT)DRVCNF_RESTART;
 243
 244       default:
 245         return (LRESULT)0L;
 246     }
 247 }
 248
 249 /**************************************************************************
 250  *                              GetDriverInfo                   [USER.256]
 251  */
 252 BOOL16 GetDriverInfo(HDRVR16 hDrvr, LPDRIVERINFOSTRUCT16 lpDrvInfo)
 253 {
 254     LPDRIVERITEM lpdrv;
 255
 256     dprintf_driver( stddeb, "GetDriverInfo(%04x, %p);\n", hDrvr, lpDrvInfo );
 257
 258     if (lpDrvInfo == NULL) return FALSE;
 259
 260     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 261     if (lpdrv == NULL) return FALSE;
 262     memcpy( lpDrvInfo, &lpdrv->dis, sizeof(DRIVERINFOSTRUCT16) );
 263     GlobalUnlock16( hDrvr );
 264
 265     return TRUE;
 266 }
 267
 268 /**************************************************************************
 269  *                              GetNextDriver                   [USER.257]
 270  */
 271 HDRVR16 GetNextDriver(HDRVR16 hDrvr, DWORD dwFlags)
 272 {
 273     LPDRIVERITEM lpdrv;
 274     HDRVR16 hRetDrv = 0;
 275
 276     dprintf_driver( stddeb, "GetNextDriver(%04x, %08lX);\n", hDrvr, dwFlags );
 277
 278     if (hDrvr == 0)
 279     {
 280         if (lpDrvItemList == NULL)
 281         {
 282             dprintf_driver(stddeb, "GetNextDriver // drivers list empty !\n");
 283             LoadStartupDrivers();
 284             if (lpDrvItemList == NULL) return 0;
 285         }
 286         dprintf_driver( stddeb,"GetNextDriver // return first %04x !\n",
 287                         lpDrvItemList->dis.hDriver );
 288         return lpDrvItemList->dis.hDriver;
 289     }
 290
 291     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 292     if (lpdrv != NULL)
 293     {
 294         if (dwFlags & GND_REVERSE)
 295         {
 296             if (lpdrv->lpPrevItem)
 297               hRetDrv = lpdrv->lpPrevItem->dis.hDriver;
 298         }
 299         else
 300         {
 301             if (lpdrv->lpNextItem)
 302               hRetDrv = lpdrv->lpNextItem->dis.hDriver;
 303         }
 304         GlobalUnlock16( hDrvr );
 305     }
 306
 307     dprintf_driver( stddeb, "GetNextDriver // return %04x !\n", hRetDrv );
 308     return hRetDrv;
 309 }