home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / aspir101.zip / aspilib.cpp next >
C/C++ Source or Header  |  1997-06-08  |  49KB  |  930 lines
  1. //***************************************************************************
  2. //*                                                                         *
  3. //*  ASPI Router Library                                                    *
  4. //*                                                                         *
  5. //*  This is a sample library which shows how to send SRB's to the          *
  6. //*  ASPI Router device driver. USE AT YOUR OWN RISK!!                      *
  7. //*                                                                         *
  8. //*  Version 1.01 - June 1997                                               *
  9. //*                                                                         *
  10. //*  Changes since 1.00:                                                    *
  11. //*  abort() added                                                          *
  12. //*                                                                         *
  13. //***************************************************************************
  14.  
  15.  
  16. #include "aspilib.h"
  17.  
  18.  
  19. //***************************************************************************
  20. //*                                                                         *
  21. //*  scsiObj()                                                              *
  22. //*                                                                         *
  23. //*  Standard constructor                                                   *
  24. //*                                                                         *
  25. //***************************************************************************
  26. scsiObj::scsiObj()
  27. {
  28. }
  29.  
  30.  
  31. //***************************************************************************
  32. //*                                                                         *
  33. //*  ~scsiObj()                                                             *
  34. //*                                                                         *
  35. //*  Standard destructor                                                    *
  36. //*                                                                         *
  37. //***************************************************************************
  38. scsiObj::~scsiObj()
  39. {
  40. }
  41.  
  42.  
  43. //***************************************************************************
  44. //*                                                                         *
  45. //*  BOOL openDriver()                                                      *
  46. //*                                                                         *
  47. //*  Opens the ASPI Router device driver and sets device_handle.            *
  48. //*  Returns:                                                               *
  49. //*    TRUE - Success                                                       *
  50. //*    FALSE - Unsuccessful opening of device driver                        *
  51. //*                                                                         *
  52. //*  Preconditions: ASPI Router driver has be loaded                        *
  53. //*                                                                         *
  54. //***************************************************************************
  55. BOOL scsiObj::openDriver()
  56. {
  57.   ULONG rc;                                             // return value
  58.   ULONG ActionTaken;                                    // return value
  59.  
  60.   rc = DosOpen((PSZ) "aspirou$",                        // open driver
  61.                &driver_handle,
  62.                &ActionTaken,
  63.                0,
  64.                0,
  65.                FILE_OPEN,
  66.                OPEN_SHARE_DENYREADWRITE | OPEN_ACCESS_READWRITE,
  67.                NULL);
  68.   if (rc) return FALSE;                                 // opening failed -> return false
  69.   return TRUE;
  70. }
  71.  
  72.  
  73. //***************************************************************************
  74. //*                                                                         *
  75. //*  BOOL closeDriver()                                                     *
  76. //*                                                                         *
  77. //*  Closes the device driver                                               *
  78. //*  Returns:                                                               *
  79. //*    TRUE - Success                                                       *
  80. //*    FALSE - Unsuccessful closing of device driver                        *
  81. //*                                                                         *
  82. //*  Preconditions: ASPI Router driver has be opened with openDriver        *
  83. //*                                                                         *
  84. //***************************************************************************
  85. BOOL scsiObj::closeDriver()
  86. {
  87.   ULONG rc;                                             // return value
  88.  
  89.   rc = DosClose(driver_handle);
  90.   if (rc) return FALSE;                                 // closing failed -> return false
  91.   return TRUE;
  92. }
  93.  
  94.  
  95. //***************************************************************************
  96. //*                                                                         *
  97. //*  BOOL initSemaphore()                                                   *
  98. //*                                                                         *
  99. //*  Creates a new Event Semaphore and passes its handle to ASPI Router.    *
  100. //*  Returns:                                                               *
  101. //*    TRUE - Success                                                       *
  102. //*    FALSE - Unsuccessful creation of event semaphore                     *
  103. //*                                                                         *
  104. //*  Preconditions: driver_handle has to be set with openDriver             *
  105. //*                                                                         *
  106. //***************************************************************************
  107. BOOL scsiObj::initSemaphore()
  108. {
  109.   ULONG  rc;                                            // return value
  110.   USHORT openSemaReturn;                                // return value
  111.   unsigned long cbreturn;
  112.   unsigned long cbParam;
  113.  
  114.   rc = DosCreateEventSem(NULL, &postSema,               // create event semaphore
  115.                          DC_SEM_SHARED, 0);
  116.   if (rc) return FALSE;                                 // DosCreateEventSem failed
  117.   rc = DosDevIOCtl(driver_handle, 0x92, 0x03,           // pass semaphore handle
  118.                    (void*) &postSema, sizeof(HEV),      // to driver
  119.                    &cbParam, (void*) &openSemaReturn,
  120.                    sizeof(USHORT), &cbreturn);
  121.   if (rc) return FALSE;                                 // DosDevIOCtl failed
  122.   if (openSemaReturn) return FALSE;                     // Driver could not open semaphore
  123.  
  124.   return TRUE;
  125. }
  126.  
  127.  
  128. //***************************************************************************
  129. //*                                                                         *
  130. //*  BOOL closeSemaphore()                                                  *
  131. //*                                                                         *
  132. //*  Closes the Event Semaphore                                             *
  133. //*  Returns:                                                               *
  134. //*    TRUE - Success                                                       *
  135. //*    FALSE - Unsuccessful closing of event semaphore                      *
  136. //*                                                                         *
  137. //*  Preconditions: init_Semaphore has to be called successfully before     *
  138. //*                                                                         *
  139. //***************************************************************************
  140. BOOL scsiObj::closeSemaphore()
  141. {
  142.   ULONG  rc;                                            // return value
  143.  
  144.   rc = DosCloseEventSem(postSema);                      // close event semaphore
  145.   if (rc) return FALSE;                                 // DosCloseEventSem failed
  146.   return TRUE;
  147. }
  148.  
  149.  
  150. //***************************************************************************
  151. //*                                                                         *
  152. //*  BOOL initBuffer()                                                      *
  153. //*                                                                         *
  154. //*  Sends the address of the data buffer to ASPI Router so that it can     *
  155. //*  lock down the segment.                                                 *
  156. //*  Returns:                                                               *
  157. //*    TRUE - Success                                                       *
  158. //*    FALSE - Unsuccessful locking of buffer segment                       *
  159. //*                                                                         *
  160. //*  Preconditions: (called from init())                                    *
  161. //*                                                                         *
  162. //***************************************************************************
  163. BOOL scsiObj::initBuffer()
  164. {
  165.   ULONG  rc;                                            // return value
  166.   USHORT lockSegmentReturn;                             // return value
  167.   unsigned long cbreturn;
  168.   unsigned long cbParam;
  169.  
  170.   rc = DosDevIOCtl(driver_handle, 0x92, 0x04,           // pass buffer pointer
  171.                    (void*) buffer, sizeof(PVOID),       // to driver
  172.                    &cbParam, (void*) &lockSegmentReturn,
  173.                    sizeof(USHORT), &cbreturn);
  174.   if (rc) return FALSE;                                 // DosDevIOCtl failed
  175.   if (lockSegmentReturn) return FALSE;                  // Driver could not lock segment
  176.  
  177.   return TRUE;
  178. }
  179.  
  180.  
  181. //***************************************************************************
  182. //*                                                                         *
  183. //*  BOOL init(ULONG bufsize)                                               *
  184. //*                                                                         *
  185. //*  This inits the ASPI library and ASPI router driver.                    *
  186. //*  Allocates the data buffer and passes its address to the driver         *
  187. //*  Returns:                                                               *
  188. //*    TRUE - Success                                                       *
  189. //*    FALSE - Unsuccessful initialization of driver and library            *
  190. //*                                                                         *
  191. //*  Preconditions: ASPI router device driver has to be loaded              *
  192. //*                                                                         *
  193. //***************************************************************************
  194. BOOL scsiObj::init(ULONG bufsize)
  195. {
  196.   BOOL  success;
  197.   ULONG rc;
  198.  
  199.   rc = DosAllocMem(&buffer, bufsize, OBJ_TILE | PAG_READ | PAG_WRITE | PAG_COMMIT);
  200.   if (rc) return FALSE;
  201.   success=openDriver();                         // call openDriver member function
  202.   if (!success) return FALSE;
  203.   success=initSemaphore();                      // call initSemaphore member function
  204.   if (!success) return FALSE;
  205.  
  206.   success=initBuffer();
  207.  
  208.   return TRUE;
  209. }
  210.  
  211.  
  212. //***************************************************************************
  213. //*                                                                         *
  214. //*  BOOL close()                                                           *
  215. //*                                                                         *
  216. //*  This closes the ASPI library and ASPI router driver and frees          *
  217. //*  the memory allocated for the data buffer.
  218. //*  Returns:                                                               *
  219. //*    TRUE - Success                                                       *
  220. //*    FALSE - Unsuccessful closing of library and driver                   *
  221. //*                                                                         *
  222. //*  Preconditions: init() should be called successfully before             *
  223. //*                                                                         *
  224. //***************************************************************************
  225. BOOL scsiObj::close()
  226. {
  227.   BOOL success;
  228.   ULONG rc;
  229.  
  230.   success=closeSemaphore();                     // call closeSemaphore member function
  231.   if (!success)
  232.   {
  233.     printf("closeSemaphore() unsuccessful.\n");
  234.     return FALSE;
  235.   }
  236.   success=closeDriver();                        // call closeDriver member function
  237.   if (!success)
  238.   {
  239.     return FALSE;
  240.     printf("closeDriver() unsucessful.\n");
  241.   }
  242.   rc = DosFreeMem(buffer);
  243.   if (rc)
  244.   {
  245.     printf("DosFreeMem unsuccessful. return code: %ld\n", rc);
  246.     return FALSE;
  247.   }
  248.   return TRUE;
  249. }
  250.  
  251.  
  252. //***************************************************************************
  253. //*                                                                         *
  254. //*  BOOL waitPost()                                                        *
  255. //*                                                                         *
  256. //*  Waits for postSema being posted by device driver                       *
  257. //*  Returns:                                                               *
  258. //*    TRUE - Success                                                       *
  259. //*    FALSE - Unsuccessful access of event semaphore                       *
  260. //*                                                                         *
  261. //*  Preconditions: init() has to be called successfully before             *
  262. //*                                                                         *
  263. //***************************************************************************
  264. BOOL scsiObj::waitPost()
  265. {
  266.   ULONG count=0;
  267.   ULONG rc;                                             // return value
  268.  
  269.   rc = DosWaitEventSem(postSema, -1);                   // wait forever
  270.   if (rc) return FALSE;                                 // DosWaitEventSem failed
  271.   rc = DosResetEventSem(postSema, &count);              // reset semaphore
  272.   if (rc) return FALSE;                                 // DosResetEventSem failed
  273.   return TRUE;
  274. }
  275.  
  276. //***************************************************************************
  277. //*                                                                         *
  278. //*  ULONG rewind(UCHAR id, UCHAR lun)                                      *
  279. //*                                                                         *
  280. //*  Sends a SRB containing a rewind command                                *
  281. //*  Returns:                                                               *
  282. //*    0  - Success                                                         *
  283. //*    1  - DevIOCtl failed                                                 *
  284. //*    2  - Semaphore access failure                                        *
  285. //*    3  - SCSI command failed                                             *
  286. //*                                                                         *
  287. //*  Preconditions: init() has to be called successfully before             *
  288. //*                                                                         *
  289. //***************************************************************************
  290. ULONG scsiObj::rewind(UCHAR id, UCHAR lun)
  291. {
  292.   ULONG rc;                                     // return value
  293.   BOOL  success;                                // return value
  294.   unsigned long cbreturn;
  295.   unsigned long cbParam;
  296.  
  297.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  298.   SRBlock.ha_num=0;                             // host adapter number
  299.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  300.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  301.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  302.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  303.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  304.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  305.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  306.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  307.   SRBlock.u.cmd.cdb_st[0]=1;                    // rewind command
  308.   SRBlock.u.cmd.cdb_st[1]=0;
  309.   SRBlock.u.cmd.cdb_st[2]=0;
  310.   SRBlock.u.cmd.cdb_st[3]=0;
  311.   SRBlock.u.cmd.cdb_st[4]=0;
  312.   SRBlock.u.cmd.cdb_st[5]=0;
  313.  
  314.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  315.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  316.   if (rc)
  317.     return 1;                                   // DosDevIOCtl failed
  318.   else
  319.   {
  320.     success=waitPost();                         // wait for SRB being processed
  321.     if (!success) return 2;                     // semaphore could not be accessed
  322.   }
  323.   if (SRBlock.status != SRB_Done) return 3;
  324.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  325.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  326.   return 0;
  327. }
  328.  
  329.  
  330. //***************************************************************************
  331. //*                                                                         *
  332. //*  ULONG read(UCHAR id, UCHAR lun, ULONG transfer)                        *
  333. //*                                                                         *
  334. //*  Sends a SRB containing a read command                                  *
  335. //*  Returns:                                                               *
  336. //*    0  - Success                                                         *
  337. //*    1  - DevIOCtl failed                                                 *
  338. //*    2  - Semaphore access failure                                        *
  339. //*    3  - SCSI command failed                                             *
  340. //*                                                                         *
  341. //*  Preconditions: init() has to be called successfully before             *
  342. //*                                                                         *
  343. //***************************************************************************
  344. ULONG scsiObj::read(UCHAR id, UCHAR lun, ULONG transfer)
  345. {
  346.   ULONG rc;                                     // return value
  347.   BOOL  success;                                // return value
  348.   unsigned long cbreturn;
  349.   unsigned long cbParam;
  350.  
  351.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  352.   SRBlock.ha_num=0;                             // host adapter number
  353.   SRBlock.flags=SRB_Read | SRB_Post;            // data transfer, posting enabled
  354.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  355.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  356.   SRBlock.u.cmd.data_len=512*transfer;          // # of bytes transferred
  357.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  358.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  359.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  360.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  361.   SRBlock.u.cmd.cdb_st[0]=0x08;                 // read command
  362.   SRBlock.u.cmd.cdb_st[1]=1;                    // fixed length
  363.   SRBlock.u.cmd.cdb_st[2]=(transfer >> 16) & 0xFF;  // transfer length MSB
  364.   SRBlock.u.cmd.cdb_st[3]=(transfer >> 8) & 0xFF;   // transfer length
  365.   SRBlock.u.cmd.cdb_st[4]=transfer & 0xFF;          // transfer length LSB
  366.   SRBlock.u.cmd.cdb_st[5]=0;
  367.  
  368.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  369.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  370.   if (rc)
  371.     return 1;                                   // DosDevIOCtl failed
  372.   else
  373.   {
  374.     success=waitPost();                         // wait for SRB being processed
  375.     if (!success) return 2;                     // semaphore could not be accessed
  376.   }
  377.   if (SRBlock.status != SRB_Done) return 3;
  378.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  379.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  380.   return 0;
  381. }
  382.  
  383.  
  384. //***************************************************************************
  385. //*                                                                         *
  386. //*  ULONG locate(UCHAR id, UCHAR lun, ULONG block)                         *
  387. //*                                                                         *
  388. //*  Sends a SRB containing a locate command                                *
  389. //*  Returns:                                                               *
  390. //*    0  - Success                                                         *
  391. //*    1  - DevIOCtl failed                                                 *
  392. //*    2  - Semaphore access failure                                        *
  393. //*    3  - SCSI command failed                                             *
  394. //*                                                                         *
  395. //*  Preconditions: init() has to be called successfully before             *
  396. //*                                                                         *
  397. //***************************************************************************
  398. ULONG scsiObj::locate(UCHAR id, UCHAR lun, ULONG block)
  399. {
  400.   ULONG rc;                                     // return value
  401.   BOOL  success;                                // return value
  402.   unsigned long cbreturn;
  403.   unsigned long cbParam;
  404.  
  405.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  406.   SRBlock.ha_num=0;                             // host adapter number
  407.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  408.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  409.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  410.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  411.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  412.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  413.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  414.   SRBlock.u.cmd.cdb_len=10;                     // SCSI command length
  415.   SRBlock.u.cmd.cdb_st[0]=0x2B;                 // locate command
  416.   SRBlock.u.cmd.cdb_st[1]=0;
  417.   SRBlock.u.cmd.cdb_st[2]=0;
  418.   SRBlock.u.cmd.cdb_st[3]=(block >> 24);        // block MSB
  419.   SRBlock.u.cmd.cdb_st[4]=(block >> 16) & 0xFF; // block
  420.   SRBlock.u.cmd.cdb_st[5]=(block >> 8) & 0xFF;  // block
  421.   SRBlock.u.cmd.cdb_st[6]=block & 0xFF;         // block LSB
  422.   SRBlock.u.cmd.cdb_st[7]=0;
  423.   SRBlock.u.cmd.cdb_st[8]=0;
  424.   SRBlock.u.cmd.cdb_st[9]=0;
  425.  
  426.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  427.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  428.   if (rc)
  429.     return 1;                                   // DosDevIOCtl failed
  430.   else
  431.   {
  432.     success=waitPost();                         // wait for SRB being processed
  433.     if (!success) return 2;                     // semaphore could not be accessed
  434.   }
  435.   if (SRBlock.status != SRB_Done) return 3;
  436.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  437.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  438.   return 0;
  439. }
  440.  
  441.  
  442. //***************************************************************************
  443. //*                                                                         *
  444. //*  ULONG unload(UCHAR id, UCHAR lun)                                      *
  445. //*                                                                         *
  446. //*  Sends a SRB containing a unload command                                *
  447. //*  Returns:                                                               *
  448. //*    0  - Success                                                         *
  449. //*    1  - DevIOCtl failed                                                 *
  450. //*    2  - Semaphore access failure                                        *
  451. //*    3  - SCSI command failed                                             *
  452. //*                                                                         *
  453. //*  Preconditions: init() has to be called successfully before             *
  454. //*                                                                         *
  455. //***************************************************************************
  456. ULONG scsiObj::unload(UCHAR id, UCHAR lun)
  457. {
  458.   ULONG rc;                                     // return value
  459.   BOOL  success;                                // return value
  460.   unsigned long cbreturn;
  461.   unsigned long cbParam;
  462.  
  463.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  464.   SRBlock.ha_num=0;                             // host adapter number
  465.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  466.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  467.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  468.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  469.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  470.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  471.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  472.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  473.   SRBlock.u.cmd.cdb_st[0]=0x1B;                 // unload command
  474.   SRBlock.u.cmd.cdb_st[1]=0;
  475.   SRBlock.u.cmd.cdb_st[2]=0;
  476.   SRBlock.u.cmd.cdb_st[3]=0;
  477.   SRBlock.u.cmd.cdb_st[4]=0;
  478.   SRBlock.u.cmd.cdb_st[5]=0;
  479.  
  480.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  481.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  482.   if (rc)
  483.     return 1;                                   // DosDevIOCtl failed
  484.   else
  485.   {
  486.     success=waitPost();                         // wait for SRB being processed
  487.     if (!success) return 2;                     // semaphore could not be accessed
  488.   }
  489.   if (SRBlock.status != SRB_Done) return 3;
  490.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  491.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  492.   return 0;
  493. }
  494.  
  495.  
  496. //***************************************************************************
  497. //*                                                                         *
  498. //*  ULONG read_position(UCHAR id, UCHAR lun, ULONG* pos, ULONG* partition, *
  499. //*                      BOOL* BOP, BOOL* EOP)                              *
  500. //*                                                                         *
  501. //*  Sends a SRB containing a read_position command                         *
  502. //*  Returns:                                                               *
  503. //*    0  - Success                                                         *
  504. //*    1  - DevIOCtl failed                                                 *
  505. //*    2  - Semaphore access failure                                        *
  506. //*    3  - SCSI command failed                                             *
  507. //*                                                                         *
  508. //*  Preconditions: init() has to be called successfully before             *
  509. //*                                                                         *
  510. //***************************************************************************
  511. ULONG scsiObj::read_position(UCHAR id, UCHAR lun, ULONG* pos, ULONG* partition,
  512.                              BOOL* BOP, BOOL* EOP)
  513. {
  514.   ULONG rc;                                     // return value
  515.   BOOL  success;                                // return value
  516.   unsigned long cbreturn;
  517.   unsigned long cbParam;
  518.   UCHAR* p;
  519.  
  520.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  521.   SRBlock.ha_num=0;                             // host adapter number
  522.   SRBlock.flags=SRB_Read | SRB_Post;            // data transfer, posting enabled
  523.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  524.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  525.   SRBlock.u.cmd.data_len=20;                    // # of bytes transferred
  526.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  527.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  528.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  529.   SRBlock.u.cmd.cdb_len=10;                     // SCSI command length
  530.   SRBlock.u.cmd.cdb_st[0]=0x34;                 // read position command
  531.   SRBlock.u.cmd.cdb_st[1]=0;
  532.   SRBlock.u.cmd.cdb_st[2]=0;
  533.   SRBlock.u.cmd.cdb_st[3]=0;
  534.   SRBlock.u.cmd.cdb_st[4]=0;
  535.   SRBlock.u.cmd.cdb_st[5]=0;
  536.   SRBlock.u.cmd.cdb_st[6]=0;
  537.   SRBlock.u.cmd.cdb_st[7]=0;
  538.   SRBlock.u.cmd.cdb_st[8]=0;
  539.   SRBlock.u.cmd.cdb_st[9]=0;
  540.  
  541.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  542.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  543.   if (rc)
  544.     return 1;                                   // DosDevIOCtl failed
  545.   else
  546.   {
  547.     success=waitPost();                         // wait for SRB being processed
  548.     if (!success) return 2;                     // semaphore could not be accessed
  549.   }
  550.   if (SRBlock.status != SRB_Done) return 3;
  551.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  552.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  553.  
  554.   *pos=0;
  555.   p=(UCHAR*)buffer;
  556.   *BOP=((*p & 0x80) == 0x80);
  557.   *EOP=((*p & 0x40) == 0x40);
  558.   *partition=0;
  559.   p+=1;
  560.   *partition=*p;
  561.   p+=3;
  562.   *pos+=*p++ << 24;
  563.   *pos+=*p++ << 16;
  564.   *pos+=*p++ << 8;
  565.   *pos+=*p++;
  566.   return 0;
  567. }
  568.  
  569.  
  570. //***************************************************************************
  571. //*                                                                         *
  572. //*  ULONG space(UCHAR id, UCHAR lun, UCHAR code, ULONG count)              *
  573. //*                                                                         *
  574. //*  Sends a SRB containing a space command                                 *
  575. //*  Returns:                                                               *
  576. //*    0  - Success                                                         *
  577. //*    1  - DevIOCtl failed                                                 *
  578. //*    2  - Semaphore access failure                                        *
  579. //*    3  - SCSI command failed                                             *
  580. //*                                                                         *
  581. //*  Preconditions: init() has to be called successfully before             *
  582. //*                                                                         *
  583. //***************************************************************************
  584. ULONG scsiObj::space(UCHAR id, UCHAR lun, UCHAR code, ULONG count)
  585. {
  586.   ULONG rc;                                     // return value
  587.   BOOL  success;                                // return value
  588.   unsigned long cbreturn;
  589.   unsigned long cbParam;
  590.  
  591.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  592.   SRBlock.ha_num=0;                             // host adapter number
  593.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  594.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  595.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  596.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  597.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  598.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  599.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  600.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  601.   SRBlock.u.cmd.cdb_st[0]=0x11;                 // space command
  602.   SRBlock.u.cmd.cdb_st[1]=code & 0x7;           // code
  603.   SRBlock.u.cmd.cdb_st[2]=(count >> 16) & 0xFF; // count MSB
  604.   SRBlock.u.cmd.cdb_st[3]=(count >> 8) & 0xFF;  // count
  605.   SRBlock.u.cmd.cdb_st[4]=count & 0xFF;         // count LSB
  606.   SRBlock.u.cmd.cdb_st[5]=0;
  607.  
  608.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  609.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  610.   if (rc)
  611.     return 1;                                   // DosDevIOCtl failed
  612.   else
  613.   {
  614.     success=waitPost();                         // wait for SRB being processed
  615.     if (!success) return 2;                     // semaphore could not be accessed
  616.   }
  617.   if (SRBlock.status != SRB_Done) return 3;
  618.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  619.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  620.   return 0;
  621. }
  622.  
  623.  
  624. //***************************************************************************
  625. //*                                                                         *
  626. //*  ULONG testUnitReady(UCHAR id, UCHAR lun)                               *
  627. //*                                                                         *
  628. //*  Sends a SRB containing a test unit ready command                       *
  629. //*  Returns:                                                               *
  630. //*    0  - Success                                                         *
  631. //*    1  - DevIOCtl failed                                                 *
  632. //*    2  - Semaphore access failure                                        *
  633. //*    3  - SCSI command failed                                             *
  634. //*                                                                         *
  635. //*  Preconditions: init() has to be called successfully before             *
  636. //*                                                                         *
  637. //***************************************************************************
  638. ULONG scsiObj::testUnitReady(UCHAR id, UCHAR lun)
  639. {
  640.   ULONG rc;                                     // return value
  641.   BOOL  success;                                // return value
  642.   unsigned long cbreturn;
  643.   unsigned long cbParam;
  644.  
  645.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  646.   SRBlock.ha_num=0;                             // host adapter number
  647.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  648.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  649.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  650.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  651.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  652.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  653.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  654.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  655.   SRBlock.u.cmd.cdb_st[0]=0x0;                  // test unit ready command
  656.   SRBlock.u.cmd.cdb_st[1]=(lun << 5);           // lun
  657.   SRBlock.u.cmd.cdb_st[2]=0;
  658.   SRBlock.u.cmd.cdb_st[3]=0;
  659.   SRBlock.u.cmd.cdb_st[4]=0;
  660.   SRBlock.u.cmd.cdb_st[5]=0;
  661.  
  662.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  663.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  664.   if (rc)
  665.     return 1;                                   // DosDevIOCtl failed
  666.   else
  667.   {
  668.     success=waitPost();                         // wait for SRB being processed
  669.     if (!success) return 2;                     // semaphore could not be accessed
  670.   }
  671.   if (SRBlock.status != SRB_Done) return 3;
  672.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  673.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  674.   return 0;
  675. }
  676.  
  677.  
  678. //***************************************************************************
  679. //*                                                                         *
  680. //*  ULONG write(UCHAR id, UCHAR lun, ULONG transfer)                       *
  681. //*                                                                         *
  682. //*  Sends a SRB containing a write command                                 *
  683. //*  Returns:                                                               *
  684. //*    0  - Success                                                         *
  685. //*    1  - DevIOCtl failed                                                 *
  686. //*    2  - Semaphore access failure                                        *
  687. //*    3  - SCSI command failed                                             *
  688. //*                                                                         *
  689. //*  Preconditions: init() has to be called successfully before             *
  690. //*                                                                         *
  691. //***************************************************************************
  692. ULONG scsiObj::write(UCHAR id, UCHAR lun, ULONG transfer)
  693. {
  694.   ULONG rc;                                     // return value
  695.   BOOL  success;                                // return value
  696.   unsigned long cbreturn;
  697.   unsigned long cbParam;
  698.  
  699.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  700.   SRBlock.ha_num=0;                             // host adapter number
  701.   SRBlock.flags=SRB_Write | SRB_Post;           // data transfer, posting enabled
  702.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  703.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  704.   SRBlock.u.cmd.data_len=512*transfer;          // # of bytes transferred
  705.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  706.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  707.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  708.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  709.   SRBlock.u.cmd.cdb_st[0]=0xA;                  // write command
  710.   SRBlock.u.cmd.cdb_st[1]=1;                    // fixed length
  711.   SRBlock.u.cmd.cdb_st[2]=(transfer >> 16) & 0xFF; // transfer length MSB
  712.   SRBlock.u.cmd.cdb_st[3]=(transfer >> 8) & 0xFF;  // transfer length
  713.   SRBlock.u.cmd.cdb_st[4]=(transfer & 0xFF);       // transfer length LSB
  714.   SRBlock.u.cmd.cdb_st[5]=0;
  715.  
  716.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  717.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  718.   if (rc)
  719.     return 1;                                   // DosDevIOCtl failed
  720.   else
  721.   {
  722.     success=waitPost();                         // wait for SRB being processed
  723.     if (!success) return 2;                     // semaphore could not be accessed
  724.   }
  725.   if (SRBlock.status != SRB_Done) return 3;
  726.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  727.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  728.   return 0;
  729. }
  730.  
  731.  
  732. //***************************************************************************
  733. //*                                                                         *
  734. //*  ULONG write_filemarks(UCHAR id, UCHAR lun, BOOL setmark, ULONG count)  *
  735. //*                                                                         *
  736. //*  Sends a SRB containing a unload command                                *
  737. //*  Returns:                                                               *
  738. //*    0  - Success                                                         *
  739. //*    1  - DevIOCtl failed                                                 *
  740. //*    2  - Semaphore access failure                                        *
  741. //*    3  - SCSI command failed                                             *
  742. //*                                                                         *
  743. //*  Preconditions: init() has to be called successfully before             *
  744. //*                                                                         *
  745. //***************************************************************************
  746. ULONG scsiObj::write_filemarks(UCHAR id, UCHAR lun, BOOL setmark, ULONG count)
  747. {
  748.   ULONG rc;                                     // return value
  749.   BOOL  success;                                // return value
  750.   unsigned long cbreturn;
  751.   unsigned long cbParam;
  752.  
  753.   SRBlock.cmd=SRB_Command;                      // execute SCSI cmd
  754.   SRBlock.ha_num=0;                             // host adapter number
  755.   SRBlock.flags=SRB_NoTransfer | SRB_Post;      // no data transfer, posting enabled
  756.   SRBlock.u.cmd.target=id;                      // Target SCSI ID
  757.   SRBlock.u.cmd.lun=lun;                        // Target SCSI LUN
  758.   SRBlock.u.cmd.data_len=0;                     // # of bytes transferred
  759.   SRBlock.u.cmd.sense_len=32;                   // length of sense buffer
  760.   SRBlock.u.cmd.data_ptr=NULL;                  // pointer to data buffer
  761.   SRBlock.u.cmd.link_ptr=NULL;                  // pointer to next SRB
  762.   SRBlock.u.cmd.cdb_len=6;                      // SCSI command length
  763.   SRBlock.u.cmd.cdb_st[0]=0x10;                 // write filemarks command
  764.   if (setmark)
  765.     SRBlock.u.cmd.cdb_st[1]=2;                  // write setmark(s) instead of filemark(s)
  766.   else
  767.     SRBlock.u.cmd.cdb_st[1]=0;                  // write filemark(s)
  768.   SRBlock.u.cmd.cdb_st[2]=(count >> 16) & 0xFF; // count MSB
  769.   SRBlock.u.cmd.cdb_st[3]=(count >> 8) & 0xFF;  // count
  770.   SRBlock.u.cmd.cdb_st[4]=count & 0xFF;         // count LSB
  771.   SRBlock.u.cmd.cdb_st[5]=0;
  772.  
  773.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  774.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  775.   if (rc)
  776.     return 1;                                   // DosDevIOCtl failed
  777.   else
  778.   {
  779.     success=waitPost();                         // wait for SRB being processed
  780.     if (!success) return 2;                     // semaphore could not be accessed
  781.   }
  782.   if (SRBlock.status != SRB_Done) return 3;
  783.   if (SRBlock.u.cmd.ha_status != SRB_NoError) return 3;
  784.   if (SRBlock.u.cmd.target_status != SRB_NoStatus) return 3;
  785.   return 0;
  786. }
  787.  
  788.  
  789. //***************************************************************************
  790. //*                                                                         *
  791. //*  ULONG HA_inquiry(UCHAR ha)                                             *
  792. //*                                                                         *
  793. //*  Sends a SRB containing a Host Adapter Inquiry command                  *
  794. //*  Returns:                                                               *
  795. //*    0  - Success                                                         *
  796. //*    1  - DevIOCtl failed                                                 *
  797. //*    2  - Host Adapter not installed                                      *
  798. //*                                                                         *
  799. //*  Preconditions: driver has to be opened                                 *
  800. //*                                                                         *
  801. //***************************************************************************
  802. ULONG scsiObj::HA_inquiry(UCHAR ha)
  803. {
  804.   ULONG rc;                                     // return value
  805.   unsigned long cbreturn;
  806.   unsigned long cbParam;
  807.  
  808.   SRBlock.cmd=SRB_Inquiry;                      // host adapter inquiry
  809.   SRBlock.ha_num=ha;                            // host adapter number
  810.   SRBlock.flags=0;                              // no flags set
  811.  
  812.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  813.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  814.   if (rc)
  815.     return 1;                                   // DosDevIOCtl failed
  816.   if (SRBlock.status != SRB_Done) return 2;
  817.   return 0;
  818. }
  819.  
  820.  
  821. //***************************************************************************
  822. //*                                                                         *
  823. //*  ULONG getDeviceType(UCHAR id, UCHAR lun)                               *
  824. //*                                                                         *
  825. //*  Sends a SRB containing a Get Device Type command                       *
  826. //*  Returns:                                                               *
  827. //*    0  - Success                                                         *
  828. //*    1  - DevIOCtl failed                                                 *
  829. //*    2  - Device not installed                                            *
  830. //*                                                                         *
  831. //*  Preconditions: driver has to be opened                                 *
  832. //*                                                                         *
  833. //***************************************************************************
  834. ULONG scsiObj::getDeviceType(UCHAR id, UCHAR lun)
  835. {
  836.   ULONG rc;                                     // return value
  837.   unsigned long cbreturn;
  838.   unsigned long cbParam;
  839.  
  840.   SRBlock.cmd=SRB_Device;                       // get device type
  841.   SRBlock.ha_num=0;                             // host adapter number
  842.   SRBlock.flags=0;                              // no flags set
  843.   SRBlock.u.dev.target=id;                      // target id
  844.   SRBlock.u.dev.lun=lun;                        // target LUN
  845.  
  846.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  847.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  848.   if (rc)
  849.     return 1;                                   // DosDevIOCtl failed
  850.   if (SRBlock.status != SRB_Done) return 2;
  851.   return 0;
  852. }
  853.  
  854.  
  855. //***************************************************************************
  856. //*                                                                         *
  857. //*  ULONG resetDevice(UCHAR id, UCHAR lun)                                 *
  858. //*                                                                         *
  859. //*  Sends a SRB containing a Reset Device command                          *
  860. //*  Returns:                                                               *
  861. //*    0  - Success                                                         *
  862. //*    1  - DevIOCtl failed                                                 *
  863. //*    2  - Semaphore access failure                                        *
  864. //*    3  - SCSI command failed                                             *
  865. //*                                                                         *
  866. //*  Preconditions: init() has to be called successfully before             *
  867. //*                                                                         *
  868. //***************************************************************************
  869. ULONG scsiObj::resetDevice(UCHAR id, UCHAR lun)
  870. {
  871.   ULONG rc;                                     // return value
  872.   unsigned long cbreturn;
  873.   unsigned long cbParam;
  874.   BOOL  success;
  875.  
  876.   SRBlock.cmd=SRB_Reset;                        // reset device
  877.   SRBlock.ha_num=0;                             // host adapter number
  878.   SRBlock.flags=SRB_Post;                       // posting enabled
  879.   SRBlock.u.res.target=id;                      // target id
  880.   SRBlock.u.res.lun=lun;                        // target LUN
  881.  
  882.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &SRBlock, sizeof(SRB), &cbParam,
  883.                   (void*) &SRBlock, sizeof(SRB), &cbreturn);
  884.   if (rc)
  885.     return 1;                                   // DosDevIOCtl failed
  886.   else
  887.   {
  888.     success=waitPost();                         // wait for SRB being processed
  889.     if (!success) return 2;                     // semaphore could not be accessed
  890.   }
  891.   if (SRBlock.status != SRB_Done) return 3;
  892.   return 0;
  893. }
  894.  
  895.  
  896. //***************************************************************************
  897. //*                                                                         *
  898. //*  ULONG abort()                                                          *
  899. //*                                                                         *
  900. //*  Sends a SRB containing a Get Device Type command                       *
  901. //*  Returns:                                                               *
  902. //*    0  - Success                                                         *
  903. //*    1  - DevIOCtl failed                                                 *
  904. //*    2  - Abort SRB not successful                                        *
  905. //*                                                                         *
  906. //*  Preconditions: driver has to be opened                                 *
  907. //*                                                                         *
  908. //***************************************************************************
  909. ULONG scsiObj::abort()
  910. {
  911.   ULONG rc;                                     // return value
  912.   unsigned long cbreturn;
  913.   unsigned long cbParam;
  914.  
  915.   AbortSRB.cmd=SRB_Abort;                       // abort SRB
  916.   AbortSRB.ha_num=0;                            // host adapter number
  917.   AbortSRB.flags=0;                             // no flags set
  918.   AbortSRB.u.abt.srb=&SRBlock;                  // SRB to abort
  919.  
  920.   rc = DosDevIOCtl(driver_handle, 0x92, 0x02, (void*) &AbortSRB, sizeof(SRB), &cbParam,
  921.                   (void*) &AbortSRB, sizeof(SRB), &cbreturn);
  922.   if (rc)
  923.     return 1;                                   // DosDevIOCtl failed
  924.   if (SRBlock.status != SRB_Done) return 2;
  925.   return 0;
  926. }
  927.  
  928.  
  929.  
  930.