source: trunk/src/wnaspi32/winaspi32.cpp@ 2013

Last change on this file since 2013 was 987, checked in by phaller, 26 years ago

Add: WinASPI32 support via ASPIROUT$-device driver
File size: 22.0 KB
Line 
1#include <os2win.h>
2#include <stdlib.h>
3#include <sys/types.h>
4#include <sys/stat.h>
5#include <errno.h>
6#include <fcntl.h>
7#include <memory.h>
8// #include <unistd.h>
9
10#include "aspi.h"
11#include "wnaspi32.h"
12#include <winreg.h>
13#include "options.h"
14#include "debugtools.h"
15
16#include "srbos2.h"
17#include "odinaspi.h"
18//#include "callback.h"
19
20DEFAULT_DEBUG_CHANNEL(aspi)
21
22
23/* FIXME!
24 * 1) Residual byte length reporting not handled
25 * 2) Make this code re-entrant for multithreading
26 * 3) Only linux supported so far
27 */
28
29#ifdef linux
30
31static ASPI_DEVICE_INFO *ASPI_open_devices = NULL;
32
33static int
34ASPI_OpenDevice(SRB_ExecSCSICmd *prb)
35{
36 int fd;
37 char idstr[20];
38 char device_str[50];
39 ASPI_DEVICE_INFO *curr;
40
41 /* search list of devices to see if we've opened it already.
42 * There is not an explicit open/close in ASPI land, so hopefully
43 * keeping a device open won't be a problem.
44 */
45
46 for (curr = ASPI_open_devices; curr; curr = curr->next) {
47 if (curr->hostId == prb->SRB_HaId &&
48 curr->target == prb->SRB_Target &&
49 curr->lun == prb->SRB_Lun) {
50 return curr->fd;
51 }
52 }
53
54 /* device wasn't cached, go ahead and open it */
55 sprintf(idstr, "scsi c%1dt%1dd%1d", prb->SRB_HaId, prb->SRB_Target, prb->SRB_Lun);
56
57 if (!PROFILE_GetWineIniString(idstr, "Device", "", device_str, sizeof(device_str))) {
58 TRACE("Trying to open unlisted scsi device %s\n", idstr);
59 return -1;
60 }
61
62 TRACE("Opening device %s=%s\n", idstr, device_str);
63
64 fd = open(device_str, O_RDWR);
65 if (fd == -1) {
66 int save_error = errno;
67#ifdef HAVE_STRERROR
68 ERR("Error opening device %s, error '%s'\n", device_str, strerror(save_error));
69#else
70 ERR("Error opening device %s, error %d\n", device_str, save_error);
71#endif
72 return -1;
73 }
74
75 /* device is now open */
76 curr = HeapAlloc( SystemHeap, 0, sizeof(ASPI_DEVICE_INFO) );
77 curr->fd = fd;
78 curr->hostId = prb->SRB_HaId;
79 curr->target = prb->SRB_Target;
80 curr->lun = prb->SRB_Lun;
81
82 /* insert new record at beginning of open device list */
83 curr->next = ASPI_open_devices;
84 ASPI_open_devices = curr;
85 return fd;
86}
87
88
89static void
90ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
91{
92 BYTE cmd;
93 int i;
94 BYTE *cdb;
95
96 switch (prb->CDBByte[0]) {
97 case CMD_INQUIRY:
98 TRACE("{\n");
99 TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
100 TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
101 TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
102 TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
103 TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
104 TRACE("}\n");
105 break;
106 case CMD_SCAN_SCAN:
107 TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
108 break;
109 }
110
111 TRACE("Host Adapter: %d\n", prb->SRB_HaId);
112 TRACE("Flags: %d\n", prb->SRB_Flags);
113 if (TARGET_TO_HOST(prb)) {
114 TRACE("\tData transfer: Target to host. Length checked.\n");
115 }
116 else if (HOST_TO_TARGET(prb)) {
117 TRACE("\tData transfer: Host to target. Length checked.\n");
118 }
119 else if (NO_DATA_TRANSFERED(prb)) {
120 TRACE("\tData transfer: none\n");
121 }
122 else {
123 WARN("\tTransfer by scsi cmd. Length not checked.\n");
124 }
125
126 TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
127 TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
128 TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
129 TRACE("Target: %d\n", prb->SRB_Target);
130 TRACE("Lun: %d\n", prb->SRB_Lun);
131 TRACE("BufLen: %ld\n", prb->SRB_BufLen);
132 TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
133 TRACE("BufPtr: %p\n", prb->SRB_BufPointer);
134 TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
135 TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
136 cdb = &prb->CDBByte[0];
137 cmd = prb->CDBByte[0];
138 if (TRACE_ON(aspi))
139 {
140 DPRINTF("CDB buffer[");
141 for (i = 0; i < prb->SRB_CDBLen; i++) {
142 if (i != 0) DPRINTF(",");
143 DPRINTF("%02x", *cdb++);
144 }
145 DPRINTF("]\n");
146 }
147}
148
149static void
150ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
151{
152 int i;
153 BYTE *cdb;
154
155 if (TRACE_ON(aspi))
156 {
157 cdb = &prb->CDBByte[0];
158 DPRINTF("SenseArea[");
159 for (i = 0; i < prb->SRB_SenseLen; i++) {
160 if (i) DPRINTF(",");
161 DPRINTF("%02x", *cdb++);
162 }
163 DPRINTF("]\n");
164 }
165}
166
167static void
168ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
169{
170
171 switch (prb->CDBByte[0]) {
172 case CMD_INQUIRY:
173 TRACE("Vendor: '%s'\n", prb->SRB_BufPointer + INQUIRY_VENDOR);
174 break;
175 case CMD_TEST_UNIT_READY:
176 ASPI_PrintSenseArea(prb);
177 break;
178 }
179}
180
181static WORD
182ASPI_ExecScsiCmd(SRB_ExecSCSICmd *lpPRB)
183{
184 struct sg_header *sg_hd, *sg_reply_hdr;
185 int status;
186 int in_len, out_len;
187 int error_code = 0;
188 int fd;
189
190 ASPI_DebugPrintCmd(lpPRB);
191
192 fd = ASPI_OpenDevice(lpPRB);
193 if (fd == -1) {
194 ERR("Failed: could not open device c%01dt%01dd%01d. Device permissions !?\n",
195 lpPRB->SRB_HaId,lpPRB->SRB_Target,lpPRB->SRB_Lun);
196 lpPRB->SRB_Status = SS_NO_DEVICE;
197 return SS_NO_DEVICE;
198 }
199
200 sg_hd = NULL;
201 sg_reply_hdr = NULL;
202
203 lpPRB->SRB_Status = SS_PENDING;
204
205 if (!lpPRB->SRB_CDBLen) {
206 WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
207 lpPRB->SRB_Status = SS_ERR;
208 return SS_ERR;
209 }
210
211 /* build up sg_header + scsi cmd */
212 if (HOST_TO_TARGET(lpPRB)) {
213 /* send header, command, and then data */
214 in_len = SCSI_OFF + lpPRB->SRB_CDBLen + lpPRB->SRB_BufLen;
215 sg_hd = (struct sg_header *) malloc(in_len);
216 memset(sg_hd, 0, SCSI_OFF);
217 memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
218 if (lpPRB->SRB_BufLen) {
219 memcpy(((BYTE *) sg_hd) + SCSI_OFF + lpPRB->SRB_CDBLen, lpPRB->SRB_BufPointer, lpPRB->SRB_BufLen);
220 }
221 }
222 else {
223 /* send header and command - no data */
224 in_len = SCSI_OFF + lpPRB->SRB_CDBLen;
225 sg_hd = (struct sg_header *) malloc(in_len);
226 memset(sg_hd, 0, SCSI_OFF);
227 memcpy(sg_hd + 1, &lpPRB->CDBByte[0], lpPRB->SRB_CDBLen);
228 }
229
230 if (TARGET_TO_HOST(lpPRB)) {
231 out_len = SCSI_OFF + lpPRB->SRB_BufLen;
232 sg_reply_hdr = (struct sg_header *) malloc(out_len);
233 memset(sg_reply_hdr, 0, SCSI_OFF);
234 sg_hd->reply_len = out_len;
235 }
236 else {
237 out_len = SCSI_OFF;
238 sg_reply_hdr = (struct sg_header *) malloc(out_len);
239 memset(sg_reply_hdr, 0, SCSI_OFF);
240 sg_hd->reply_len = out_len;
241 }
242
243 status = write(fd, sg_hd, in_len);
244 if (status < 0 || status != in_len) {
245 int save_error = errno;
246
247 WARN("Not enough bytes written to scsi device bytes=%d .. %d\n", in_len, status);
248 if (status < 0) {
249 if (save_error == ENOMEM) {
250 MESSAGE("ASPI: Linux generic scsi driver\n You probably need to re-compile your kernel with a larger SG_BIG_BUFF value (sg.h)\n Suggest 130560\n");
251 }
252#ifdef HAVE_STRERROR
253 WARN("error:= '%s'\n", strerror(save_error));
254#else
255 WARN("error:= %d\n", save_error);
256#endif
257 }
258 goto error_exit;
259 }
260
261 status = read(fd, sg_reply_hdr, out_len);
262 if (status < 0 || status != out_len) {
263 WARN("not enough bytes read from scsi device%d\n", status);
264 goto error_exit;
265 }
266
267 if (sg_reply_hdr->result != 0) {
268 error_code = sg_reply_hdr->result;
269 WARN("reply header error (%d)\n", sg_reply_hdr->result);
270 goto error_exit;
271 }
272
273 if (TARGET_TO_HOST(lpPRB) && lpPRB->SRB_BufLen) {
274 memcpy(lpPRB->SRB_BufPointer, sg_reply_hdr + 1, lpPRB->SRB_BufLen);
275 }
276
277 /* copy in sense buffer to amount that is available in client */
278 if (lpPRB->SRB_SenseLen) {
279 int sense_len = lpPRB->SRB_SenseLen;
280 if (lpPRB->SRB_SenseLen > 16)
281 sense_len = 16;
282 memcpy(SENSE_BUFFER(lpPRB), &sg_reply_hdr->sense_buffer[0], sense_len);
283 }
284
285
286 lpPRB->SRB_Status = SS_COMP;
287 lpPRB->SRB_HaStat = HASTAT_OK;
288 lpPRB->SRB_TargStat = STATUS_GOOD;
289
290 /* now do posting */
291
292 if (lpPRB->SRB_PostProc) {
293 if (ASPI_POSTING(lpPRB)) {
294 TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
295 (*lpPRB->SRB_PostProc)(lpPRB);
296 }
297 else
298 if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY) {
299 TRACE("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc);
300 SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
301 }
302 }
303 free(sg_reply_hdr);
304 free(sg_hd);
305 ASPI_DebugPrintResult(lpPRB);
306 return SS_COMP;
307
308error_exit:
309 if (error_code == EBUSY) {
310 lpPRB->SRB_Status = SS_ASPI_IS_BUSY;
311 TRACE("Device busy\n");
312 }
313 else {
314 WARN("Failed\n");
315 lpPRB->SRB_Status = SS_ERR;
316 }
317
318 /* I'm not sure exactly error codes work here
319 * We probably should set lpPRB->SRB_TargStat, SRB_HaStat ?
320 */
321 WARN("error_exit\n");
322 free(sg_reply_hdr);
323 free(sg_hd);
324 return lpPRB->SRB_Status;
325}
326#endif
327
328// OS/2 ODIN implemetation code
329#ifdef _ODIN_H_
330
331static void
332ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
333{
334 BYTE cmd;
335 int i;
336 BYTE *cdb;
337
338 switch (prb->CDBByte[0]) {
339 case CMD_INQUIRY:
340 TRACE("{\n");
341 TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
342 TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
343 TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
344 TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
345 TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
346 TRACE("}\n");
347 break;
348 case CMD_SCAN_SCAN:
349 TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
350 break;
351 }
352
353 TRACE("Host Adapter: %d\n", prb->SRB_HaId);
354 TRACE("Flags: %d\n", prb->SRB_Flags);
355 if (TARGET_TO_HOST(prb)) {
356 TRACE("\tData transfer: Target to host. Length checked.\n");
357 }
358 else if (HOST_TO_TARGET(prb)) {
359 TRACE("\tData transfer: Host to target. Length checked.\n");
360 }
361 else if (NO_DATA_TRANSFERED(prb)) {
362 TRACE("\tData transfer: none\n");
363 }
364 else {
365 WARN("\tTransfer by scsi cmd. Length not checked.\n");
366 }
367
368 TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
369 TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
370 TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
371 TRACE("Target: %d\n", prb->SRB_Target);
372 TRACE("Lun: %d\n", prb->SRB_Lun);
373 TRACE("BufLen: %ld\n", prb->SRB_BufLen);
374 TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
375 TRACE("BufPtr: %p\n", prb->SRB_BufPointer);
376 TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
377 TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
378 cdb = &prb->CDBByte[0];
379 cmd = prb->CDBByte[0];
380 if (TRACE_ON(aspi))
381 {
382 DPRINTF("CDB buffer[");
383 for (i = 0; i < prb->SRB_CDBLen; i++) {
384 if (i != 0) DPRINTF(",");
385 DPRINTF("%02x", *cdb++);
386 }
387 DPRINTF("]\n");
388 }
389}
390
391static void
392ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
393{
394 int i;
395 BYTE *cdb;
396
397 if (TRACE_ON(aspi))
398 {
399 cdb = &prb->CDBByte[0];
400 DPRINTF("SenseArea[");
401 for (i = 0; i < prb->SRB_SenseLen; i++) {
402 if (i) DPRINTF(",");
403 DPRINTF("%02x", *cdb++);
404 }
405 DPRINTF("]\n");
406 }
407}
408
409static void
410ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
411{
412
413 switch (prb->CDBByte[0]) {
414 case CMD_INQUIRY:
415 TRACE("Vendor: '%s'\n", prb->SRB_BufPointer + INQUIRY_VENDOR);
416 break;
417 case CMD_TEST_UNIT_READY:
418 ASPI_PrintSenseArea(prb);
419 break;
420 }
421}
422
423
424static WORD
425ASPI_ExecScsiCmd( PODINASPIDATA pData,
426 SRB_ExecSCSICmd *lpPRB)
427{
428 int status;
429 int error_code = 0;
430 SRBOS2 SRBlock;
431 LONG rc;
432
433 ASPI_DebugPrintCmd(lpPRB);
434
435 lpPRB->SRB_Status = SS_PENDING;
436
437 if (!lpPRB->SRB_CDBLen)
438 {
439 WARN("Failed: lpPRB->SRB_CDBLen = 0.\n");
440 lpPRB->SRB_Status = SS_ERR;
441 return SS_ERR;
442 }
443
444 if(MaxCDBStatus<lpPRB->SRB_CDBLen)
445 {
446 WARN("Failed: lpPRB->SRB_CDBLen > 64.\n");
447 lpPRB->SRB_Status = SS_ERR;
448 return SS_ERR;
449 }
450
451 if(lpPRB->SRB_BufLen>65536) // Check Max 64k!!
452 {
453 WARN("Failed: lpPRB->SRB_BufLen > 65536.\n");
454 lpPRB->SRB_Status = SS_BUFFER_TO_BIG;
455 return SS_BUFFER_TO_BIG;
456 }
457
458 // copy up to LUN SRBOS2 has no WORD for padding like in WINE
459 memcpy( &SRBlock,
460 lpPRB,
461 6* sizeof(BYTE) + sizeof(DWORD));
462 SRBlock.flags |= SRB_Post;
463 SRBlock.u.cmd.sense_len = 32; // length of sense buffer
464 SRBlock.u.cmd.data_ptr = NULL; // pointer to data buffer
465 SRBlock.u.cmd.link_ptr = NULL; // pointer to next SRB
466 SRBlock.u.cmd.cdb_len = lpPRB->SRB_CDBLen; // SCSI command length
467 memcpy( &SRBlock.u.cmd.cdb_st[0],
468 &lpPRB->CDBByte[0],
469 lpPRB->SRB_CDBLen);
470
471 if (HOST_TO_TARGET(lpPRB))
472 {
473 // Write: Copy all Data to Communication Buffer
474 if (lpPRB->SRB_BufLen)
475 {
476 memcpy( pData->pvBuffer,
477 lpPRB->SRB_BufPointer,
478 lpPRB->SRB_BufLen);
479 }
480 }
481
482 rc = lSendSRBlock( pData->hfDriver,
483 &SRBlock,
484 &SRBlock);
485
486 if(!rc)
487 {
488 if( fWaitPost(pData->hevPost))
489 {
490 if (TARGET_TO_HOST(lpPRB))
491 {
492 // Was Read : Copy all Data from Communication Buffer
493 if (lpPRB->SRB_BufLen)
494 {
495 memcpy( lpPRB->SRB_BufPointer,
496 pData->pvBuffer,
497 lpPRB->SRB_BufLen);
498 }
499 }
500
501 if (lpPRB->SRB_SenseLen)
502 {
503 int sense_len = lpPRB->SRB_SenseLen;
504 if (lpPRB->SRB_SenseLen > 32)
505 sense_len = 32;
506 memcpy( SENSE_BUFFER(lpPRB),
507 &SRBlock.u.cmd.cdb_st[SRBlock.u.cmd.cdb_len],
508 sense_len);
509 }
510
511 /* now do posting */
512
513 if (lpPRB->SRB_PostProc)
514 {
515 if (ASPI_POSTING(lpPRB))
516 {
517 TRACE("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc);
518 (*lpPRB->SRB_PostProc)();
519 }
520 else
521 if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY)
522 {
523 TRACE("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc);
524 SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
525 }
526 }
527 }
528 lpPRB->SRB_Status = SRBlock.status;
529 lpPRB->SRB_HaStat = SRBlock.u.cmd.ha_status;
530 lpPRB->SRB_TargStat = SRBlock.u.cmd.target_status;
531 }
532 else
533 lpPRB->SRB_Status = SS_ERR;
534
535
536 ASPI_DebugPrintResult(lpPRB);
537
538 return lpPRB->SRB_Status;
539
540}
541#endif
542
543/*******************************************************************
544 * GetASPI32SupportInfo32 [WNASPI32.0]
545 *
546 * Checks if the ASPI subsystem is initialized correctly.
547 *
548 * RETURNS
549 * HIWORD: 0.
550 * HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
551 * LOBYTE of LOWORD: # of host adapters.
552 */
553#ifdef _ODIN_H_
554DWORD WINAPI GetASPI32SupportInfo()
555{
556 LONG rc;
557 ODINASPIDATA aspi;
558 ULONG hmtxDriver;
559 BYTE bNumDrv;
560 HKEY hkeyDrvInfo;
561 DWORD dwType;
562 DWORD dwData;
563 DWORD dwSize;
564 SRBOS2 SRBlock;
565 ULONG ulParam, ulReturn;
566 BYTE brc;
567
568 bNumDrv = 0;
569
570 if( fGainDrvAccess( FALSE, &hmtxDriver) ) // Do nonblocking call for info
571 {
572 brc = bOpenASPI(&aspi);
573 if(SS_COMP==brc )
574 {
575 SRBlock.cmd=SRB_Inquiry; // host adapter inquiry
576 SRBlock.ha_num=0; // host adapter number
577 SRBlock.flags=0; // no flags set
578
579 rc = lSendSRBlock( aspi.hfDriver,
580 &SRBlock,
581 &SRBlock);
582
583 if (!rc)
584 {
585 bNumDrv = SRBlock.u.inq.num_ha;
586
587 rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
588 "Software\\ODIN\\ASPIROUT",
589 &hkeyDrvInfo);
590 if(ERROR_SUCCESS==rc)
591 {
592 dwData = bNumDrv;
593 RegSetValueExA( hkeyDrvInfo,
594 "NumAdapers",
595 NULL,
596 REG_DWORD,
597 (LPBYTE)&dwData,
598 sizeof(DWORD));
599 RegCloseKey( hkeyDrvInfo);
600 }
601 }
602
603 fCloseASPI(&aspi);
604 }
605 else
606 brc = SS_FAILED_INIT;
607
608 fReleaseDrvAccess( hmtxDriver);
609 }
610 else
611 {
612 // Driver is used by other process/thread
613 // so try get value form registry
614
615 brc = SS_FAILED_INIT;
616 rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
617 "Software\\ODIN\\ASPIROUT",
618 &hkeyDrvInfo);
619
620 if(ERROR_SUCCESS!=rc)
621 return ((SS_FAILED_INIT << 8) | bNumDrv);
622
623 dwSize = sizeof(DWORD);
624 rc = RegQueryValueExA( hkeyDrvInfo,
625 "NumAdapers",
626 NULL,
627 &dwType,
628 (BYTE*)&dwData,
629 &dwSize);
630
631 RegCloseKey( hkeyDrvInfo);
632
633 if( (ERROR_SUCCESS==rc) &&
634 (REG_DWORD != dwType) )
635 {
636 bNumDrv = 0xFF & dwData;
637 brc = SS_COMP;
638 }
639 }
640
641 return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
642}
643#else
644DWORD WINAPI GetASPI32SupportInfo()
645{
646 return ((SS_COMP << 8) | 1); /* FIXME: get # of host adapters installed */
647}
648#endif
649
650/***********************************************************************
651 * SendASPI32Command32 (WNASPI32.1)
652 */
653DWORD __cdecl SendASPI32Command(LPSRB lpSRB)
654{
655#ifdef linux
656 switch (lpSRB->common.SRB_Cmd) {
657 case SC_HA_INQUIRY:
658 lpSRB->inquiry.SRB_Status = SS_COMP; /* completed successfully */
659 lpSRB->inquiry.HA_Count = 1; /* not always */
660 lpSRB->inquiry.HA_SCSI_ID = 7; /* not always ID 7 */
661 strcat(lpSRB->inquiry.HA_ManagerId, "ASPI for WIN32"); /* max 15 chars, don't change */
662 strcat(lpSRB->inquiry.HA_Identifier, "Wine host"); /* FIXME: return host adapter name */
663 memset(lpSRB->inquiry.HA_Unique, 0, 16); /* default HA_Unique content */
664 lpSRB->inquiry.HA_Unique[6] = 0x02; /* Maximum Transfer Length (128K, Byte> 4-7) */
665 FIXME("ASPI: Partially implemented SC_HA_INQUIRY for adapter %d.\n", lpSRB->inquiry.SRB_HaId);
666 return SS_COMP;
667 case SC_GET_DEV_TYPE:
668 FIXME("Not implemented SC_GET_DEV_TYPE\n");
669 break;
670 case SC_EXEC_SCSI_CMD:
671 return ASPI_ExecScsiCmd(&lpSRB->cmd);
672 break;
673 case SC_RESET_DEV:
674 FIXME("Not implemented SC_RESET_DEV\n");
675 break;
676 default:
677 WARN("Unknown command %d\n", lpSRB->common.SRB_Cmd);
678 }
679 return SS_INVALID_SRB;
680#else
681 #ifdef _ODIN_H_
682
683 SRBOS2 SRBlock;
684 DWORD dwRC;
685 ULONG ulParam, ulReturn;
686 BYTE bRC;
687 ODINASPIDATA aspi;
688 ULONG hmtxDriver;
689 LONG rc;
690
691 if(NULL==lpSRB)
692 return SS_INVALID_SRB; // Not sure what to return here but that is an error
693
694 // test first for a valid command
695 if( (SC_HA_INQUIRY!=lpSRB->common.SRB_Cmd) &&
696 (SC_GET_DEV_TYPE!=lpSRB->common.SRB_Cmd) &&
697 (SC_EXEC_SCSI_CMD!=lpSRB->common.SRB_Cmd) &&
698 (SC_ABORT_SRB!=lpSRB->common.SRB_Cmd) &&
699 (SC_RESET_DEV!=lpSRB->common.SRB_Cmd) )
700 return SS_INVALID_SRB; // shoud be invalid command
701
702 dwRC = SS_ERR;
703
704 if( fGainDrvAccess( TRUE, &hmtxDriver) ) // Block if a SRB is pending
705 {
706 bRC = bOpenASPI( &aspi);
707 if(SS_COMP==bRC)
708 {
709 switch (lpSRB->common.SRB_Cmd)
710 {
711 case SC_HA_INQUIRY:
712 SRBlock.cmd=SRB_Inquiry; // host adapter inquiry
713 SRBlock.ha_num=lpSRB->inquiry.SRB_HaId; // host adapter number
714 SRBlock.flags=0; // no flags set
715
716 rc = lSendSRBlock( aspi.hfDriver,
717 &SRBlock,
718 &SRBlock);
719 if (!rc)
720 {
721 memcpy( lpSRB,
722 &SRBlock,
723 sizeof(SRB_HaInquiry) );
724 dwRC = SRBlock.status;
725 }
726 break;
727 case SC_GET_DEV_TYPE:
728 memcpy( &SRBlock,
729 lpSRB,
730 sizeof(SRB_GDEVBlock));
731 SRBlock.flags = 0;
732
733 rc = lSendSRBlock( aspi.hfDriver,
734 &SRBlock,
735 &SRBlock);
736
737 if (!rc)
738 {
739 memcpy( lpSRB,
740 &SRBlock,
741 sizeof(SRB_GDEVBlock) );
742 lpSRB->devtype.SRB_Rsvd1 = 0x00;
743 dwRC = SRBlock.status;
744 }
745
746 break;
747 case SC_EXEC_SCSI_CMD:
748 dwRC = ASPI_ExecScsiCmd( &aspi,
749 &lpSRB->cmd);
750 break;
751 case SC_ABORT_SRB:
752 dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
753 break;
754 case SC_RESET_DEV:
755 memset( &SRBlock,
756 0,
757 sizeof(SRBOS2) );
758 SRBlock.cmd = lpSRB->reset.SRB_Cmd; /* ASPI command code = SC_RESET_DEV */
759 SRBlock.status = lpSRB->reset.SRB_Status; /* ASPI command status byte */
760 SRBlock.ha_num = lpSRB->reset.SRB_HaId; /* ASPI host adapter number */
761 SRBlock.flags = SRB_Post;
762 SRBlock.u.res.target = lpSRB->reset.SRB_Target; /* Target's SCSI ID */
763 SRBlock.u.res.lun = lpSRB->reset.SRB_Lun; /* Target's LUN number */
764
765 rc = lSendSRBlock( aspi.hfDriver,
766 &SRBlock,
767 &SRBlock);
768
769 if (!rc)
770 {
771 fWaitPost( aspi.hevPost );
772 lpSRB->reset.SRB_Status = SRBlock.status;
773 lpSRB->reset.SRB_Flags = SRBlock.flags;
774 lpSRB->reset.SRB_Hdr_Rsvd = 0;
775 memset( lpSRB->reset.SRB_Rsvd1,
776 0,
777 12 );
778 lpSRB->reset.SRB_HaStat = SRBlock.u.res.ha_status; /* Host Adapter Status */
779 lpSRB->reset.SRB_TargStat = SRBlock.u.res.target_status; /* Target Status */
780 lpSRB->reset.SRB_PostProc = NULL; /* Post routine */
781 lpSRB->reset.SRB_Rsvd2 = NULL; /* Reserved */
782 memset( lpSRB->reset.SRB_Rsvd3,
783 0,
784 32); /* Reserved */
785 dwRC = SRBlock.status;
786 }
787 break;
788 } // end switch (lpSRB->common.SRB_Cmd)
789
790 fCloseASPI(&aspi);
791 }
792 else
793 {
794 dwRC = bRC;
795 }
796
797 fReleaseDrvAccess( hmtxDriver);
798 }
799 else
800 {
801 dwRC = SS_NO_ASPI;
802 }
803
804 return dwRC;
805
806 #else
807 return SS_INVALID_SRB;
808 #endif
809#endif
810}
811
812
813/***********************************************************************
814 * GetASPI32DLLVersion32 (WNASPI32.3)
815 */
816
817DWORD WINAPI GetASPI32DLLVersion()
818{
819#ifdef linux
820 return (DWORD)1;
821#else
822 #ifdef _ODIN_H_
823 return (DWORD)1;
824 #else
825 return (DWORD)0;
826 #endif
827#endif
828}
829
Note: See TracBrowser for help on using the repository browser.