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