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

Last change on this file since 4336 was 4280, checked in by sandervl, 25 years ago

save & restore fs when calling ack function
File size: 13.6 KB
Line 
1/* $Id: winaspi32.cpp,v 1.10 2000-09-18 19:27:10 sandervl Exp $ */
2/*
3 * WNASPI routines
4 *
5 * Copyright 1999 Markus Montkowski
6 * Copyright 2000 Przemyslaw Dobrowolski
7 *
8 * Project Odin Software License can be found in LICENSE.TXT
9 *
10 */
11#include <os2win.h>
12#include <stdlib.h>
13#include <sys/types.h>
14#include <sys/stat.h>
15#include <errno.h>
16#include <fcntl.h>
17#include <memory.h>
18
19#include "aspi.h"
20#include "wnaspi32.h"
21#include <winreg.h>
22#include "options.h"
23#include "debugtools.h"
24
25//#include "srbos2.h"
26//#include "odinaspi.h"
27#include "aspilib.h"
28//#include "callback.h"
29
30#ifdef DEBUG
31#define DEBUG_BUFFER
32#endif
33
34DEFAULT_DEBUG_CHANNEL(aspi)
35ODINDEBUGCHANNEL(WNASPI32)
36
37static void
38ASPI_DebugPrintCmd(SRB_ExecSCSICmd *prb)
39{
40 BYTE cmd;
41 int i;
42 BYTE *cdb;
43
44 switch (prb->CDBByte[0]) {
45 case CMD_INQUIRY:
46 TRACE("{\n");
47 TRACE("\tEVPD: %d\n", prb->CDBByte[1] & 1);
48 TRACE("\tLUN: %d\n", (prb->CDBByte[1] & 0xc) >> 1);
49 TRACE("\tPAGE CODE: %d\n", prb->CDBByte[2]);
50 TRACE("\tALLOCATION LENGTH: %d\n", prb->CDBByte[4]);
51 TRACE("\tCONTROL: %d\n", prb->CDBByte[5]);
52 TRACE("}\n");
53 break;
54 case CMD_SCAN_SCAN:
55 TRACE("Transfer Length: %d\n", prb->CDBByte[4]);
56 break;
57 }
58
59 TRACE("Host Adapter: %d\n", prb->SRB_HaId);
60 TRACE("Flags: %d\n", prb->SRB_Flags);
61 if (TARGET_TO_HOST(prb)) {
62 TRACE("\tData transfer: Target to host. Length checked.\n");
63 }
64 else if (HOST_TO_TARGET(prb)) {
65 TRACE("\tData transfer: Host to target. Length checked.\n");
66 }
67 else if (NO_DATA_TRANSFERED(prb)) {
68 TRACE("\tData transfer: none\n");
69 }
70 else {
71 WARN("\tTransfer by scsi cmd. Length not checked.\n");
72 }
73
74 TRACE("\tResidual byte length reporting %s\n", prb->SRB_Flags & 0x4 ? "enabled" : "disabled");
75 TRACE("\tLinking %s\n", prb->SRB_Flags & 0x2 ? "enabled" : "disabled");
76 TRACE("\tPosting %s\n", prb->SRB_Flags & 0x1 ? "enabled" : "disabled");
77 TRACE("Target: %d\n", prb->SRB_Target);
78 TRACE("Lun: %d\n", prb->SRB_Lun);
79 TRACE("BufLen: %ld\n", prb->SRB_BufLen);
80 TRACE("SenseLen: %d\n", prb->SRB_SenseLen);
81 TRACE("BufPtr: %p\n", prb->SRB_BufPointer);
82 TRACE("CDB Length: %d\n", prb->SRB_CDBLen);
83 TRACE("POST Proc: %lx\n", (DWORD) prb->SRB_PostProc);
84 cdb = &prb->CDBByte[0];
85 cmd = prb->CDBByte[0];
86#ifdef DEBUG_BUFFER
87 dprintfNoEOL(("CDB buffer["));
88 for (i = 0; i < prb->SRB_CDBLen; i++) {
89 if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
90 else dprintfNoEOL(("0x%02x", *cdb++));
91 }
92 dprintfNoEOL(("]\n"));
93#endif
94}
95
96static void
97ASPI_PrintSenseArea(SRB_ExecSCSICmd *prb)
98{
99 int i;
100 BYTE *cdb;
101
102 if (TRACE_ON(aspi))
103 {
104 cdb = &prb->CDBByte[0];
105 DPRINTF("SenseArea[");
106 for (i = 0; i < prb->SRB_SenseLen; i++) {
107 if (i) DPRINTF(",");
108 DPRINTF("%02x", *cdb++);
109 }
110 DPRINTF("]\n");
111 }
112}
113
114static void
115ASPI_DebugPrintResult(SRB_ExecSCSICmd *prb)
116{
117
118 switch (prb->CDBByte[0]) {
119 case CMD_INQUIRY:
120 TRACE("Vendor: '%s'\n", prb->SRB_BufPointer + INQUIRY_VENDOR);
121 break;
122 case CMD_TEST_UNIT_READY:
123 ASPI_PrintSenseArea(prb);
124 break;
125 }
126 dprintf(("Result code: %x", prb->SRB_Status));
127}
128
129
130static WORD ASPI_ExecScsiCmd( scsiObj *aspi, SRB_ExecSCSICmd *lpPRB, USHORT sel)
131{
132 int status;
133 int error_code = 0;
134 LONG rc;
135
136 /* FIXME: hackmode */
137#define MAKE_TARGET_TO_HOST(lpPRB) \
138 if (!TARGET_TO_HOST(lpPRB)) { \
139 WARN("program was not sending target_to_host for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
140 lpPRB->SRB_Flags |= 8; \
141 }
142#define MAKE_HOST_TO_TARGET(lpPRB) \
143 if (!HOST_TO_TARGET(lpPRB)) { \
144 WARN("program was not sending host_to_target for cmd %x (flags=%x),correcting.\n",lpPRB->CDBByte[0],lpPRB->SRB_Flags); \
145 lpPRB->SRB_Flags |= 0x10; \
146 }
147 switch (lpPRB->CDBByte[0]) {
148 case 0x12: /* INQUIRY */
149 case 0x5a: /* MODE_SENSE_10 */
150 case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
151 case 0xad: /* READ DVD STRUCTURE MMC-2 */
152 MAKE_TARGET_TO_HOST(lpPRB)
153 break;
154 case 0xa3: /* SEND KEY (DVD) MMC-2 */
155 MAKE_HOST_TO_TARGET(lpPRB)
156 break;
157 default:
158 if ((((lpPRB->SRB_Flags & 0x18) == 0x00) ||
159 ((lpPRB->SRB_Flags & 0x18) == 0x18)
160 ) && lpPRB->SRB_BufLen
161 ) {
162 FIXME("command 0x%02x, no data transfer specified, but buflen is %ld!!!\n",lpPRB->CDBByte[0],lpPRB->SRB_BufLen);
163 }
164 break;
165 }
166
167 ASPI_DebugPrintCmd(lpPRB);
168
169 lpPRB->SRB_Status = SS_PENDING;
170
171 if (!lpPRB->SRB_CDBLen)
172 {
173 dprintf(("Failed: lpPRB->SRB_CDBLen = 0."));
174 lpPRB->SRB_Status = SS_ERR;
175 return SS_ERR;
176 }
177
178 if(MaxCDBStatus<lpPRB->SRB_CDBLen)
179 {
180 dprintf(("Failed: lpPRB->SRB_CDBLen > 64."));
181 lpPRB->SRB_Status = SS_ERR;
182 return SS_ERR;
183 }
184
185 if(lpPRB->SRB_BufLen>65536) // Check Max 64k!!
186 {
187 dprintf(("Failed: lpPRB->SRB_BufLen > 65536."));
188 lpPRB->SRB_Status = SS_BUFFER_TO_BIG;
189 return SS_BUFFER_TO_BIG;
190 }
191
192 // copy up to LUN SRBOS2 has no WORD for padding like in WINE
193 memcpy( &aspi->SRBlock,
194 lpPRB,
195 6* sizeof(BYTE) + sizeof(DWORD));
196 aspi->SRBlock.flags |= SRB_Post;
197 aspi->SRBlock.u.cmd.sense_len = lpPRB->SRB_SenseLen;; // length of sense buffer
198 aspi->SRBlock.u.cmd.data_ptr = NULL; // pointer to data buffer
199 aspi->SRBlock.u.cmd.link_ptr = NULL; // pointer to next SRB
200 aspi->SRBlock.u.cmd.data_len = lpPRB->SRB_BufLen;
201 aspi->SRBlock.u.cmd.cdb_len = lpPRB->SRB_CDBLen; // SCSI command length
202 memcpy( &aspi->SRBlock.u.cmd.cdb_st[0],
203 &lpPRB->CDBByte[0],
204 lpPRB->SRB_CDBLen);
205
206 if (HOST_TO_TARGET(lpPRB))
207 {
208 // Write: Copy all Data to Communication Buffer
209 if (lpPRB->SRB_BufLen)
210 {
211 memcpy( aspi->buffer,
212 lpPRB->SRB_BufPointer,
213 lpPRB->SRB_BufLen);
214
215#ifdef DEBUG_BUFFER
216 char *cdb = (char *)lpPRB->SRB_BufPointer;
217 dprintfNoEOL(("Write SRB buffer["));
218 for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
219 if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
220 else dprintfNoEOL(("0x%02x", *cdb++));
221 }
222 dprintfNoEOL(("]\n"));
223#endif
224 }
225 }
226
227 rc = aspi->SendSRBlock();
228
229 if(!rc)
230 {
231 if( aspi->waitPost())
232 {
233 if (TARGET_TO_HOST(lpPRB))
234 {
235 // Was Read : Copy all Data from Communication Buffer
236 if (lpPRB->SRB_BufLen)
237 {
238 memcpy( lpPRB->SRB_BufPointer,
239 aspi->buffer,
240 lpPRB->SRB_BufLen);
241#ifdef DEBUG_BUFFER
242 char *cdb = (char *)lpPRB->SRB_BufPointer;
243 dprintfNoEOL(("Read SRB buffer["));
244 for (int i = 0; i < lpPRB->SRB_BufLen; i++) {
245 if (i != 0) dprintfNoEOL((",0x%02x", *cdb++));
246 else dprintfNoEOL(("0x%02x", *cdb++));
247 }
248 dprintfNoEOL(("]\n"));
249#endif
250 }
251 }
252
253 if (lpPRB->SRB_SenseLen)
254 {
255 int sense_len = lpPRB->SRB_SenseLen;
256 if (lpPRB->SRB_SenseLen > 32)
257 sense_len = 32;
258 memcpy( SENSE_BUFFER(lpPRB),
259 &aspi->SRBlock.u.cmd.cdb_st[aspi->SRBlock.u.cmd.cdb_len],
260 sense_len);
261 }
262
263#if 0
264 /* FIXME: Should this be != 0 maybe? */
265 if(aspi->SRBlock.u.cmd.target_status == 2 ) {
266 aspi->SRBlock.status = SS_ERR;
267 switch (lpPRB->CDBByte[0]) {
268 case 0xa4: /* REPORT_KEY (DVD) MMC-2 */
269 case 0xa3: /* SEND KEY (DVD) MMC-2 */
270 aspi->SRBlock.status = SS_COMP;
271 aspi->SRBlock.u.cmd.target_status = 0;
272 FIXME("Program wants to do DVD Region switching, but fails (non compliant DVD drive). Ignoring....\n");
273 break;
274 }
275 }
276#endif
277 /* now do posting */
278 if (lpPRB->SRB_PostProc)
279 {
280 if(ASPI_POSTING(lpPRB))
281 {
282 dprintf(("Post Routine (%lx) called\n", (DWORD) lpPRB->SRB_PostProc));
283 //SvL: Restore win32 FS selector
284 SetFS(sel);
285 (*lpPRB->SRB_PostProc)();
286 RestoreOS2FS();
287 }
288 else
289 if (lpPRB->SRB_Flags & SRB_EVENT_NOTIFY)
290 {
291 dprintf(("Setting event %04x\n", (HANDLE)lpPRB->SRB_PostProc));
292 SetEvent((HANDLE)lpPRB->SRB_PostProc); /* FIXME: correct ? */
293 }
294 }
295 }
296 }
297 else
298 lpPRB->SRB_Status = SS_ERR;
299
300 //SvL: Shouldn't this be set before posting?
301 lpPRB->SRB_Status = aspi->SRBlock.status;
302 lpPRB->SRB_HaStat = aspi->SRBlock.u.cmd.ha_status;
303 lpPRB->SRB_TargStat = aspi->SRBlock.u.cmd.target_status;
304
305 ASPI_DebugPrintResult(lpPRB);
306
307 return lpPRB->SRB_Status;
308}
309
310/*******************************************************************
311 * GetASPI32SupportInfo32 [WNASPI32.0]
312 *
313 * Checks if the ASPI subsystem is initialized correctly.
314 *
315 * RETURNS
316 * HIWORD: 0.
317 * HIBYTE of LOWORD: status (SS_COMP or SS_FAILED_INIT)
318 * LOBYTE of LOWORD: # of host adapters.
319 */
320ODINFUNCTION0(DWORD, GetASPI32SupportInfo)
321{
322 LONG rc;
323 BYTE bNumDrv;
324 HKEY hkeyDrvInfo;
325 DWORD dwType;
326 DWORD dwData;
327 DWORD dwSize;
328 ULONG ulParam, ulReturn;
329 BYTE brc;
330
331 bNumDrv = 0;
332
333 if(aspi->access(FALSE)) //'non-blocking' call
334 {
335 bNumDrv = aspi->getNumHosts();
336 brc = SS_COMP;
337 rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
338 "Software\\ODIN\\ASPIROUT",
339 &hkeyDrvInfo);
340 if(ERROR_SUCCESS==rc)
341 {
342 dwData = bNumDrv;
343 RegSetValueExA( hkeyDrvInfo,
344 "NumAdapers",
345 NULL,
346 REG_DWORD,
347 (LPBYTE)&dwData,
348 sizeof(DWORD));
349 RegCloseKey( hkeyDrvInfo);
350 }
351 aspi->release();
352 }
353 else
354 {
355 // Driver is used by other process/thread
356 // so try get value form registry
357
358 brc = SS_FAILED_INIT;
359 rc = RegOpenKeyA ( HKEY_LOCAL_MACHINE,
360 "Software\\ODIN\\ASPIROUT",
361 &hkeyDrvInfo);
362
363 if(ERROR_SUCCESS!=rc)
364 return ((SS_FAILED_INIT << 8) | bNumDrv);
365
366 dwSize = sizeof(DWORD);
367 rc = RegQueryValueExA( hkeyDrvInfo,
368 "NumAdapers",
369 NULL,
370 &dwType,
371 (BYTE*)&dwData,
372 &dwSize);
373
374 RegCloseKey( hkeyDrvInfo);
375
376 if( (ERROR_SUCCESS==rc) &&
377 (REG_DWORD != dwType) )
378 {
379 bNumDrv = 0xFF & dwData;
380 brc = SS_COMP;
381 }
382 }
383
384 return ((brc << 8) | bNumDrv); /* FIXME: get # of host adapters installed */
385}
386
387/***********************************************************************
388 * SendASPI32Command32 (WNASPI32.1)
389 */
390DWORD SendASPICommand(LPSRB lpSRB, USHORT sel)
391{
392 DWORD dwRC;
393 ULONG ulParam, ulReturn;
394 BYTE bRC;
395 LONG rc;
396
397 if(NULL==lpSRB)
398 return SS_INVALID_SRB; // Not sure what to return here but that is an error
399
400 dprintf(("SendASPI32Command %x %d", lpSRB, lpSRB->common.SRB_Cmd));
401
402 // test first for a valid command
403 if( (SC_HA_INQUIRY!=lpSRB->common.SRB_Cmd) &&
404 (SC_GET_DEV_TYPE!=lpSRB->common.SRB_Cmd) &&
405 (SC_EXEC_SCSI_CMD!=lpSRB->common.SRB_Cmd) &&
406 (SC_ABORT_SRB!=lpSRB->common.SRB_Cmd) &&
407 (SC_RESET_DEV!=lpSRB->common.SRB_Cmd) )
408 {
409 dprintf(("Invalid command!"));
410 return SS_INVALID_SRB; // shoud be invalid command
411 }
412
413 dwRC = SS_ERR;
414
415 if(aspi->access(TRUE)) // Block if a SRB is pending
416 {
417 switch (lpSRB->common.SRB_Cmd)
418 {
419 case SC_HA_INQUIRY:
420 aspi->HA_inquiry(lpSRB->inquiry.SRB_HaId);
421 memset(lpSRB,0,sizeof(SRB_HaInquiry));
422 memcpy( lpSRB,
423 &aspi->SRBlock,
424 sizeof(SRB_HaInquiry)-4 );
425 // FIXME: I'dont know why in OS/2->ha_unique are filled with 0
426 // Hackmode ON ======
427 lpSRB->inquiry.HA_Unique[6] = 0x01; // transfer only 64KB
428 lpSRB->inquiry.HA_Unique[3] = 0x10; // 16 devices.
429 // HackMode OFF =====
430 dwRC = aspi->SRBlock.status;
431 break;
432
433 case SC_GET_DEV_TYPE:
434 rc=aspi->getDeviceType(lpSRB->devtype.SRB_HaId,lpSRB->devtype.SRB_Target, lpSRB->devtype.SRB_Lun);
435 dwRC = lpSRB->devtype.SRB_Status = aspi->SRBlock.status;
436 lpSRB->devtype.SRB_DeviceType = aspi->SRBlock.u.dev.devtype;
437 break;
438
439 case SC_EXEC_SCSI_CMD:
440 dwRC = ASPI_ExecScsiCmd( aspi, &lpSRB->cmd, sel);
441 break;
442
443 case SC_ABORT_SRB:
444 dwRC = SS_INVALID_SRB; // We don't do async ASPI so no way to abort
445 break;
446
447 case SC_RESET_DEV:
448 aspi->resetDevice(lpSRB->reset.SRB_HaId,lpSRB->reset.SRB_Target, lpSRB->reset.SRB_Lun);
449 lpSRB->reset.SRB_Status = aspi->SRBlock.status;
450 lpSRB->reset.SRB_Flags = aspi->SRBlock.flags;
451 lpSRB->reset.SRB_Hdr_Rsvd = 0;
452 memset( lpSRB->reset.SRB_Rsvd1,
453 0,
454 12 );
455 lpSRB->reset.SRB_HaStat = aspi->SRBlock.u.res.ha_status; /* Host Adapter Status */
456 lpSRB->reset.SRB_TargStat = aspi->SRBlock.u.res.target_status; /* Target Status */
457 lpSRB->reset.SRB_PostProc = NULL; /* Post routine */
458 lpSRB->reset.SRB_Rsvd2 = NULL; /* Reserved */
459 memset( lpSRB->reset.SRB_Rsvd3,
460 0,
461 32); /* Reserved */
462 dwRC = aspi->SRBlock.status;
463 break;
464
465 } // end switch (lpSRB->common.SRB_Cmd)
466
467 aspi->release();
468 }
469 else
470 {
471 dwRC = SS_NO_ASPI;
472 }
473
474 return dwRC;
475}
476
477DWORD CDECL SendASPI32Command(LPSRB lpSRB)
478{
479 DWORD yyrc;
480 USHORT sel = RestoreOS2FS();
481
482 yyrc = SendASPICommand(lpSRB, sel);
483 SetFS(sel);
484
485 return yyrc;
486}
487
488
489/***********************************************************************
490 * GetASPI32DLLVersion32 (WNASPI32.3)
491 */
492DWORD WINAPI GetASPI32DLLVersion()
493{
494 return (DWORD)1;
495}
496
Note: See TracBrowser for help on using the repository browser.