- Add a lot of traces to make debugging a bit easier.
[wine] / dlls / winaspi / aspi.c
1 /**************************************************************************
2  * ASPI routines
3  * Copyright (C) 2000 David Elliott <dfe@infinite-internet.net>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2.1 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19
20 /* These routines are to be called from either WNASPI32 or WINASPI */
21
22 /* FIXME:
23  * - Registry format is stupid for now.. fix that later
24  * - No way to override automatic /proc detection, maybe provide an
25  *   HKEY_LOCAL_MACHINE\Software\Wine\Wine\Scsi regkey
26  * - Somewhat debating an #ifdef linux... technically all this code will
27  *   run on another UNIX.. it will fail nicely.
28  * - Please add support for mapping multiple channels on host adapters to
29  *   aspi controllers, e-mail me if you need help.
30  */
31
32 /*
33 Registry format is currently:
34 HKEY_DYN_DATA
35         WineScsi
36                 (default)=number of host adapters
37                 hHHcCCtTTdDD=linux device name
38 */
39
40 #include "config.h"
41
42 #include <stdio.h>
43 #include <stdarg.h>
44 #include <sys/types.h>
45 #ifdef HAVE_SYS_IOCTL_H
46 #include <sys/ioctl.h>
47 #endif
48 #include <fcntl.h>
49 #include <dirent.h>
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
53 #include <errno.h>
54 #include <string.h>
55
56 #include "windef.h"
57 #include "winbase.h"
58 #include "winreg.h"
59 #include "winerror.h"
60 #include "winescsi.h"
61
62 #include "wine/debug.h"
63
64 WINE_DEFAULT_DEBUG_CHANNEL(aspi);
65
66 /* Internal function prototypes */
67 static void
68 SCSI_GetProcinfo();
69
70 #ifdef linux
71 static void
72 SCSI_MapHCtoController();
73 #endif
74
75 static void set_last_error(void)
76 {
77     int save_errno = errno; /* errno gets overwritten by printf */
78     switch (errno)
79     {
80     case EAGAIN:
81         SetLastError( ERROR_SHARING_VIOLATION );
82         break;
83     case EBADF:
84         SetLastError( ERROR_INVALID_HANDLE );
85         break;
86     case ENOSPC:
87         SetLastError( ERROR_HANDLE_DISK_FULL );
88         break;
89     case EACCES:
90     case EPERM:
91     case EROFS:
92         SetLastError( ERROR_ACCESS_DENIED );
93         break;
94     case EBUSY:
95         SetLastError( ERROR_LOCK_VIOLATION );
96         break;
97     case ENOENT:
98         SetLastError( ERROR_FILE_NOT_FOUND );
99         break;
100     case EISDIR:
101         SetLastError( ERROR_CANNOT_MAKE );
102         break;
103     case ENFILE:
104     case EMFILE:
105         SetLastError( ERROR_NO_MORE_FILES );
106         break;
107     case EEXIST:
108         SetLastError( ERROR_FILE_EXISTS );
109         break;
110     case EINVAL:
111     case ESPIPE:
112         SetLastError( ERROR_SEEK );
113         break;
114     case ENOTEMPTY:
115         SetLastError( ERROR_DIR_NOT_EMPTY );
116         break;
117     case ENOEXEC:
118         SetLastError( ERROR_BAD_FORMAT );
119         break;
120     default:
121         WARN( "unknown file error: %s\n", strerror(save_errno) );
122         SetLastError( ERROR_GEN_FAILURE );
123         break;
124     }
125     errno = save_errno;
126 }
127
128 /* Exported functions */
129 void
130 SCSI_Init()
131 {
132         /* For now we just call SCSI_GetProcinfo */
133         SCSI_GetProcinfo();
134 #ifdef linux
135         SCSI_MapHCtoController();
136 #endif
137 }
138
139 int
140 ASPI_GetNumControllers()
141 {
142         HKEY hkeyScsi;
143         HKEY hkeyControllerMap;
144         DWORD error;
145         DWORD type = REG_DWORD;
146         DWORD num_ha = 0;
147         DWORD cbData = sizeof(num_ha);
148
149         if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
150         {
151                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
152                 return 0;
153         }
154
155         if( (error=RegOpenKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, KEY_ALL_ACCESS, &hkeyControllerMap )) != ERROR_SUCCESS )
156         {
157                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
158                 RegCloseKey(hkeyScsi);
159                 SetLastError(error);
160                 return 0;
161         }
162         if( RegQueryValueExA(hkeyControllerMap, NULL, NULL, &type, (LPBYTE)&num_ha, &cbData ) != ERROR_SUCCESS )
163         {
164                 ERR("Could not query value HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
165                 num_ha=0;
166         }
167         RegCloseKey(hkeyControllerMap);
168         RegCloseKey(hkeyScsi);
169         TRACE("Returning %ld host adapters\n", num_ha );
170         return num_ha;
171 }
172
173 BOOL
174 SCSI_GetDeviceName( int h, int c, int t, int d, LPSTR devstr, LPDWORD lpcbData )
175 {
176
177         char idstr[20];
178         HKEY hkeyScsi;
179         DWORD type;
180
181         if( RegOpenKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, KEY_ALL_ACCESS, &hkeyScsi ) != ERROR_SUCCESS )
182         {
183                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
184                 return FALSE;
185         }
186
187
188         sprintf(idstr, "h%02dc%02dt%02dd%02d", h, c, t, d);
189
190         if( RegQueryValueExA(hkeyScsi, idstr, NULL, &type, devstr, lpcbData) != ERROR_SUCCESS )
191         {
192                 WARN("Could not query value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
193                 RegCloseKey(hkeyScsi);
194                 return FALSE;
195         }
196         RegCloseKey(hkeyScsi);
197
198         TRACE("scsi %s: Device name: %s\n",idstr,devstr);
199         return TRUE;
200 }
201
202 /* SCSI_GetHCforController
203  * RETURNS
204  *      HIWORD: Host Adapter
205  *      LOWORD: Channel
206  */
207 DWORD
208 ASPI_GetHCforController( int controller )
209 {
210         DWORD hc = 0xFFFFFFFF;
211         char cstr[20];
212         DWORD error;
213         HKEY hkeyScsi;
214         HKEY hkeyControllerMap;
215         DWORD type = REG_DWORD;
216         DWORD cbData = sizeof(DWORD);
217         DWORD disposition;
218 #if 0
219         FIXME("Please fix to map each channel of each host adapter to the proper ASPI controller number!\n");
220         hc = (controller << 16);
221         return hc;
222 #endif
223         if( (error=RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition )) != ERROR_SUCCESS )
224         {
225                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
226                 SetLastError(error);
227                 return hc;
228         }
229         if( disposition != REG_OPENED_EXISTING_KEY )
230         {
231                 WARN("Created HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
232         }
233         if( (error=RegCreateKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyControllerMap, &disposition )) != ERROR_SUCCESS )
234         {
235                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
236                 RegCloseKey(hkeyScsi);
237                 SetLastError(error);
238                 return hc;
239         }
240         if( disposition != REG_OPENED_EXISTING_KEY )
241         {
242                 WARN("Created HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
243         }
244
245         sprintf(cstr, "c%02d", controller);
246         if( (error=RegQueryValueExA( hkeyControllerMap, cstr, 0, &type, (LPBYTE)&hc, &cbData)) != ERROR_SUCCESS )
247         {
248                 ERR("Could not open HKEY_DYN_DATA\\%s\\%s\\%s, error=%lx\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP, cstr, error );
249                 SetLastError( error );
250         }
251         RegCloseKey(hkeyControllerMap);
252         RegCloseKey(hkeyScsi);
253         return hc;
254
255 };
256
257 int
258 SCSI_OpenDevice( int h, int c, int t, int d )
259 {
260         char devstr[20];
261         DWORD cbData = 20;
262         int fd = -1;
263         char dainbread_linux_hack = 1;
264
265         if(!SCSI_GetDeviceName( h, c, t, d, devstr, &cbData ))
266         {
267                 WARN("Could not get device name for h%02dc%02dt%02dd%02d\n", h, c, t, d);
268                 return -1;
269         }
270
271 linux_hack:
272         TRACE("Opening device %s mode O_RDWR\n",devstr);
273         fd = open(devstr, O_RDWR);
274
275         if( fd < 0 )
276         {
277                 int len = strlen(devstr);
278                 set_last_error(); /* SetLastError() to errno */
279                 TRACE("Open failed (%s)\n", strerror(errno));
280
281                 /* in case of "/dev/sgX", convert from sga to sg0
282                  * and the other way around.
283                  * FIXME: remove it if the distributions
284                  * finally manage to agree on something.
285                  * The best would probably be a complete
286                  * rewrite of the Linux SCSI layer
287                  * to use CAM + devfs :-) */
288                 if ( (dainbread_linux_hack) &&
289                      (len >= 3) &&
290                      (devstr[len-3] == 's') && (devstr[len-2] == 'g') )
291                 {
292                         char *p = &devstr[len-1];
293                         *p = (*p >= 'a') ? *p - 'a' + '0' : *p - '0' + 'a';
294                         dainbread_linux_hack = 0;
295                         TRACE("Retry with \"equivalent\" Linux device '%s'\n", devstr);
296                         goto linux_hack;
297                 }
298         }
299         return fd;
300 }
301
302 #ifdef linux
303 /* SCSI_Fix_CMD_LEN
304  *      Checks to make sure the CMD_LEN is correct
305  */
306 void
307 SCSI_Fix_CMD_LEN(int fd, int cmd, int len)
308 {
309         /* This is what the linux kernel thinks.... */
310         static const unsigned char scsi_command_size[8] =
311         {
312                 6, 10, 10, 12,
313                 12, 12, 10, 10
314         };
315
316         int index=(cmd>>5)&7;
317
318         if (len!=scsi_command_size[index])
319         {
320                 TRACE("CDBLen for command %d claims to be %d, expected %d\n",
321                                 cmd, len, scsi_command_size[index]);
322                 ioctl(fd,SG_NEXT_CMD_LEN,&len);
323         }
324 }
325
326 int
327 SCSI_LinuxSetTimeout( int fd, int timeout )
328 {
329         int retval;
330         TRACE("Setting timeout to %d jiffies\n", timeout);
331         retval=ioctl(fd,SG_SET_TIMEOUT,&timeout);
332         if(retval)
333         {
334                 WARN("Could not set timeout ! (%s)\n", strerror(errno));
335         }
336         return retval;
337
338 }
339
340 /* This function takes care of the write/read to the linux sg device.
341  * It returns TRUE or FALSE and uses set_last_error() to convert
342  * UNIX errno to Windows GetLastError().  The reason for that is that
343  * several programs will check that error and we might as well set
344  * it here.  We also return the value of the read call in
345  * lpcbBytesReturned.
346  */
347 BOOL /* NOTE: This function SHOULD BLOCK */
348 SCSI_LinuxDeviceIo( int fd,
349                 struct sg_header * lpInBuffer, DWORD cbInBuffer,
350                 struct sg_header * lpOutBuffer, DWORD cbOutBuffer,
351                 LPDWORD lpcbBytesReturned )
352 {
353         DWORD dwBytes;
354         DWORD save_error;
355
356         TRACE("Writing to Linux sg device\n");
357         dwBytes = write( fd, lpInBuffer, cbInBuffer );
358         if( dwBytes != cbInBuffer )
359         {
360                 set_last_error();
361                 save_error = GetLastError();
362                 WARN("Not enough bytes written to scsi device. bytes=%ld .. %ld\n", cbInBuffer, dwBytes );
363                 /* FIXME: set_last_error() never sets error to ERROR_NOT_ENOUGH_MEMORY... */
364                 if( save_error == ERROR_NOT_ENOUGH_MEMORY )
365                         MESSAGE("Your Linux kernel was not able to handle the amount of data sent to the scsi device. Try recompiling with a larger SG_BIG_BUFF value (kernel 2.0.x sg.h)");
366                 WARN("error= %ld\n", save_error );
367                 *lpcbBytesReturned = 0;
368                 return FALSE;
369         }
370
371         TRACE("Reading reply from Linux sg device\n");
372         *lpcbBytesReturned = read( fd, lpOutBuffer, cbOutBuffer );
373         if( *lpcbBytesReturned != cbOutBuffer )
374         {
375                 set_last_error();
376                 save_error = GetLastError();
377                 WARN("Not enough bytes read from scsi device. bytes=%ld .. %ld\n", cbOutBuffer, *lpcbBytesReturned);
378                 WARN("error= %ld\n", save_error );
379                 return FALSE;
380         }
381         return TRUE;
382 }
383
384 /* Internal functions */
385 struct LinuxProcScsiDevice
386 {
387         int host;
388         int channel;
389         int target;
390         int lun;
391         char vendor[9];
392         char model[17];
393         char rev[5];
394         char type[33];
395         int ansirev;
396 };
397
398 /*
399  * we need to declare white spaces explicitly via %*1[ ],
400  * as there are very dainbread CD-ROM devices out there
401  * which have their manufacturer name blanked out via spaces,
402  * which confuses fscanf's parsing (skips all blank spaces)
403  */
404 static int
405 SCSI_getprocentry( FILE * procfile, struct LinuxProcScsiDevice * dev )
406 {
407         int result;
408         result = fscanf( procfile,
409                 "Host:%*1[ ]scsi%d%*1[ ]Channel:%*1[ ]%d%*1[ ]Id:%*1[ ]%d%*1[ ]Lun:%*1[ ]%d\n",
410                 &dev->host,
411                 &dev->channel,
412                 &dev->target,
413                 &dev->lun );
414         if( result == EOF )
415         {
416                 /* "end of entries" return, so no TRACE() here */
417                 return EOF;
418         }
419         if( result != 4 )
420         {
421                 ERR("bus id line scan count error\n");
422                 return 0;
423         }
424         result = fscanf( procfile,
425                 "  Vendor:%*1[ ]%8c%*1[ ]Model:%*1[ ]%16c%*1[ ]Rev:%*1[ ]%4c\n",
426                 dev->vendor,
427                 dev->model,
428                 dev->rev );
429         if( result != 3 )
430         {
431                 ERR("model line scan count error\n");
432                 return 0;
433         }
434
435         result = fscanf( procfile,
436                 "  Type:%*3[ ]%32c%*1[ ]ANSI%*1[ ]SCSI%*1[ ]revision:%*1[ ]%d\n",
437                 dev->type,
438                 &dev->ansirev );
439         if( result != 2 )
440         {
441                 ERR("SCSI type line scan count error\n");
442                 return 0;
443         }
444         /* Since we fscanf with %XXc instead of %s.. put a NULL at end */
445         dev->vendor[8] = 0;
446         dev->model[16] = 0;
447         dev->rev[4] = 0;
448         dev->type[32] = 0;
449
450         return 1;
451 }
452
453 static void
454 SCSI_printprocentry( const struct LinuxProcScsiDevice * dev )
455 {
456         TRACE( "Host: scsi%d Channel: %02d Id: %02d Lun: %02d\n",
457                 dev->host,
458                 dev->channel,
459                 dev->target,
460                 dev->lun );
461         TRACE( "  Vendor: %s Model: %s Rev: %s\n",
462                 dev->vendor,
463                 dev->model,
464                 dev->rev );
465         TRACE( "  Type:   %s ANSI SCSI revision: %02d\n",
466                 dev->type,
467                 dev->ansirev );
468 }
469
470 static BOOL
471 SCSI_PutRegControllerMap( HKEY hkeyControllerMap, int num_controller, int ha, int chan)
472 {
473         DWORD error;
474         char cstr[20];
475         DWORD hc;
476         hc = (ha << 16) + chan;
477         sprintf(cstr, "c%02d", num_controller);
478         if( (error=RegSetValueExA( hkeyControllerMap, cstr, 0, REG_DWORD, (LPBYTE)&hc, sizeof(DWORD))) != ERROR_SUCCESS )
479         {
480                 ERR("Could not create HKEY_DYN_DATA\\%s\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP, cstr );
481         }
482         return error;
483 }
484
485 static void
486 SCSI_MapHCtoController()
487 {
488         HKEY hkeyScsi;
489         HKEY hkeyControllerMap;
490         DWORD disposition;
491
492         char idstr[20];
493         DWORD cbIdStr;
494         int i = 0;
495         DWORD type = 0;
496         DWORD error;
497
498         DWORD num_controller = 0;
499         int last_ha = -1;
500         int last_chan = -1;
501
502         int ha = 0;
503         int chan = 0;
504
505         if( RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition ) != ERROR_SUCCESS )
506         {
507                 ERR("Could not open HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
508                 return;
509         }
510         if( disposition != REG_OPENED_EXISTING_KEY )
511         {
512                 WARN("Created HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
513         }
514         if( RegCreateKeyExA(hkeyScsi, KEYNAME_SCSI_CONTROLLERMAP, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyControllerMap, &disposition ) != ERROR_SUCCESS )
515         {
516                 ERR("Could not create HKEY_DYN_DATA\\%s\\%s\n", KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
517                 RegCloseKey(hkeyScsi);
518                 return;
519         }
520
521         for( i=0; cbIdStr = sizeof(idstr), (error=RegEnumValueA( hkeyScsi, i, idstr, &cbIdStr, NULL, &type, NULL, NULL )) == ERROR_SUCCESS; i++ )
522         {
523                 if(idstr[0] == '\0') continue; /* skip the default value */
524
525                 if(sscanf(idstr, "h%02dc%02dt%*02dd%*02d", &ha, &chan) != 2) {
526                         ERR("incorrect reg. value %s\n", debugstr_a(idstr));
527                         continue;
528                 }
529
530                 if( last_ha < ha )
531                 {       /* Next HA */
532                         last_ha = ha;
533                         last_chan = chan;
534                         SCSI_PutRegControllerMap( hkeyControllerMap, num_controller, ha, chan);
535                         num_controller++;
536                 }
537                 else if( last_ha > ha )
538                 {
539                         FIXME("Expected registry to be sorted\n");
540                 }
541                 /* last_ha == ha */
542                 else if( last_chan < chan )
543                 {
544                         last_chan = chan;
545                         SCSI_PutRegControllerMap( hkeyControllerMap, num_controller, ha, chan);
546                         num_controller++;
547                 }
548                 else if( last_chan > chan )
549                 {
550                         FIXME("Expected registry to be sorted\n");
551                 }
552                 /* else last_ha == ha && last_chan == chan so do nothing */
553         }
554         /* Set (default) value to number of controllers */
555         if( RegSetValueExA(hkeyControllerMap, NULL, 0, REG_DWORD, (LPBYTE)&num_controller, sizeof(DWORD) ) != ERROR_SUCCESS )
556         {
557                 ERR("Could not set value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, KEYNAME_SCSI_CONTROLLERMAP);
558         }
559         RegCloseKey(hkeyControllerMap);
560         RegCloseKey(hkeyScsi);
561         return;
562 }
563 #endif
564
565 int SCSI_Linux_CheckDevices(void)
566 {
567     DIR *devdir;
568     struct dirent *dent = NULL;
569
570     devdir = opendir("/dev");
571     for (dent=readdir(devdir);dent;dent=readdir(devdir))
572     {
573         if (!(strncmp(dent->d_name, "sg", 2)))
574             break;
575     }
576     closedir(devdir);
577
578     if (dent == NULL)
579     {
580         TRACE("WARNING: You don't have any /dev/sgX generic scsi devices ! \"man MAKEDEV\" !\n");
581         return 0;
582     }
583     return 1;
584 }
585
586 static void
587 SCSI_GetProcinfo()
588 /* I'll admit, this function is somewhat of a mess... it was originally
589  * designed to make some sort of linked list then I realized that
590  * HKEY_DYN_DATA would be a lot less messy
591  */
592 {
593 #ifdef linux
594         static const char procname[] = "/proc/scsi/scsi";
595         FILE * procfile = NULL;
596
597         char read_line[40], read1[10] = "\0", read2[10] = "\0";
598         int result = 0;
599
600         struct LinuxProcScsiDevice dev;
601
602         char idstr[20];
603         char devstr[20];
604
605         int devnum=0;
606         int num_ha = 0;
607
608         HKEY hkeyScsi;
609         DWORD disposition;
610
611         /* Check whether user has generic scsi devices at all */
612         if (!(SCSI_Linux_CheckDevices()))
613             return;
614
615         procfile = fopen( procname, "r" );
616         if( !procfile )
617         {
618                 ERR("Could not open %s\n", procname);
619                 return;
620         }
621
622         fgets(read_line, 40, procfile);
623         sscanf( read_line, "Attached %9s %9s", read1, read2);
624
625         if(strcmp(read1, "devices:"))
626         {
627                 ERR("Incorrect %s format\n", procname);
628                 return;
629         }
630
631         if(!(strcmp(read2, "none")))
632         {
633                 ERR("No devices found in %s. Make sure you loaded your SCSI driver or set up ide-scsi emulation for your IDE device if this app needs it !\n", procname);
634                 return;
635         }
636
637         if( RegCreateKeyExA(HKEY_DYN_DATA, KEYNAME_SCSI, 0, NULL, REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyScsi, &disposition ) != ERROR_SUCCESS )
638         {
639                 ERR("Could not create HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
640                 return;
641         }
642
643         /* Read info for one device */
644         while( (result = SCSI_getprocentry(procfile, &dev)) > 0 )
645         {
646                 /* Add to registry */
647
648                 sprintf(idstr, "h%02dc%02dt%02dd%02d", dev.host, dev.channel, dev.target, dev.lun);
649                 sprintf(devstr, "/dev/sg%c", 'a'+devnum);
650                 if( RegSetValueExA(hkeyScsi, idstr, 0, REG_SZ, devstr, strlen(devstr)+1 ) != ERROR_SUCCESS )
651                 {
652                         ERR("Could not set value HKEY_DYN_DATA\\%s\\%s\n",KEYNAME_SCSI, idstr);
653                 }
654
655                 /* Debug output */
656                 SCSI_printprocentry( &dev );
657
658                 /* FIXME: We *REALLY* need number of controllers.. not ha */
659                 /* num of hostadapters is highest ha + 1 */
660                 if( dev.host >= num_ha )
661                         num_ha = dev.host+1;
662                 devnum++;
663         } /* while(1) */
664         if( result != EOF )
665         {
666                 ERR("Sorry, incorrect %s format\n", procname);
667         }
668         fclose( procfile );
669         if( RegSetValueExA(hkeyScsi, NULL, 0, REG_DWORD, (LPBYTE)&num_ha, sizeof(num_ha) ) != ERROR_SUCCESS )
670         {
671                 ERR("Could not set value HKEY_DYN_DATA\\%s\n",KEYNAME_SCSI);
672         }
673         RegCloseKey(hkeyScsi);
674         return;
675 #endif
676 }