ser2440_ser.c

2440 wince uart source code

       )
{

    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
    RETAILMSG(QYDEBUG,(TEXT("============== SERIAL3 OPEN ============\r\n")));
    RETAILMSG(1,((TEXT("+ Ser4Open() 0x%x\r\n")),pHead));
    // Disallow multiple simultaneous opens
    if ( pHWHead->cOpenCount){
        return (FALSE);}
    

    pHWHead->cOpenCount++;
     
    pHWHead->fIRMode  = FALSE;   // Select wired by default

    // NOTE: - If we want to support 16450s, we'll need to dynamically
    // identify them here.
    pHWHead->ser16550.ChipID = CHIP_ID_16550;

    // Init 16550 info
    SL_Openq( pHWHead );
    RETAILMSG(QYDEBUG,(TEXT("- Ser4Open(s) END\r\n")));//=====QM:0419
    return (TRUE);

}

//for 16C550
static
BOOL
Ser4PowerOn(
          PVOID   pHead       // @parm	PVOID returned by SerInit.
          )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
RETAILMSG(QYDEBUG,(TEXT("+Ser3PowerOn\r\n")));
    // First, power up the UART
    SL_PowerOnq( pHWHead );

    // And then enable our IR interface (if needed)
    RETAILMSG(QYDEBUG,(TEXT("-Ser3PowerOn\r\n")));
    return (TRUE);
}

//for 16C550
static
BOOL
Ser4EnableIR(
           PVOID   pHead, // @parm PVOID returned by Serinit.
           ULONG   BaudRate  // @parm PVOID returned by HWinit.
           )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
	 	RETAILMSG(QYDEBUG,(TEXT("+Ser3EnableIR\r\n")));
    // Ignore the passed baudrate and use the one in our struct.
    pHWHead->fIRMode  = FALSE;
    RETAILMSG(QYDEBUG,(TEXT("-Ser3EnableIR\r\n")));
    return (TRUE);
}
//for 16C550
static
BOOL
Ser4DisableIR(
            PVOID   pHead /*@parm PVOID returned by Serinit. */
            )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
 	RETAILMSG(QYDEBUG,(TEXT("+Ser3DisableIR\r\n")));
    pHWHead->fIRMode  = TRUE;
 	RETAILMSG(QYDEBUG,(TEXT("-Ser3DisableIR\r\n")));
    return (TRUE);
}

//for 16C550
static
BOOL
Ser4PowerOff(
           PVOID   pHead       // @parm	PVOID returned by SerInit.
           )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
	//volatile IOPreg *s2410IOP = (IOPreg *)IOP_BASE;
RETAILMSG(QYDEBUG,(TEXT("+Ser3PowerOff\r\n")));
//RETAILMSG(QYDEBUG,(TEXT("+NEWSer3PowerOff\r\n")));
    // First, power down the UART
	//s2410IOP->rGPGDAT &= ~(1 << 4);                /* Backlight OFF    devised by zhangshunke   2006.11.28                                     */
   SL_PowerOffq( pHWHead );

    // And then disable our IR and 9 Pin interface
RETAILMSG(QYDEBUG,(TEXT("-Ser3PowerOff\r\n")));
    return (TRUE);
}

//for 16C550
static
BOOL
Ser4Deinit(
         PVOID   pHead   // @parm PVOID returned by SerInit.
         )
{

    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
    RETAILMSG(QYDEBUG,(TEXT(" +Ser4Deinit() START \r\n")));
    //while(1); //test,must remove
    if ( !pHWHead )
        return (FALSE);

    // Make sure device is closed before doing DeInit
    if ( pHWHead->cOpenCount )
        Ser4Close( pHead );

    if ( pHWHead->pBaseAddress )
        VirtualFree(pHWHead->pBaseAddress, 0, MEM_RELEASE);

    //if ( pHWHead->pBootArgs )
      //  MmUnmapIoSpace( pHWHead->pBootArgs, sizeof(BOOT_ARGS) );

    
    LocalFree(pHWHead);
  RETAILMSG(QYDEBUG,(TEXT("-Ser4Deinit() END \r\n")));
    return (TRUE);
}
//for 16C550
static
ULONG
Ser4Close(
        PVOID   pHead   // @parm PVOID returned by SerInit.
        )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
    ULONG  uTries;
    RETAILMSG(QYDEBUG,(TEXT("+Ser3Close\r\n")));
    if ( pHWHead->cOpenCount ) {
        RETAILMSG(QYDEBUG, 
                  (TEXT("SerClose, closing device\r\n")));
        pHWHead->cOpenCount--;

        // while we are still transmitting, sleep.
        uTries = 0;
        while ( ((pHWHead->ser16550.IER = READ_PORT_UCHAR(pHWHead->ser16550.pIER)) 
                 & SERIAL_IER_THR) &&  // indicates TX in progress
                (uTries++ < 100) &&                            // safety net
                !(pHWHead->ser16550.LSR & SERIAL_LSR_TEMT)     // indicates FIFO not yet empty
              ) {
            Sleep(10);
        }

        // When the device is closed, we power it down.
        RETAILMSG(QYDEBUG, 
                  (TEXT("SerClose - Powering down UART\r\n")));
        pHWHead->fIRMode  = FALSE;  

        RETAILMSG(QYDEBUG, (TEXT("SerClose - Calling SL_Close\r\n")));
        SL_Closeq( pHWHead );
    }

    RETAILMSG(QYDEBUG,(TEXT("-SerClose\r\n")));
    return (0);
}
//for 16C550
static
VOID
Ser4GetCommProperties(
                    PVOID   pHead,      // @parm PVOID returned by SerInit. 
                    LPCOMMPROP  pCommProp   // @parm Pointer to receive COMMPROP structure. 
                    )
{
    PSER_16552_INFO   pHWHead = (PSER_16552_INFO)pHead;
	RETAILMSG(QYDEBUG,(TEXT("SerGetCommProperties\r\n")));
    *pCommProp = pHWHead->CommProp;
    return;
}
//for 16C550
BOOL
Ser4_GetRegistryData(PSER_16552_INFO pHWHead, LPCTSTR regKeyPath)
{
#define GCI_BUFFER_SIZE 256   

	LONG    regError;
	HKEY    hKey;
	DWORD   dwDataSize = GCI_BUFFER_SIZE;

	RETAILMSG(DEBUGMODE, (TEXT("Try to open %s\r\n"), regKeyPath));

	// We've been handed the name of a key in the registry that was generated
	// on the fly by device.exe.  We're going to open that key and pull from it
	// a value that is the name of this serial port's real key.  That key
	// will have the DeviceArrayIndex that we're trying to find.  
	hKey = OpenDeviceKey(regKeyPath);
	if ( hKey == NULL ) {
		DEBUGMSG(ZONE_INIT | ZONE_ERROR,(TEXT("Failed to open device key\r\n")));
		return ( FALSE );        
	}

	// Okay, we're finally ready to try and load our registry data.
	dwDataSize = PC_REG_DEVINDEX_VAL_LEN;
	regError = RegQueryValueEx(
					hKey, 
					PC_REG_DEVINDEX_VAL_NAME, 
					NULL, 
					NULL,
					(LPBYTE)(&pHWHead->dwDevIndex), 
					&dwDataSize);

	if ( regError == ERROR_SUCCESS ) {
		dwDataSize = PC_REG_IRQ_VAL_LEN;
		regError = RegQueryValueEx(
					hKey, 
					PC_REG_IRQ_VAL_NAME, 
					NULL, 
					NULL,
					(LPBYTE)(&pHWHead->dwIRQ), 
					&dwDataSize);
	}

	if ( regError == ERROR_SUCCESS ) {
		dwDataSize = PC_REG_IOBASE_VAL_LEN;
		regError = RegQueryValueEx(
					hKey, 
					PC_REG_IOBASE_VAL_NAME, 
					NULL, 
					NULL,
					(LPBYTE)(&pHWHead->dwIOBase), 
					&dwDataSize);
	}

	if ( regError == ERROR_SUCCESS ) {
		dwDataSize = PC_REG_IOLEN_VAL_LEN;
		regError = RegQueryValueEx(
					hKey, 
					PC_REG_IOLEN_VAL_NAME, 
					NULL, 
					NULL,
					(LPBYTE)(&pHWHead->dwIOLen), 
					&dwDataSize);
	}

	RegCloseKey (hKey);

	if ( regError != ERROR_SUCCESS ) {
		RETAILMSG(DEBUGMODE, (TEXT("Failed to get serial registry values, Error 0x%X\r\n"),regError));
		return ( FALSE );
	}

	RETAILMSG (DEBUGMODE,(TEXT("SerInit - Devindex %d, IRQ %d, IOB %X, IOLen %X \r\n"),
		pHWHead->dwDevIndex, pHWHead->dwIRQ, pHWHead->dwIOBase, pHWHead->dwIOLen));
	return ( TRUE ); 
}

const
HW_VTBL IoVTbl = {
	SerInitSerial,
	SL_PostInit,
	SerDeinit,
	SerOpen,
	SerClose,
	SL_GetInterruptType,
	SL_RxIntr,
	SL_TxIntrEx,
	SL_ModemIntr,
	SL_LineIntr,
	SL_GetRxBufferSize,
	SerPowerOff,
	SerPowerOn,
	SL_ClearDTR,
	SL_SetDTR,
	SL_ClearRTS,
	SL_SetRTS,
	SerEnableSerial,
	SerDisableSerial,
	SL_ClearBreak,
	SL_SetBreak,
	SL_XmitComChar,
	SL_GetStatus,
	SL_Reset,
	SL_GetModemStatus,
	SerGetCommProperties,
	SL_PurgeComm,
	SL_SetDCB,
	SL_SetCommTimeouts,
	};
	
	const
HW_VTBL IoVTbl2 = {
	SerInitSerial2,
	SL_PostInit,
	SerDeinit,
	SerOpen,
	SerClose,
	SL_GetInterruptType,
	SL_RxIntr,
	SL_TxIntrEx,
	SL_ModemIntr,
	SL_LineIntr,
	SL_GetRxBufferSize,
	SerPowerOff,
	SerPowerOn,
	SL_ClearDTR,
	SL_SetDTR,
	SL_ClearRTS,
	SL_SetRTS,
	SerEnableSerial,
	SerDisableSerial,
	SL_ClearBreak,
	SL_SetBreak,
	SL_XmitComChar,
	SL_GetStatus,
	SL_Reset,
	SL_GetModemStatus,
	SerGetCommProperties,
	SL_PurgeComm,
	SL_SetDCB,
	SL_SetCommTimeouts,
	};
	
	const
HW_VTBL IoVTbl3 = {
	SerInitSerial3,
	SL_PostInit,
	SerDeinit,
	SerOpen,
	SerClose,
	SL_GetInterruptType,
	SL_RxIntr,
	SL_TxIntrEx,
	SL_ModemIntr,
	SL_LineIntr,
	SL_GetRxBufferSize,
	SerPowerOff,
	SerPowerOn,
	SL_ClearDTR,
	SL_SetDTR,
	SL_ClearRTS,
	SL_SetRTS,
	SerEnableSerial,
	SerDisableSerial,
	SL_ClearBreak,
	SL_SetBreak,
	SL_XmitComChar,
	SL_GetStatus,
	SL_Reset,
	SL_GetModemStatus,
	SerGetCommProperties,
	SL_PurgeComm,
	SL_SetDCB,
	SL_SetCommTimeouts,
	};
	
const
HW_VTBL Io16552VTbl4 = {
    Ser4Init,
    SL_PostInitq,
    Ser4Deinit,
    Ser4Open,
    Ser4Close,
    SL_GetInterruptTypeq,
    SL_RxIntrq,
    SL_TxIntrExq,
    SL_OtherIntrq,
    SL_LineIntrq,   
    SL_GetRxBufferSizeq,
    Ser4PowerOff,
    Ser4PowerOn,
    SL_ClearDTRq,
    SL_SetDTRq,
    SL_ClearRTSq,
    SL_SetRTSq,
    Ser4EnableIR,
    Ser4DisableIR,
    SL_ClearBreakq,
    SL_SetBreakq,
    SL_XmitComCharq,
    SL_GetStatusq,
    SL_Resetq,
    SL_GetModemStatusq,
    Ser4GetCommProperties,
    SL_PurgeCommq,
    SL_SetDCBq,
    SL_SetCommTimeoutsq
    };
	
extern const HW_VTBL SerCardIoVTbl;

/*const
HW_VTBL IrVTbl = {
	SerInitIR,
	SL_PostInit,
	SerDeinit,
	SerOpen,
	SerClose,
	SL_GetInterruptType,
	SL_RxIntr,
	SL_TxIntrEx,
	SL_ModemIntr,
	SL_LineIntr,
	SL_GetRxBufferSize,
	SerPowerOff,
	SerPowerOn,
	SL_ClearDTR,
	SL_SetDTR,
	SL_ClearRTS,
	SL_SetRTS,
	SerEnableIR,
	SerDisableIR,
	SL_ClearBreak,
	SL_SetBreak,
	SL_XmitComChar,
	SL_GetStatus,
	SL_Reset,
	SL_GetModemStatus,
	SerGetCommProperties,
	SL_PurgeComm,
	SL_SetDCB,
	SL_SetCommTimeouts,
	};
extern const HW_VTBL SerCardIrVTbl;*/

const HWOBJ IoObj = {
	THREAD_AT_INIT,
	SYSINTR_SERIAL,
	(PHW_VTBL) &IoVTbl
};
const HWOBJ IoObj2 = {
	THREAD_AT_INIT,
	SYSINTR_SERIAL2,
	(PHW_VTBL) &IoVTbl2
};
const HWOBJ IoObj3 = {
	THREAD_AT_INIT,
	SYSINTR_SERIAL3,
	(PHW_VTBL) &IoVTbl3
};
const HWOBJ Io16552Obj4 = {
	THREAD_AT_INIT,
	SYSINTR_SERIAL4,
	(PHW_VTBL) &Io16552VTbl4
};
/*const HWOBJ IrObj = {
	THREAD_AT_INIT,
	SYSINTR_IR,
	(PHW_VTBL) &IrVTbl
};*/

typedef HWOBJ const *PCHWOBJ;

const PCHWOBJ HWObjects[] = {
	&IoObj,
	&IoObj2,
	&IoObj3,
	&Io16552Obj4,
};

// GetSerialObj : The purpose of this function is to allow multiple PDDs to be
// linked with a single MDD creating a multiport driver.  In such a driver, the
// MDD must be able to determine the correct vtbl and associated parameters for
// each PDD.  Immediately prior to calling HWInit, the MDD calls GetSerialObject
// to get the correct function pointers and parameters.
//
PHWOBJ
GetSerialObject(DWORD DeviceArrayIndex)
{
	PHWOBJ pSerObj;

	RETAILMSG(1,(TEXT("GetSerialObject%d\r\n"),DeviceArrayIndex));

	IRDA = DeviceArrayIndex;

	// Now return this structure to the MDD.
	if ( DeviceArrayIndex == 0 )
		pSerObj = (PHWOBJ)(&IoObj);
	else if(DeviceArrayIndex == 1)
		pSerObj = (PHWOBJ)(&IoObj2);
	else if(DeviceArrayIndex == 2)
		pSerObj = (PHWOBJ)(&IoObj3);
	else if(DeviceArrayIndex == 3)
		pSerObj = (PHWOBJ)(&Io16552Obj4);
	else
		pSerObj = (PHWOBJ)(&IoObj);
	return (pSerObj);
}