handles.c
上传用户:xmgzy123
上传日期:2007-01-07
资源大小:373k
文件大小:7k
源码类别:

SCSI/ASPI

开发平台:

WINDOWS

  1. /*
  2.  * handles.c - Copyright (C) 1999 Jay A. Key
  3.  *
  4.  * Routines for CDROM handle management
  5.  *
  6.  **********************************************************************
  7.  *
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU Lesser General Public License as published
  10.  * by the Free Software Foundation; either version 2 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21.  *
  22.  **********************************************************************
  23.  *
  24.  * $Id: handles.c,v 1.2 2000/02/25 10:47:37 akey Exp $
  25.  * $Date: 2000/02/25 10:47:37 $
  26.  * $Locker:  $
  27.  * $Log: handles.c,v $
  28.  * Revision 1.2  2000/02/25 10:47:37  akey
  29.  * sync'ed with akrip32.dll v0.94
  30.  *
  31.  * Revision 1.5  2000/02/25 10:13:26  akey
  32.  * Added SPTIOpenCDHandle for scsi pass through
  33.  *
  34.  * Revision 1.4  2000/02/14 09:56:25  akey
  35.  * cleaned up #ifdef _DEBUG code considerably
  36.  *
  37.  * Revision 1.3  2000/02/11 10:00:35  akey
  38.  * added access to cdplayer.ini
  39.  *
  40.  * Revision 1.2  2000/01/03 12:29:43  akey
  41.  * v0.91 release -- added CDDB and bug fixes
  42.  *
  43.  *
  44.  */
  45. #define _AKRIP32_
  46. #include <windows.h>
  47. #include <stdio.h>
  48. #include "myaspi32.h"
  49. #include "scsidefs.h"
  50. #include "aspilib.h"
  51. #include "akrip32.h"
  52. extern CDHANDLEREC *cdHandles;
  53. extern HANDLE *cdMutexes;
  54. extern CRITICAL_SECTION getHandle;
  55. extern int alErrCode;
  56. extern BYTE alAspiErr;
  57. extern int *nextHandle;
  58. BOOL UsingSCSIPT( void );
  59. /****************************************************************
  60.  * GetCDHandle
  61.  *
  62.  * Opens a handle to a CD Device, setting the type of function used
  63.  * for reading CD Audio.
  64.  *
  65.  * Parameters:
  66.  *   bHA           Host Adapter number
  67.  *   bTgt          Target
  68.  *   bLun          LUN
  69.  *   bReadType     Algorithm to use for reading cd audio.  Can be
  70.  *                 one of: CDR_ANY, CDR_ATAPI1, CDR_ATAPI2,
  71.  *                 CDR_READ6, CDR_READ10
  72.  *
  73.  * Returns a handle suitable for use by functions in the dll, or
  74.  * NULL on error.  Check GetAspiLibError() to get the actual error
  75.  * code.
  76.  *
  77.  ****************************************************************/
  78. HCDROM  GetCDHandle( LPGETCDHAND lpcd )
  79. {
  80.   int i;
  81.   BYTE devType;
  82.   //LPBYTE pDevType = &devType;
  83.   HANDLE hMutex;
  84.   //BOOL bSkip;
  85.   if ( !lpcd )
  86.     {
  87. #ifdef _DEBUG
  88.       dbprintf( "AKRip32: Error: GetCDHandle( NULL )" );
  89. #endif
  90.       alErrCode = ALERR_INVPTR;
  91.       return NULL;
  92.     }
  93.   if ( ( lpcd->ver != 1 ) || ( lpcd->size < sizeof(GETCDHAND) ) )
  94.     {
  95.       alErrCode = ALERR_INVPARM;
  96.       return NULL;
  97.     }
  98. #ifdef _DEBUG
  99.   dbprintf( "AKRip32: GetCDHandle( %02X, %02X, %02X, %02X )",
  100.     lpcd->ha, lpcd->tgt, lpcd->lun, lpcd->readType );
  101. #endif
  102.   hMutex = CreateMutex( NULL, FALSE, "akrip32_getCDHandle" );
  103.   if ( !hMutex || (WaitForSingleObject( hMutex, TIMEOUT) != WAIT_OBJECT_0) )
  104.     {
  105.       alErrCode = ALERR_LOCK;
  106.       if ( hMutex )
  107. CloseHandle( hMutex );
  108. #ifdef _DEBUG
  109.       dbprintf( "AKRip32: GetCDHandle() -> failed to lock mutex" );
  110. #endif
  111.       return NULL;
  112.     }
  113.   for( i = 0; i < MAXCDHAND; i++ )
  114.     {
  115.       if ( (cdHandles[i].ha == lpcd->ha) && (cdHandles[i].tgt == lpcd->tgt) &&
  116.    (cdHandles[i].lun == lpcd->lun) && (cdHandles[i].used) )
  117. {
  118. #ifdef _DEBUG
  119.   dbprintf( "akrip32: GetCDHandle() -> ERROR:cd already allocated" );
  120. #endif
  121.   alErrCode = ALERR_DUPHAND;
  122.   ReleaseMutex( hMutex );
  123.   CloseHandle( hMutex );
  124.   return NULL;
  125. }
  126.     }
  127. #ifdef _DEBUG
  128.   dbprintf( "AKRip32: GetCDHandle( %02X, %02X, %02X, %02X )",
  129.     lpcd->ha, lpcd->tgt, lpcd->lun, lpcd->readType );
  130. #endif
  131.   i = getSCSIDevType( lpcd->ha, lpcd->tgt, lpcd->lun, &devType, NULL, 0 );
  132.   if ( !i || ( devType != DTYPE_CDROM ) )
  133.     {
  134.       if ( alErrCode == ALERR_NOERROR )
  135. alErrCode = ALERR_NOTACD;
  136.       ReleaseMutex( hMutex );
  137.       CloseHandle( hMutex );
  138. #ifdef _DEBUG
  139.       dbprintf( "AKRip32: GetCDHandle() -> ALERR_NOTACD, i == %d, devType == %d", i, devType );
  140. #endif
  141.       return NULL;
  142.     }
  143.   for( i = 0; i < MAXCDHAND; i++ )
  144.     {
  145.       int j;
  146.       j = (i + *nextHandle ) % MAXCDHAND;
  147.       if ( !cdHandles[j].used )
  148. {
  149.   memset( &cdHandles[j], 0, sizeof(CDHANDLEREC) );
  150.   cdHandles[j].bMSF     = FALSE;
  151.   cdHandles[j].ha       = lpcd->ha;
  152.   cdHandles[j].tgt      = lpcd->tgt;
  153.   cdHandles[j].lun      = lpcd->lun;
  154.   //   cdHandles[j].pfnRead  = readCDAudioLBA_ATAPI;
  155.   cdHandles[j].used     = TRUE;
  156.   cdHandles[j].readType = lpcd->readType;
  157.   cdHandles[j].numCheck = lpcd->numJitter;
  158.   cdHandles[j].numOverlap = lpcd->numOverlap;
  159.   switch( lpcd->readType )
  160.     {
  161.     case CDR_ATAPI1:
  162.     case CDR_ATAPI2:
  163.       cdHandles[j].pfnRead  = readCDAudioLBA_ATAPI;
  164.       break;
  165.     case CDR_READ6:
  166.     case CDR_READ10:
  167.     case CDR_READ10_2:
  168.       cdHandles[j].pfnRead = readCDAudioLBA_READ10;
  169.       break;
  170.     case CDR_READ_D8:
  171.       cdHandles[j].pfnRead = readCDAudioLBA_D8;
  172.       break;
  173.     case CDR_READ_D4:
  174.     case CDR_READ_D4_1:
  175.       cdHandles[j].pfnRead = readCDAudioLBA_D4;
  176.       break;
  177.     case CDR_ANY:
  178.     default:
  179.       cdHandles[j].pfnRead  = readCDAudioLBA_ANY;
  180.       cdHandles[j].readType = CDR_ANY;
  181.       break;
  182.     }
  183.   *nextHandle = j % MAXCDHAND;
  184.   if ( UsingSCSIPT() )
  185.     SPTIOpenCDHandle( lpcd->ha, lpcd->tgt, lpcd->lun );
  186.   ReleaseMutex( hMutex );
  187.   CloseHandle( hMutex );
  188.   return (HCDROM)(j+1);
  189. }
  190.     }
  191.   alErrCode = ALERR_NOMOREHAND;
  192.   ReleaseMutex( hMutex );
  193.   CloseHandle( hMutex );
  194.   return NULL;
  195. }
  196. /****************************************************************
  197.  * CloseCDHandle
  198.  *
  199.  * Releases a CD Handle.
  200.  *
  201.  ****************************************************************/
  202. BOOL CloseCDHandle( HCDROM hCD )
  203. {
  204.   int idx = (int)hCD - 1;
  205.   if ( (idx<0) || (idx>=MAXCDHAND) || !cdHandles[idx].used )
  206.     return FALSE;
  207.   if ( WaitForSingleObject( cdMutexes[idx], TIMEOUT ) != WAIT_OBJECT_0 )
  208.     {
  209.       alErrCode = ALERR_LOCK;
  210.       return FALSE;
  211.     }
  212.   if ( cdHandles[idx].pfnDeinit )
  213.     cdHandles[idx].pfnDeinit( hCD );
  214.   memset( &cdHandles[idx], 0, sizeof(CDHANDLEREC) );
  215.   ReleaseMutex( cdMutexes[idx] );
  216.   return TRUE;
  217. }