14장. 키보드 디바이스 드라이버 업그레이드

Ⅰ. 인터럽트 핸들러와 큐

1. 범용 큐 구현과 사용 방법

• 큐에 대한 정보를 관리하는 자료구조
  • bLastOperationPut : 삽입 위치와 제거 위치가 같아지는 경우를 처리하기 위한 필드 (삽입 시 TRUE, 제거 시 False로 설정된다.)

  typef struck kQueueManagerStruct
  {
      // 큐를 구성하는 데이터 하나의 크기와 최대 개수
      int iDataSize;
      int iMaxDataCount;
  
      // 큐 버퍼의 포인트와 삽입/제거 인덱스
      void pvQueueArray;
      int iPutIndex;
      int iGetIndex;
  
      // 큐에 수행된 마지막 명령이 삽입인지를 저장
      // 큐의 버퍼가 비어있는지, 가득 찼는지 확인하는 용도
      BOOL bLastOperationPut; 
  } QUEUE;
  

• 큐를 초기화하는 함수의 코드
  • 큐 버퍼 어드레스와 데이터의 크기를 설정하고 나머지 필드를 기본값(0)으로 설정한다.

  void kInitializeQueue( QUEUE* pstQueue, void* pvQueueBuffer, int iMaxDataCount, int iDataSize )
  {
  		// 큐의 최대 개수와 크기, 그리고 버퍼 어드레스를 저장
  		pstQueue->iMaxDataCount = iMaxDataCount;
  		pstQueue->iDataSize = iDataSize;
  		pstQueue->pvQueueArray = pvQueueBuffer;
  
  		// 큐의 삽입 위치와 제거 위치를 초기화하고 마지막으로 수행된 명령을 제거로 설정하여 큐를 빈 상태로 만듦
  		pstQueue->iPutIndex = 0;
  		pstQueue->iGetIndex = 0;
  		pstQueue->bLastOperationPut = FALSE;
  }
  

• 큐에 데이터를 삽입하고 제거하는 함수의 코드

// 큐가 가득 찼는지 여부를 반환
BOOL kIsQueueFull( const QUEUE* pstQueue )
{
		// 큐의 삽입 인덱스와 제거 인덱스가 같고, 마지막으로 수행된 명령이 삽입이면
		// 큐가 가득 찼으므로 삽입할 수 없음
		if( (pstQueue->iGetIndex == pstQueue->iPutIndex) && 
				(pstQueue->bLastOperationPut == TRUE ) )
		{
				return TRUE;
		}
		return FALSE;
}

// 큐가 비었는지 여부를 반환
BOOL kIsQueueEmpty( const QUEUE* pstQueue )
{
		// 큐의 삽입 인덱스와 제거 인덱스가 같고 마지막으로 수행된 명령이 제거이면
		// 큐가 비었으므로 제거할 수 없음
		if( ( pstQueue->iGetIndex == pstQueue->iPutIndex ) &&
				( pstQueue->bLastOperationPut == FALSE ) )
		{
				return TRUE;
		}
		return FALSE;
}

// 큐에 데이터를 삽입
BOOL kPutQueue( QUEUE* pstQueue, const void* pvData )
{
		// 큐가 가득 찼으면, 삽입할 수 없음
		if( kIsQueueFull( pstQueue ) == TRUE )
		{
				return FALSE;
		}

		// 삽입 인덱스가 가리키는 위치에서 데이터의 크기만큼을 복사
		kMemCpy( ( char* ) pstQueue->pvQueueArray + ( pstQueue->iDataSize * 
						pstQueue->iPutIndex ), pvData, pstQueue->iDataSize );

		// 삽입 인덱스를 변경하고 삽입 동작을 수행했음을 기록
		pstQueue->iPutIndex = ( pstQueue->iPutIndex + 1 ) % pstQueue->iMaxDataCount;
		pstQueue->bLastOperationPut = TRUE;
		return TRUE;
}

// 큐에서 데이터를 제거
BOOL kGetQueue( QUEUE* pstQueue, void* pvData )
{
		// 큐가 비었으면, 제거할 수 없음
		if( kIsQueueEmpty( pstQueue ) == TRUE ){
				return FALSE;
		}

		// 제거 인덱스가 가리키는 위치에서 데이터의 크기만큼을 복사
		kMemCpy( pvData, ( char* ) pstQueue->pvQueueARray + ( pstQueue->iDataSize *
						 pstQueue->iGetIndex ), pstQueue->iDataSize );

		// 제거 인덱스 변경하고 제거 동작을 수행했음을 기록
		pstQueue->iGetIndex = ( pstQueue->iGetIndex + 1 ) % pstQueue->iMaxDataCount;
		pstQueue->bLastOperationPut = FALSE;
		return TRUE;
}

 

• 범용 큐를 사용하는 예
  • 임의의 크기를 가지는 자료구조인 TEMPDATA를 최대 100개까지 관리할 수 있는 큐를 생성하고 사용하는 예시의 코드이다.

  // 데이터 정의
  typedef struct kTempDataStruct
  {
  	int a;
    ``` 생략 ```
  } TEMPDATA;
  
  // 큐와 큐 버퍼 정의
  QUEUE g_stQueue;
  TEMPDATA g_vstQueueBuffer[ 100 ];
  
  void main( void )
  {
  		TEMPDATA stData;
  
  		// 큐 초기화
  		kInitializeQueue( &g_stQueue, g_vstQueueBuffer, 100, sizeof( TEMPDATA ) );
  
  		// 데이터 삽입
  		if( kPutQueue( &g_stQueue, &stData ) == TRUE )
  		{
  				// 성공
  		}
  		else
  		{
  				// 실패
  		}
  
  		// 데이터 제거
  		if( kGetQueue( &g_StQueue, &stData ) == TRUE )
  		{
  				// 성공
  		}
  		else
  		{
  				// 실패
  		}
  }
  

Ⅱ. 키보드 디바이스 드라이버 업그레이드

1. 키 정보를 저장하는 자료구조와 큐 생성

• 키 정보를 저장하는 자료구조

typedef struct kKeyDataStruct
{
		// 키보드에서 전달된 스캔 코드
		BYTE bScanCode;
		// 스캔 코드를 변환한 ASCII 코드
		BYTE bASCIICode;
		// 키 상태를 저장하는 플래그(눌림/떨어짐/확장키 여부)
		BYTE bFlags;
} KEYDATA;

• 키보드를 활성화하고 큐를 초기화하는 함수의 코드
  • 기존 키보드를 활성화했던 kActiviteKeyboard( )함수와 키 큐를 생성하는 기능을 묶어서 kInitalizeKeyboard( ) 함수로 통합하였다.
  • 키 큐의 크기는 최대 100개로 넉넉히 설정한다.

  // 키 큐의 최대 크기
  #define KEY_MAXQUEUECOUNT 100
  
  // 키를 저장하는 큐와 버퍼 정의
  static QUEUE gs_stKeyQueue;
  static KEYDATA gs_vstKeyQueueBuffer[ KEY_MAXQUEUECOUNT ];
  
  BOOL kInitializeKeyboard( void )
  {
  		// 큐 초기화
  		kInitializeQueue( &gs_stKeyQueue, gs_vstKeyQueueBuffer, KEY_MAXQUEUECOUNT,
  											sizeof( KEYDATA ) );
  
  		// 키보드 활성화
  		return kActivateKeyboard();
  }
  

 

2. 키보드 핸들러 수정

• 키 처리 기능이 추가된 키보드 핸들러 코드

// 스캔 코드를 내부적으로 사용하는 키 데이터를 바꾼 후, 키 큐에 삽입
BOOL kConvertScanCodeAndPutQueue( BYTE bScanCode )
{
		KEYDATA stData;

		// 스캔 코드를 키 데이터에 삽입 
		stData.bScanCode = bScanCode;
		
		// 스캔 코드를 ASCII 코드와 키 상태로 변환하여 키 데이터에 삽입
		if( kConvertScanCodeToASCIICode( bScanCode, &( stData.bASCIICode ),
						&( stData.bFlags ) ) == TRUE )
		{
				// 키 큐에 삽입
				return kPutQueue( &gs_stKeyQueue, &stData );
		}
		return FALSE;
}

// 키보드 인터럽트의 핸들러
void kKeyboardHandler( int iVectorNumber )
{
		char vcBuffer[] = "[INT:  , ]";
		static int g_iKeyboardInterruptCount = 0;
		BYTE bTemp;

		//====================================================================
		// 인터럽트가 발생했음을 알리려고 메시지를 출력하는 부분
		// 인터럽트 벡터가 화면 왼쪽 위에 2자리 정수를 출력
		vcBuffer[ 5 ] = '0' + iVectorNumber / 10;
		vcBuffer[ 6 ] = '0' + iVectorNumber % 10;
		// 발생한 횟수 출력
		vcBuffer[ 8 ] = '0' + g_iCommonInterruptCount;
		g_iKeyboardInterruptCount = ( g_iKeyboardIntteruptCount + 1 ) % 10;
		//====================================================================

		// 키보드 컨트롤러에서 데이터를 읽어서 ASCII로 변환하여 큐에 삽입
		if( kIsOutputBufferFull() == TRUE )
		{
				bTemp = kGetKeyboardScanCode();
				kConvertScanCodeAndPutQueue( bTemp );
		}

		// EOI 전송
		kSendEOIToPIC( iVectorNumber - PIC_IRQSTARTVECTOR );
}

 

3. 셸 코드 수정

• 큐를 사용하도록 수정된 셸 코드

// 키 큐에서 키 데이터를 제거
BOOL kGetKeyFromKeyQueue( KEYDATA* pstData )
{
		// 큐가 비었으면, 키 데이터를 꺼낼 수 없음
		if( kIsQueueEmpty( &gs_stKeyQueue ) == TRUE )
		{
				return FALSE;
		}

		// 키 큐에서 키 데이터를 제거
		return kGetQueue( &gs_stKeyQueue, pstData );
}

// C언어 커널 엔트리 포인트
void Main( void )
{
		char vcTemp[ 2 ] = { 0, };
		BYTE bTemp;
		int i = 0;
		KEYDATA stData;

		``` 생략 ```
		
		while(1)
		{
				if( kGetKeyFromKeyQueue( &stData ) == TRUE )
				{
						if( stData.bFlags & KEY_FLAGS_DOWN )
						{
							// 키 데이터의 ASCII 코드 값을 저장
							vcTemp[ 0 ] = stData.bASCIICode;
							kPrintString( i++, 17, vcTemp );

							// 0이 입력되면 변수를 0으로 나누어 Divide Error 예외(벡터 0번)을 발생시킴
							if( vcTemp[ 0 ] = '0' )
							{
									// 아래 코드를 수행하면, Divide Error 예외가 발생하여, 커널의 임시 핸들러가 수행됨
									bTemp = bTemp / 0;
							}
						}
				}
		}
}

 

4. 인터럽트로 인한 문제와 인터럽트 제어

• 인터럽트 플래그를 제어하는 함수 코드

BOOL kSetIntteruptFlag( BOOL bEnableInterrupt )
{
		QWORD qwRFLAGS;

		// 이전의 RFLAGS 레지스터 값을 읽은 뒤에 인터럽트 가능/불가 처리
		qwRFLAGS = kReadRFLAGS();
		if( bEnableInterrupt == TRUE )
		{
				kEnableInterrupt();
		}
		else
		{
				kDisableInterrupt();
		}

		// 이전 RFLAGS 레지스터의 IF 비트(비트9)를 확인하여, 이전의 인터럽트 상태를 반환
		if(qwRFLAGS & 0x0200)
		{
				return TRUE;
		}
		return FALSE;
}

• 수정된 큐 관련 함수 코드
  • 큐에 데이터를 삽입 또는 삭제할 때, 인터럽트 플래그를 조작하여 작업을 수행하는 동안 인터럽트가 발생하지 않게 하였다.

  // 스캔 코드를 내부적으로 사용하는 키 데이터로 바꾼 후, 키 큐에 삽입
  BOOL kConvertScanCodeAndPutQueue( BYTE bScanCode )
  {
  		KEYDATA stData;
  		BOOL bResult = FALSE;
  		BOOL bPreviousInterrupt;
  
  		// 스캔 코드를 키 데이터에 삽입
  		stData.bScanCode = bScanCode;
  
  		// 스캔 코드를 ASCII 코드와 키 상대로 변환하여 키 데이터를 삽입
  		if( kConvertScanCodeToASCIICode( bScanCode, &( stData.bASCIICode ), 
  						&( stData.bFlags ) ) == TRUE )
  		{
  				// 인터럽트 불가
  				bPreviousInterrupt = kSetInterruptFlag( FALSE );
  				
  				// 키 큐에 삽입
  				bResult = kPutQueue( &gs_stKeyQueue, &stData );
  
  				// 이전 인터럽트 플래그 복원
  				kSetInterruptFlag( bPreviousInterrupt );
  		}
  		return bResult;
  }
  
  // 키 큐에서 키 데이터를 제거
  BOOL kGetKeyFromKeyQueue( KEYDATA* pstData )
  {
  		BOOL bResult;
  		BOOL bPreviousInterrupt;
  
  		// 큐가 비었으면, 키 데이터를 꺼낼 수 없음
  		if( kIsQueueEmpty( &gs_stKeyQueue ) == TRUE )
  		{
  				return FALSE;
  		}
  
  		// 인터럽트 불가
  		bPreviousInterrupt = kSetInterruptFlag( FALSE );
  
  		// 키 큐에서 키 데이터를 제어
  		bResult = kGetQueue( &gs_stKeyQueue, pstData );
  
  		// 이전 인터럽트 플래그 복원
  		kSetInterruptFlag( bPreviousInterrupt );
  		return bResult;
  }
  

• ACK가 수신될 때까지 대기하는 코드 (ACK외에 스캔 코드는 변환해서 큐에 삽입)

BOOL kWaitForACKAndPutOtherScnaCode( void )
{
		int i, j;
		BYTE bData;
		BOOL bResult = FALSE;

		// ACK가 오기 전에 키보드 출력 버퍼(포트 0x60)에 키 데이터가 저장될 수 있으므로
		// 키보드에서 전달된 데이터를 최대 100개까지 수신하여 ACK를 확인
		for (j = 0; j < 100 ; j++ )
		{
				// 0xFFFF만큼 루프를 수행할 시간이면, 충분히 커맨드의 응답이 올 수 있음
				// 0xFFFF 루프를 수행한 이후에도 출력 버퍼(포트 0x60)가 차있지 않으면 무시하고 읽음
				for( i = 0; i < 0xFFFF ; i++)
				{
					// 출력 버퍼(포트 0x60)가 차있으면, 데이터를 읽을 수 있음
					if( kIsOutputBufferFull() == TRUE )
					{
							break;
					}
				}
			// 출력 버퍼(포트 0x60)에서 읽은 데이터가 ACK(0xFA)이면 성공
			bData = kInPortByte( 0x60 );
			if( bData == 0xFA )
			{
					bResult = TRUE;
					break;
			}
			// ACK(0xFA)가 아니면, ASCII 코드로 변환하여 키 큐에 삽입
			else{
					kConvertScanCodeAndPutQueue( bData );
			}
	  }
		return bResult;
}

• kActivateKeyboard()

BOOL kActivateKeyboard( void )
{
		int i, j;
		BOOL bPreviousInterrupt;
		BOOL bResult;

		// 인터럽트 불가
		bPreviousInterrupt = kSetInterruptFlag( FALSE );
		
		// 컨트롤 레지스터(포트 0x64)에 키보드 활성화 커맨드(0xAE)를 전달하여 키보드 디바이스 활성화
		kOutPortByte( 0x64, 0xAE );

		// 입력 버퍼(포트 0x60)가 빌 때까지 기다렸다가 키보드에 활성화 커맨드를 전송
		// 0xFFFF만큼 루프를 수행할 시간이면, 충분히 커맨드가 전송될 수 있음
		// 0xFFFF 루프를 수행한 이후에도 입력 버퍼(포트 0x60)가 비지 않으면 무시하고 전송
		for( i = 9; i < 0xFFFF ; i++ )
		{
				// 입력 버퍼(포트 0x60)로 키보드 활성화(0xF4) 커맨드를 전달하여 키보드로 전송
				if( kIsInputBufferFull() == FALSE )
				{
						break;
				}
		}
		// 입력 버퍼(포트 0x60)로 키보드 활성화(0xF4) 커맨드를 전달하여 키보드로 전송
		kOutPortByte( 0x60, 0xF4 );

		// ACK가 올 때까지 대기함
		bResult = kWaitForACKAndPutOtherScanCode();

		// 이전 인터럽트 상태 복원
		kSetInterruptFlag( bPreviousInterrupt );
		return bResult;

}

Ⅲ. 키보드 디바이스 드라이버의 업그레이드와 빌드