misc/driver.c

   1 /*
   2  * Wine Drivers functions
   3  *
   4  * Copyright 1994 Martin Ayotte
   5 static char Copyright[] = "Copyright  Martin Ayotte, 1994";
   6 */
   7
   8 #include <stdio.h>
   9 #include "windows.h"
  10 #include "win.h"
  11 #include "user.h"
  12 #include "driver.h"
  13 #include "stddebug.h"
  14 #include "debug.h"
  15
  16 LPDRIVERITEM lpDrvItemList = NULL;
  17
  18 void LoadStartupDrivers(void)
  19 {
  20         HDRVR   hDrv;
  21         char    str[256];
  22         LPSTR   ptr     = str;
  23         LPSTR   file = "SYSTEM.INI";
  24         if (GetPrivateProfileString("drivers", NULL,
  25                 "", str, sizeof(str), file) < 2) {
  26                 fprintf(stderr,
  27                 "LoadStartupDrivers // can't find drivers section in '%s'\n",
  28                 file);
  29                 return;
  30                 }
  31         while(strlen(ptr) != 0) {
  32                 dprintf_driver(stddeb,"LoadStartupDrivers // str='%s'\n", ptr);
  33                 hDrv = OpenDriver(ptr, "drivers", 0L);
  34                 dprintf_driver(stddeb,
  35                         "LoadStartupDrivers // hDrv=%04x\n", hDrv);
  36                 ptr += strlen(ptr) + 1;
  37                 }
  38         dprintf_driver(stddeb,"LoadStartupDrivers // end of list !\n");
  39 }
  40
  41 /**************************************************************************
  42  *                              SendDriverMessage               [USER.251]
  43  */
  44 LRESULT SendDriverMessage(HDRVR hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2)
  45 {
  46         dprintf_driver(stdnimp,"SendDriverMessage(%04x, %04X, %08lX, %08lX);\n",
  47                                                 hDriver, msg, lParam1, lParam2);
  48         return 0;
  49 }
  50
  51 /**************************************************************************
  52  *                              OpenDriver                      [USER.252]
  53  */
  54 HDRVR OpenDriver(LPSTR lpDriverName, LPSTR lpSectionName, LPARAM lParam)
  55 {
  56         HDRVR                   hDrvr;
  57         LPDRIVERITEM    lpnewdrv;
  58         LPDRIVERITEM    lpdrv = lpDrvItemList;
  59         char                    DrvName[128];
  60         dprintf_driver(stddeb,"OpenDriver('%s', '%s', %08lX);\n",
  61                 lpDriverName, lpSectionName, lParam);
  62         if (lpSectionName == NULL) lpSectionName = "drivers";
  63         GetPrivateProfileString(lpSectionName, lpDriverName,
  64                 "", DrvName, sizeof(DrvName), "SYSTEM.INI");
  65         dprintf_driver(stddeb,"OpenDriver // DrvName='%s'\n", DrvName);
  66         if (strlen(DrvName) < 1) return 0;
  67         while (lpdrv != NULL) {
  68                 if (lpdrv->lpNextItem == NULL) break;
  69                 lpdrv = lpdrv->lpNextItem;
  70                 }
  71         hDrvr = GlobalAlloc16(GMEM_MOVEABLE, sizeof(DRIVERITEM));
  72         lpnewdrv = (LPDRIVERITEM) GlobalLock16(hDrvr);
  73         if (lpnewdrv == NULL) return 0;
  74         lpnewdrv->dis.length = sizeof(DRIVERINFOSTRUCT);
  75         lpnewdrv->dis.hModule = 0;
  76 /*      lpnewdrv->dis.hModule = LoadImage(DrvName, DLL, 0);
  77         if (lpnewdrv->dis.hModule == 0) {
  78                 GlobalUnlock(hDrvr);
  79                 GlobalFree(hDrvr);
  80                 return 0;
  81                 } */
  82         lpnewdrv->dis.hDriver = hDrvr;
  83         strcpy(lpnewdrv->dis.szAliasName, lpDriverName);
  84         lpnewdrv->count = 0;
  85         lpnewdrv->lpNextItem = NULL;
  86         if (lpDrvItemList == NULL || lpdrv == NULL) {
  87                 lpDrvItemList = lpnewdrv;
  88                 lpnewdrv->lpPrevItem = NULL;
  89                 }
  90         else {
  91                 lpdrv->lpNextItem = lpnewdrv;
  92                 lpnewdrv->lpPrevItem = lpdrv;
  93                 }
  94         lpnewdrv->lpDrvProc = (DRIVERPROC)NULL;
  95         dprintf_driver(stddeb,"OpenDriver // hDrvr=%04x loaded !\n", hDrvr);
  96         return hDrvr;
  97 }
  98
  99 /**************************************************************************
 100  *                              CloseDriver                             [USER.253]
 101  */
 102 LRESULT CloseDriver(HDRVR hDrvr, LPARAM lParam1, LPARAM lParam2)
 103 {
 104         LPDRIVERITEM    lpdrv;
 105         dprintf_driver(stddeb,
 106                 "CloseDriver(%04x, %08lX, %08lX);\n", hDrvr, lParam1, lParam2);
 107         lpdrv = (LPDRIVERITEM) GlobalLock16(hDrvr);
 108         if (lpdrv != NULL && lpdrv->dis.hDriver == hDrvr) {
 109                 if (lpdrv->lpPrevItem)
 110                         ((LPDRIVERITEM)lpdrv->lpPrevItem)->lpNextItem = lpdrv->lpNextItem;
 111                 if (lpdrv->lpNextItem)
 112                         ((LPDRIVERITEM)lpdrv->lpNextItem)->lpPrevItem = lpdrv->lpPrevItem;
 113                 GlobalUnlock16(hDrvr);
 114                 GlobalFree16(hDrvr);
 115         dprintf_driver(stddeb,"CloseDriver // hDrvr=%04x closed !\n", hDrvr);
 116                 return TRUE;
 117                 }
 118         return FALSE;
 119 }
 120
 121 /**************************************************************************
 122  *                              GetDriverModuleHandle   [USER.254]
 123  */
 124 HANDLE GetDriverModuleHandle(HDRVR hDrvr)
 125 {
 126         LPDRIVERITEM    lpdrv;
 127         HANDLE                  hModule = 0;
 128         dprintf_driver(stddeb,"GetDriverModuleHandle(%04x);\n", hDrvr);
 129         lpdrv = (LPDRIVERITEM) GlobalLock16(hDrvr);
 130         if (lpdrv != NULL) {
 131                 hModule = lpdrv->dis.hModule;
 132                 GlobalUnlock16(hDrvr);
 133                 }
 134         return hModule;
 135 }
 136
 137 /**************************************************************************
 138  *                              DefDriverProc                   [USER.255]
 139  */
 140 LRESULT DefDriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
 141                                                 DWORD dwParam1, DWORD dwParam2)
 142 {
 143         switch(wMsg) {
 144                 case DRV_LOAD:
 145                         return (LRESULT)0L;
 146                 case DRV_FREE:
 147                         return (LRESULT)0L;
 148                 case DRV_OPEN:
 149                         return (LRESULT)0L;
 150                 case DRV_CLOSE:
 151                         return (LRESULT)0L;
 152                 case DRV_ENABLE:
 153                         return (LRESULT)0L;
 154                 case DRV_DISABLE:
 155                         return (LRESULT)0L;
 156                 case DRV_QUERYCONFIGURE:
 157                         return (LRESULT)0L;
 158                 case DRV_CONFIGURE:
 159                         MessageBox((HWND)NULL, "Driver isn't configurable !",
 160                                                                         "Wine Driver", MB_OK);
 161                         return (LRESULT)0L;
 162                 case DRV_INSTALL:
 163                         return (LRESULT)DRVCNF_RESTART;
 164                 case DRV_REMOVE:
 165                         return (LRESULT)DRVCNF_RESTART;
 166                 default:
 167                         return (LRESULT)0L;
 168                 }
 169 }
 170
 171 /**************************************************************************
 172  *                              GetDriverInfo                   [USER.256]
 173  */
 174 BOOL GetDriverInfo(HDRVR hDrvr, LPDRIVERINFOSTRUCT lpDrvInfo)
 175 {
 176         LPDRIVERITEM    lpdrv;
 177         dprintf_driver(stddeb,"GetDriverInfo(%04x, %p);\n", hDrvr, lpDrvInfo);
 178         if (lpDrvInfo == NULL) return FALSE;
 179         lpdrv = (LPDRIVERITEM) GlobalLock16(hDrvr);
 180         if (lpdrv == NULL) return FALSE;
 181         memcpy(lpDrvInfo, &lpdrv->dis, sizeof(DRIVERINFOSTRUCT));
 182         GlobalUnlock16(hDrvr);
 183         return TRUE;
 184 }
 185
 186 /**************************************************************************
 187  *                              GetNextDriver                   [USER.257]
 188  */
 189 HDRVR GetNextDriver(HDRVR hDrvr, DWORD dwFlags)
 190 {
 191         LPDRIVERITEM    lpdrv;
 192         HDRVR                   hRetDrv = 0;
 193         dprintf_driver(stddeb,"GetNextDriver(%04x, %08lX);\n", hDrvr, dwFlags);
 194         if (hDrvr == 0) {
 195                 if (lpDrvItemList == NULL) {
 196                         dprintf_driver(stddeb,
 197                                 "GetNextDriver // drivers list empty !\n");
 198                         LoadStartupDrivers();
 199                         if (lpDrvItemList == NULL) return 0;
 200                         }
 201                 dprintf_driver(stddeb,"GetNextDriver // return first %04x !\n",
 202                                         lpDrvItemList->dis.hDriver);
 203                 return lpDrvItemList->dis.hDriver;
 204                 }
 205         lpdrv = (LPDRIVERITEM) GlobalLock16(hDrvr);
 206         if (lpdrv != NULL) {
 207                 if (dwFlags & GND_REVERSE) {
 208                         if (lpdrv->lpPrevItem)
 209                                 hRetDrv = ((LPDRIVERITEM)lpdrv->lpPrevItem)->dis.hDriver;
 210                         }
 211                 else {
 212                         if (lpdrv->lpNextItem)
 213                                 hRetDrv = ((LPDRIVERITEM)lpdrv->lpNextItem)->dis.hDriver;
 214                         }
 215                 GlobalUnlock16(hDrvr);
 216                 }
 217         dprintf_driver(stddeb,"GetNextDriver // return %04x !\n", hRetDrv);
 218         return hRetDrv;
 219 }
 220
 221