misc/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 (GetPrivateProfileString( "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     GetPrivateProfileString( 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 = LoadModule( 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 = MODULE_GetEntryPoint( lpnewdrv->dis.hModule,
 126                                                       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, HDRVR 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         MessageBox( (HWND)NULL, "Driver isn't configurable !",
 236                     "Wine Driver", MB_OK );
 237         return (LRESULT)0L;
 238
 239       case DRV_INSTALL:
 240         return (LRESULT)DRVCNF_RESTART;
 241
 242       case DRV_REMOVE:
 243         return (LRESULT)DRVCNF_RESTART;
 244
 245       default:
 246         return (LRESULT)0L;
 247     }
 248 }
 249
 250 /**************************************************************************
 251  *                              GetDriverInfo                   [USER.256]
 252  */
 253 BOOL16 GetDriverInfo(HDRVR16 hDrvr, LPDRIVERINFOSTRUCT16 lpDrvInfo)
 254 {
 255     LPDRIVERITEM lpdrv;
 256
 257     dprintf_driver( stddeb, "GetDriverInfo(%04x, %p);\n", hDrvr, lpDrvInfo );
 258
 259     if (lpDrvInfo == NULL) return FALSE;
 260
 261     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 262     if (lpdrv == NULL) return FALSE;
 263     memcpy( lpDrvInfo, &lpdrv->dis, sizeof(DRIVERINFOSTRUCT16) );
 264     GlobalUnlock16( hDrvr );
 265
 266     return TRUE;
 267 }
 268
 269 /**************************************************************************
 270  *                              GetNextDriver                   [USER.257]
 271  */
 272 HDRVR16 GetNextDriver(HDRVR16 hDrvr, DWORD dwFlags)
 273 {
 274     LPDRIVERITEM lpdrv;
 275     HDRVR16 hRetDrv = 0;
 276
 277     dprintf_driver( stddeb, "GetNextDriver(%04x, %08lX);\n", hDrvr, dwFlags );
 278
 279     if (hDrvr == 0)
 280     {
 281         if (lpDrvItemList == NULL)
 282         {
 283             dprintf_driver(stddeb, "GetNextDriver // drivers list empty !\n");
 284             LoadStartupDrivers();
 285             if (lpDrvItemList == NULL) return 0;
 286         }
 287         dprintf_driver( stddeb,"GetNextDriver // return first %04x !\n",
 288                         lpDrvItemList->dis.hDriver );
 289         return lpDrvItemList->dis.hDriver;
 290     }
 291
 292     lpdrv = (LPDRIVERITEM)GlobalLock16( hDrvr );
 293     if (lpdrv != NULL)
 294     {
 295         if (dwFlags & GND_REVERSE)
 296         {
 297             if (lpdrv->lpPrevItem)
 298               hRetDrv = lpdrv->lpPrevItem->dis.hDriver;
 299         }
 300         else
 301         {
 302             if (lpdrv->lpNextItem)
 303               hRetDrv = lpdrv->lpNextItem->dis.hDriver;
 304         }
 305         GlobalUnlock16( hDrvr );
 306     }
 307
 308     dprintf_driver( stddeb, "GetNextDriver // return %04x !\n", hRetDrv );
 309     return hRetDrv;
 310 }