modmflow.cod

怎样在win2000下构造驱动程序znsoft_Serial2000_demo.ZIP

; Listing generated by Microsoft (R) Optimizing Compiler Version 12.00.9044.0 

	TITLE	F:\W2DDK\src\kernel\serial\modmflow.c
	.386P
include listing.inc
if @Version gt 510
.model FLAT
else
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
_DATA	SEGMENT DWORD USE32 PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT DWORD USE32 PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT DWORD USE32 PUBLIC 'BSS'
_BSS	ENDS
$$SYMBOLS	SEGMENT BYTE USE32 'DEBSYM'
$$SYMBOLS	ENDS
$$TYPES	SEGMENT BYTE USE32 'DEBTYP'
$$TYPES	ENDS
_TLS	SEGMENT DWORD USE32 PUBLIC 'TLS'
_TLS	ENDS
;	COMDAT _RtlConvertLongToLargeInteger@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialSetDTR@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialClrDTR@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialSetRTS@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialClrRTS@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialSetupNewHandFlow@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialSetHandFlow@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialTurnOnBreak@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialTurnOffBreak@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialPretendXoff@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialPretendXon@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialHandleReducedIntBuffer@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialProdXonXoff@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialHandleModemUpdate@8
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialPerhapsLowerRTS@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialStartTimerLowerRTS@16
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialInvokePerhapsLowerRTS@16
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
;	COMDAT _SerialDecrementRTSCounter@4
_TEXT	SEGMENT PARA USE32 PUBLIC 'CODE'
_TEXT	ENDS
FLAT	GROUP _DATA, CONST, _BSS
	ASSUME	CS: FLAT, DS: FLAT, SS: FLAT
endif

INCLUDELIB LIBC
INCLUDELIB OLDNAMES

PUBLIC	_SerialSetDTR@4
EXTRN	__imp__READ_PORT_UCHAR@4:NEAR
EXTRN	__imp__WRITE_PORT_UCHAR@8:NEAR
; Function compile flags: /Ogsy
; File f:\w2ddk\src\kernel\serial\modmflow.c
;	COMDAT _SerialSetDTR@4
_TEXT	SEGMENT
_Context$ = 8
_ModemControl$ = 8
_SerialSetDTR@4 PROC NEAR				; COMDAT

; 81   : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 82   : 
; 83   :     PSERIAL_DEVICE_EXTENSION Extension = Context;
; 84   :     UCHAR ModemControl;
; 85   : 
; 86   :     ModemControl = READ_MODEM_CONTROL(Extension->Controller);

  00003	8b 45 08	 mov	 eax, DWORD PTR _Context$[ebp]
  00006	56		 push	 esi
  00007	8d b0 98 00 00
	00		 lea	 esi, DWORD PTR [eax+152]
  0000d	8b 06		 mov	 eax, DWORD PTR [esi]
  0000f	83 c0 04	 add	 eax, 4
  00012	50		 push	 eax
  00013	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__READ_PORT_UCHAR@4

; 87   : 
; 88   :     ModemControl |= SERIAL_MCR_DTR;

  00019	0c 01		 or	 al, 1
  0001b	88 45 08	 mov	 BYTE PTR _ModemControl$[ebp], al

; 89   : 
; 90   :     SerialDump(
; 91   :         SERFLOW,
; 92   :         ("SERIAL: Setting DTR for %x\n",
; 93   :          Extension->Controller)
; 94   :         );
; 95   :     WRITE_MODEM_CONTROL(
; 96   :         Extension->Controller,
; 97   :         ModemControl
; 98   :         );

  0001e	8b 06		 mov	 eax, DWORD PTR [esi]
  00020	ff 75 08	 push	 DWORD PTR _ModemControl$[ebp]
  00023	83 c0 04	 add	 eax, 4
  00026	50		 push	 eax
  00027	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__WRITE_PORT_UCHAR@8

; 99   : 
; 100  :     return FALSE;

  0002d	32 c0		 xor	 al, al
  0002f	5e		 pop	 esi

; 101  : 
; 102  : }

  00030	5d		 pop	 ebp
  00031	c2 04 00	 ret	 4
_SerialSetDTR@4 ENDP
_TEXT	ENDS
PUBLIC	_SerialClrDTR@4
; Function compile flags: /Ogsy
;	COMDAT _SerialClrDTR@4
_TEXT	SEGMENT
_Context$ = 8
_ModemControl$ = 8
_SerialClrDTR@4 PROC NEAR				; COMDAT

; 126  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 127  : 
; 128  :     PSERIAL_DEVICE_EXTENSION Extension = Context;
; 129  :     UCHAR ModemControl;
; 130  : 
; 131  :     ModemControl = READ_MODEM_CONTROL(Extension->Controller);

  00003	8b 45 08	 mov	 eax, DWORD PTR _Context$[ebp]
  00006	56		 push	 esi
  00007	8d b0 98 00 00
	00		 lea	 esi, DWORD PTR [eax+152]
  0000d	8b 06		 mov	 eax, DWORD PTR [esi]
  0000f	83 c0 04	 add	 eax, 4
  00012	50		 push	 eax
  00013	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__READ_PORT_UCHAR@4

; 132  : 
; 133  :     ModemControl &= ~SERIAL_MCR_DTR;

  00019	24 fe		 and	 al, 254			; 000000feH
  0001b	88 45 08	 mov	 BYTE PTR _ModemControl$[ebp], al

; 134  : 
; 135  :     SerialDump(
; 136  :         SERFLOW,
; 137  :         ("SERIAL: Clearing DTR for %x\n",
; 138  :          Extension->Controller)
; 139  :         );
; 140  :     WRITE_MODEM_CONTROL(
; 141  :         Extension->Controller,
; 142  :         ModemControl
; 143  :         );

  0001e	8b 06		 mov	 eax, DWORD PTR [esi]
  00020	ff 75 08	 push	 DWORD PTR _ModemControl$[ebp]
  00023	83 c0 04	 add	 eax, 4
  00026	50		 push	 eax
  00027	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__WRITE_PORT_UCHAR@8

; 144  : 
; 145  :     return FALSE;

  0002d	32 c0		 xor	 al, al
  0002f	5e		 pop	 esi

; 146  : 
; 147  : }

  00030	5d		 pop	 ebp
  00031	c2 04 00	 ret	 4
_SerialClrDTR@4 ENDP
_TEXT	ENDS
PUBLIC	_SerialSetRTS@4
; Function compile flags: /Ogsy
;	COMDAT _SerialSetRTS@4
_TEXT	SEGMENT
_Context$ = 8
_ModemControl$ = 8
_SerialSetRTS@4 PROC NEAR				; COMDAT

; 171  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 172  : 
; 173  :     PSERIAL_DEVICE_EXTENSION Extension = Context;
; 174  :     UCHAR ModemControl;
; 175  : 
; 176  :     ModemControl = READ_MODEM_CONTROL(Extension->Controller);

  00003	8b 45 08	 mov	 eax, DWORD PTR _Context$[ebp]
  00006	56		 push	 esi
  00007	8d b0 98 00 00
	00		 lea	 esi, DWORD PTR [eax+152]
  0000d	8b 06		 mov	 eax, DWORD PTR [esi]
  0000f	83 c0 04	 add	 eax, 4
  00012	50		 push	 eax
  00013	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__READ_PORT_UCHAR@4

; 177  : 
; 178  :     ModemControl |= SERIAL_MCR_RTS;

  00019	0c 02		 or	 al, 2
  0001b	88 45 08	 mov	 BYTE PTR _ModemControl$[ebp], al

; 179  : 
; 180  :     SerialDump(
; 181  :         SERFLOW,
; 182  :         ("SERIAL: Setting Rts for %x\n",
; 183  :          Extension->Controller)
; 184  :         );
; 185  :     WRITE_MODEM_CONTROL(
; 186  :         Extension->Controller,
; 187  :         ModemControl
; 188  :         );

  0001e	8b 06		 mov	 eax, DWORD PTR [esi]
  00020	ff 75 08	 push	 DWORD PTR _ModemControl$[ebp]
  00023	83 c0 04	 add	 eax, 4
  00026	50		 push	 eax
  00027	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__WRITE_PORT_UCHAR@8

; 189  : 
; 190  :     return FALSE;

  0002d	32 c0		 xor	 al, al
  0002f	5e		 pop	 esi

; 191  : 
; 192  : }

  00030	5d		 pop	 ebp
  00031	c2 04 00	 ret	 4
_SerialSetRTS@4 ENDP
_TEXT	ENDS
PUBLIC	_SerialClrRTS@4
; Function compile flags: /Ogsy
;	COMDAT _SerialClrRTS@4
_TEXT	SEGMENT
_Context$ = 8
_ModemControl$ = 8
_SerialClrRTS@4 PROC NEAR				; COMDAT

; 216  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 217  : 
; 218  :     PSERIAL_DEVICE_EXTENSION Extension = Context;
; 219  :     UCHAR ModemControl;
; 220  : 
; 221  :     ModemControl = READ_MODEM_CONTROL(Extension->Controller);

  00003	8b 45 08	 mov	 eax, DWORD PTR _Context$[ebp]
  00006	56		 push	 esi
  00007	8d b0 98 00 00
	00		 lea	 esi, DWORD PTR [eax+152]
  0000d	8b 06		 mov	 eax, DWORD PTR [esi]
  0000f	83 c0 04	 add	 eax, 4
  00012	50		 push	 eax
  00013	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__READ_PORT_UCHAR@4

; 222  : 
; 223  :     ModemControl &= ~SERIAL_MCR_RTS;

  00019	24 fd		 and	 al, 253			; 000000fdH
  0001b	88 45 08	 mov	 BYTE PTR _ModemControl$[ebp], al

; 224  : 
; 225  :     SerialDump(
; 226  :         SERFLOW,
; 227  :         ("SERIAL: Clearing Rts for %x\n",
; 228  :          Extension->Controller)
; 229  :         );
; 230  :     WRITE_MODEM_CONTROL(
; 231  :         Extension->Controller,
; 232  :         ModemControl
; 233  :         );

  0001e	8b 06		 mov	 eax, DWORD PTR [esi]
  00020	ff 75 08	 push	 DWORD PTR _ModemControl$[ebp]
  00023	83 c0 04	 add	 eax, 4
  00026	50		 push	 eax
  00027	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__WRITE_PORT_UCHAR@8

; 234  : 
; 235  :     return FALSE;

  0002d	32 c0		 xor	 al, al
  0002f	5e		 pop	 esi

; 236  : 
; 237  : }

  00030	5d		 pop	 ebp
  00031	c2 04 00	 ret	 4
_SerialClrRTS@4 ENDP
_TEXT	ENDS
PUBLIC	_SerialSetupNewHandFlow@8
PUBLIC	_SerialProdXonXoff@8
PUBLIC	_SerialPerhapsLowerRTS@4
EXTRN	_SerialProcessLSR@4:NEAR
; Function compile flags: /Ogsy
;	COMDAT _SerialSetupNewHandFlow@8
_TEXT	SEGMENT
_Extension$ = 8
_NewHandFlow$ = 12
_New$ = -16
_SerialSetupNewHandFlow@8 PROC NEAR			; COMDAT

; 266  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H
  00006	53		 push	 ebx
  00007	56		 push	 esi

; 267  : 
; 268  :     SERIAL_HANDFLOW New = *NewHandFlow;

  00008	8b 75 0c	 mov	 esi, DWORD PTR _NewHandFlow$[ebp]
  0000b	57		 push	 edi
  0000c	8d 7d f0	 lea	 edi, DWORD PTR _New$[ebp]
  0000f	a5		 movsd
  00010	a5		 movsd
  00011	a5		 movsd
  00012	a5		 movsd

; 269  : 
; 270  :     //
; 271  :     // If the Extension->DeviceIsOpened is FALSE that means
; 272  :     // we are entering this routine in response to an open request.
; 273  :     // If that is so, then we always proceed with the work regardless
; 274  :     // of whether things have changed.
; 275  :     //
; 276  : 
; 277  :     //
; 278  :     // First we take care of the DTR flow control.  We only
; 279  :     // do work if something has changed.
; 280  :     //
; 281  : 
; 282  :     if ((!Extension->DeviceIsOpened) ||
; 283  :         ((Extension->HandFlow.ControlHandShake & SERIAL_DTR_MASK) !=
; 284  :          (New.ControlHandShake & SERIAL_DTR_MASK))) {

  00013	8b 75 08	 mov	 esi, DWORD PTR _Extension$[ebp]
  00016	8b 45 f0	 mov	 eax, DWORD PTR _New$[ebp]
  00019	80 be 9d 01 00
	00 00		 cmp	 BYTE PTR [esi+413], 0
  00020	74 0d		 je	 SHORT $L14829
  00022	8b 8e 74 01 00
	00		 mov	 ecx, DWORD PTR [esi+372]
  00028	33 c8		 xor	 ecx, eax
  0002a	f6 c1 03	 test	 cl, 3
  0002d	74 67		 je	 SHORT $L14859
$L14829:

; 285  : 
; 286  :         SerialDump(
; 287  :             SERFLOW,
; 288  :             ("SERIAL: Processing DTR flow for %x\n",
; 289  :              Extension->Controller)
; 290  :             );
; 291  : 
; 292  :         if (New.ControlHandShake & SERIAL_DTR_MASK) {

  0002f	83 e0 03	 and	 eax, 3
  00032	74 4c		 je	 SHORT $L14833

; 293  : 
; 294  :             //
; 295  :             // Well we might want to set DTR.
; 296  :             //
; 297  :             // Before we do, we need to check whether we are doing
; 298  :             // dtr flow control.  If we are then we need to check
; 299  :             // if then number of characters in the interrupt buffer
; 300  :             // exceeds the XoffLimit.  If it does then we don't
; 301  :             // enable DTR AND we set the RXHolding to record that
; 302  :             // we are holding because of the dtr.
; 303  :             //
; 304  : 
; 305  :             if ((New.ControlHandShake & SERIAL_DTR_MASK)
; 306  :                 == SERIAL_DTR_HANDSHAKE) {

  00034	83 f8 02	 cmp	 eax, 2
  00037	75 39		 jne	 SHORT $L14836

; 307  : 
; 308  :                 if ((Extension->BufferSize - New.XoffLimit) >
; 309  :                     Extension->CharsInInterruptBuffer) {

  00039	8b 86 04 01 00
	00		 mov	 eax, DWORD PTR [esi+260]
  0003f	8b 96 f0 00 00
	00		 mov	 edx, DWORD PTR [esi+240]
  00045	2b 45 fc	 sub	 eax, DWORD PTR _New$[ebp+12]
  00048	3b c2		 cmp	 eax, edx
  0004a	76 1d		 jbe	 SHORT $L14848

; 310  : 
; 311  :                     //
; 312  :                     // However if we are already holding we don't want
; 313  :                     // to turn it back on unless we exceed the Xon