dlls/winedos/ppdev.c

   1 /*
   2  * Parallel port device support
   3  *
   4  * Copyright 2001 Uwe Bonnes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "windef.h"
  24
  25 #ifdef HAVE_PPDEV
  26
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <sys/types.h>
  30 #ifdef HAVE_SYS_STAT_H
  31 # include <sys/stat.h>
  32 #endif
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #ifdef HAVE_SYS_IOCTL_H
  36 # include <sys/ioctl.h>
  37 #endif
  38 #ifdef HAVE_LINUX_IOCTL_H
  39 # include <linux/ioctl.h>
  40 #endif
  41 #include <linux/ppdev.h>
  42
  43 #include "winerror.h"
  44 #include "winbase.h"
  45 #include "winreg.h"
  46 #include "winternl.h"
  47
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(int);
  51
  52 typedef struct _PPDEVICESTRUCT{
  53   int fd; /* NULL if device not available */
  54   char *devicename;
  55   int userbase; /* where wine thinks the ports are */
  56   DWORD lastaccess; /* or NULL if release */
  57   int timeout; /* time in second of inactivity to release the port */
  58 } PPDeviceStruct;
  59
  60 static PPDeviceStruct PPDeviceList[5];
  61 static int PPDeviceNum=0;
  62
  63 static int IO_pp_sort(const void *p1,const  void *p2)
  64 {
  65     return ((const PPDeviceStruct*)p1)->userbase - ((const PPDeviceStruct*)p2)->userbase;
  66 }
  67
  68 /* IO_pp_init
  69  *
  70  * Read the ppdev entries from wine.conf, open the device and check
  71  * for necessary IOCTRL
  72  * Report verbose about possible errors
  73  */
  74 char IO_pp_init(void)
  75 {
  76     char name[80];
  77     char buffer[256];
  78     HANDLE root, hkey;
  79     int i,idx=0,fd,res,userbase,nports=0;
  80     char * timeout;
  81     char ret=1;
  82     int lasterror;
  83     OBJECT_ATTRIBUTES attr;
  84     UNICODE_STRING nameW;
  85
  86     static const WCHAR configW[] = {'S','o','f','t','w','a','r','e','\\',
  87                                     'W','i','n','e','\\','V','D','M','\\','p','p','d','e','v',0};
  88
  89     TRACE("\n");
  90
  91     RtlOpenCurrentUser( KEY_ALL_ACCESS, &root );
  92     attr.Length = sizeof(attr);
  93     attr.RootDirectory = root;
  94     attr.ObjectName = &nameW;
  95     attr.Attributes = 0;
  96     attr.SecurityDescriptor = NULL;
  97     attr.SecurityQualityOfService = NULL;
  98     RtlInitUnicodeString( &nameW, configW );
  99
 100     /* @@ Wine registry key: HKCU\Software\Wine\VDM\ppdev */
 101     if (NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr )) hkey = 0;
 102     NtClose( root );
 103     if (!hkey) return 1;
 104
 105     for (;;)
 106     {
 107         DWORD total_size, len;
 108         char temp[256];
 109         KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)temp;
 110
 111         if (NtEnumerateValueKey( hkey, idx, KeyValueFullInformation,
 112                                  temp, sizeof(temp), &total_size )) break;
 113         if (info->Type != REG_SZ) break;
 114
 115         RtlUnicodeToMultiByteN( name, sizeof(name)-1, &len, info->Name, info->NameLength );
 116         name[len] = 0;
 117         RtlUnicodeToMultiByteN( buffer, sizeof(buffer)-1, &len,
 118                                 (WCHAR *)(temp + info->DataOffset), total_size-info->DataOffset );
 119         buffer[len] = 0;
 120
 121         idx++;
 122         if(nports >4)
 123           {
 124             FIXME("Make the PPDeviceList larger than 5 elements\n");
 125             break;
 126           }
 127         TRACE("Device '%s' at virtual userbase '%s'\n", buffer,name);
 128         timeout = strchr(buffer,',');
 129         if (timeout)
 130           *timeout++=0;
 131         fd=open(buffer,O_RDWR);
 132         lasterror=errno;
 133         if (fd == -1)
 134           {
 135             WARN("Configuration: No access to %s Cause: %s\n",buffer,strerror(lasterror));
 136             WARN("Rejecting configuration item\n");
 137             if (lasterror == ENODEV)
 138               ERR("Is the ppdev module loaded?\n");
 139             continue;
 140           }
 141         userbase = strtol(name,(char **)NULL, 16);
 142         if ( errno == ERANGE)
 143           {
 144             WARN("Configuration: Invalid base %s for %s\n",name,buffer);
 145             WARN("Rejecting configuration item\n");
 146             continue;
 147           }
 148         if (ioctl (fd,PPCLAIM,0))
 149           {
 150             ERR("PPCLAIM rejected %s\n",buffer);
 151             ERR("Perhaps the device is already in use or nonexistent\n");
 152             continue;
 153           }
 154         if (nports > 0)
 155           {
 156             for (i=0; i<= nports; i++)
 157               {
 158                 if (PPDeviceList[i].userbase == userbase)
 159                   {
 160                     WARN("Configuration: %s uses the same virtual ports as %s\n",
 161                          buffer,PPDeviceList[0].devicename);
 162                     WARN("Configuration: Rejecting configuration item\n");
 163                     userbase = 0;
 164                     break;
 165                   }
 166               }
 167             if (!userbase) continue;
 168           }
 169         /* Check for the minimum required IOCTLS */
 170         if ((ioctl(fd,PPRDATA,&res))||
 171             (ioctl(fd,PPRCONTROL,&res))||
 172             (ioctl(fd,PPRCONTROL,&res)))
 173           {
 174             ERR("PPUSER IOCTL not available for parport device %s\n",buffer);
 175             continue;
 176           }
 177         if (ioctl (fd,PPRELEASE,0))
 178           {
 179             ERR("PPRELEASE rejected %s\n",buffer);
 180             ERR("Perhaps the device is already in use or nonexistent\n");
 181             continue;
 182           }
 183         PPDeviceList[nports].devicename = malloc(sizeof(buffer)+1);
 184         if (!PPDeviceList[nports].devicename)
 185           {
 186             ERR("No (more) space for devicename\n");
 187             break;
 188           }
 189         strcpy(PPDeviceList[nports].devicename,buffer);
 190         PPDeviceList[nports].fd = fd;
 191         PPDeviceList[nports].userbase = userbase;
 192         PPDeviceList[nports].lastaccess=GetTickCount();
 193         if (timeout)
 194           {
 195             PPDeviceList[nports].timeout = strtol(timeout,(char **)NULL, 10);
 196             if (errno == ERANGE)
 197               {
 198                 WARN("Configuration: Invalid timeout %s in configuration for %s, Setting to 0\n",
 199                      timeout,buffer);
 200                 PPDeviceList[nports].timeout = 0;
 201               }
 202           }
 203         else
 204           PPDeviceList[nports].timeout = 0;
 205         nports++;
 206     }
 207     TRACE("found %d ports\n",nports);
 208     NtClose( hkey );
 209
 210     PPDeviceNum= nports;
 211     if (nports > 1)
 212       /* sort in ascending order for userbase for faster access */
 213       qsort (PPDeviceList,PPDeviceNum,sizeof(PPDeviceStruct),IO_pp_sort);
 214
 215     if (nports)
 216       ret=0;
 217     for (idx= 0;idx<PPDeviceNum; idx++)
 218       TRACE("found device %s userbase %x fd %x timeout %d\n",
 219             PPDeviceList[idx].devicename, PPDeviceList[idx].userbase,
 220             PPDeviceList[idx].fd,PPDeviceList[idx].timeout);
 221     /* FIXME:
 222        register a timer callback perhaps every 30 seconds to release unused ports
 223        Set lastaccess = 0 as indicator when port was released
 224     */
 225     return ret;
 226 }
 227
 228 /* IO_pp_do_access
 229  *
 230  * Do the actual IOCTL
 231  * Return NULL on success
 232  */
 233 static int IO_pp_do_access(int idx,int ppctl, DWORD* res)
 234 {
 235   int ret;
 236   if (ioctl(PPDeviceList[idx].fd,PPCLAIM,0))
 237     {
 238       ERR("Can't reclaim device %s, PPUSER/PPDEV handling confused\n",
 239           PPDeviceList[idx].devicename);
 240       return 1;
 241     }
 242   ret = ioctl(PPDeviceList[idx].fd,ppctl,res);
 243   if (ioctl(PPDeviceList[idx].fd,PPRELEASE,0))
 244     {
 245       ERR("Can't release device %s, PPUSER/PPDEV handling confused\n",
 246           PPDeviceList[idx].devicename);
 247       return 1;
 248     }
 249   return ret;
 250
 251 }
 252
 253 /* IO_pp_inp
 254  *
 255  * Check if we can satisfy the INP command with some of the configured PPDEV deviced
 256  * Return NULL on success
 257  */
 258 int IO_pp_inp(int port, DWORD* res)
 259 {
 260     int idx,j=0;
 261
 262     for (idx=0;idx<PPDeviceNum ;idx++)
 263       {
 264        j = port - PPDeviceList[idx].userbase;
 265        if (j <0) return 1;
 266        switch (j)
 267          {
 268          case 0:
 269            return IO_pp_do_access(idx,PPRDATA,res);
 270          case 1:
 271            return IO_pp_do_access(idx,PPRSTATUS,res);
 272          case 2:
 273            return IO_pp_do_access(idx,PPRCONTROL,res);
 274          case 0x400:
 275          case 0x402:
 276          case 3:
 277          case 4:
 278          case 0x401:
 279            FIXME("Port 0x%x not accessible for reading with ppdev\n",port);
 280            FIXME("If this is causing problems, try direct port access\n");
 281            return 1;
 282          default:
 283            break;
 284          }
 285       }
 286     return 1;
 287 }
 288
 289 /* IO_pp_outp
 290  *
 291  * Check if we can satisfy the INP command with some of the configured PPDEV deviced
 292  * Return NULL on success
 293  */
 294 BOOL IO_pp_outp(int port, DWORD* res)
 295 {
 296     int idx,j=0;
 297
 298     for (idx=0;idx<PPDeviceNum ;idx++)
 299       {
 300        j = port - PPDeviceList[idx].userbase;
 301        if (j <0) return 1;
 302        switch (j)
 303          {
 304          case 0:
 305            return IO_pp_do_access(idx,PPWDATA,res);
 306          case 2:
 307            {
 308              /* We can't switch port direction via PPWCONTROL,
 309                 so do it via PPDATADIR
 310              */
 311              DWORD mode = *res & 0x20;
 312              IO_pp_do_access(idx,PPDATADIR,&mode);
 313              mode = (*res & ~0x20);
 314              return IO_pp_do_access(idx,PPWCONTROL,&mode);
 315            }
 316
 317          case 1:
 318          case 0x400:
 319          case 0x402:
 320          case 3:
 321          case 4:
 322          case 0x401:
 323            FIXME("Port %d not accessible for writing with ppdev\n",port);
 324            FIXME("If this is causing problems, try direct port access\n");
 325            return 1;
 326          default:
 327            break;
 328          }
 329       }
 330     return TRUE;
 331 }
 332
 333
 334 #else /* HAVE_PPDEV */
 335
 336
 337 char IO_pp_init(void)
 338 {
 339   return 1;
 340 }
 341
 342 int IO_pp_inp(int port, DWORD* res)
 343 {
 344   return 1;
 345 }
 346
 347 BOOL IO_pp_outp(int port, DWORD* res)
 348 {
 349   return TRUE;
 350 }
 351 #endif  /* HAVE_PPDEV */