source: xtideuniversalbios/trunk/XTIDE_Universal_BIOS/Src/Device/Serial/SerialCommand.asm @ 223

Last change on this file since 223 was 223, checked in by krille_n_@…, 11 years ago

Changes:

  • Fixed what appears to be a mistake in EBIOS.inc
  • Added a 'release' option to the makefile of the Serial Server (invokes UPX)
  • Some very minor optimizations
  • Removed the eSEG macro and did some other cleanups (fixed typos etc)
File size: 23.6 KB
Line 
1; Project name  :   XTIDE Universal BIOS
2; Description   :   Serial Device Command functions.
3
4; Section containing code
5SECTION .text
6
7;--------------- UART Equates -----------------------------
8;
9; Serial Programming References:
10;    http://en.wikibooks.org/wiki/Serial_Programming
11;
12
13SerialCommand_UART_base                         EQU     0
14SerialCommand_UART_transmitByte                 EQU     0
15SerialCommand_UART_receiveByte                  EQU     0
16
17;
18; Values for UART_divisorLow:
19; 60h = 1200, 30h = 2400, 18h = 4800, 0ch = 9600, 6 = 19200, 3 = 38400, 2 = 57600, 1 = 115200
20;
21SerialCommand_UART_divisorLow                   EQU     0
22
23;
24; We support 4 baud rates, starting here going higher and skipping every other baud rate
25; Starting with 30h, that means 30h (1200 baud), 0ch (9600 baud), 3 (38400 baud), and 1 (115200 baud)
26; Note: hardware baud multipliers (2x, 4x) will impact the final baud rate and are not known at this level
27;
28SerialCommand_UART_divisorLow_startingBaud      EQU   030h
29
30SerialCommand_UART_interruptEnable              EQU     1
31
32;
33; UART_divisorHigh is zero for all speeds including and above 1200 baud (which is all we do)
34;
35SerialCommand_UART_divisorHigh                  EQU     1
36
37SerialCommand_UART_interruptIdent               EQU     2
38SerialCommand_UART_FIFOControl                  EQU     2
39
40SerialCommand_UART_lineControl                  EQU     3
41
42SerialCommand_UART_modemControl                 EQU     4
43
44SerialCommand_UART_lineStatus                   EQU     5
45
46SerialCommand_UART_modemStatus                  EQU     6
47
48SerialCommand_UART_scratch                      EQU     7
49
50SerialCommand_Protocol_Write                    EQU     3
51SerialCommand_Protocol_Read                     EQU     2
52SerialCommand_Protocol_Inquire                  EQU     0
53SerialCommand_Protocol_Header                   EQU     0a0h
54
55;--------------------------------------------------------------------
56; SerialCommand_OutputWithParameters
57;   Parameters:
58;       BH:     Non-zero if 48-bit addressing used
59;               (ignored at present as 48-bit addressing is not supported)
60;       BL:     IDE Status Register bit to poll after command
61;               (ignored at present, since there is no IDE status register to poll)
62;       ES:SI:  Ptr to buffer (for data transfer commands)
63;       DS:DI:  Ptr to DPT (in RAMVARS segment)
64;       SS:BP:  Ptr to IDEREGS_AND_INTPACK
65;   Returns:
66;       AH:     INT 13h Error Code
67;       CF:     Cleared if success, Set if error
68;   Corrupts registers:
69;       AL, BX, CX, DX, (ES:SI for data transfer commands)
70;--------------------------------------------------------------------
71ALIGN JUMP_ALIGN
72SerialCommand_OutputWithParameters:
73
74        mov     ah,(SerialCommand_Protocol_Header | SerialCommand_Protocol_Read)
75
76        mov     al,[bp+IDEPACK.bCommand]
77
78        cmp     al,20h          ; Read Sectors IDE command
79        jz      .readOrWrite
80        inc     ah              ; now SerialCommand_Protocol_Write
81        cmp     al,30h          ; Write Sectors IDE command
82        jz      .readOrWrite
83
84;  all other commands return success
85;  including function 0ech which should return drive information, this is handled with the identify functions
86;
87        xor     ah,ah           ;  also clears carry
88        ret
89
90.readOrWrite:
91        mov     [bp+IDEPACK.bFeatures],ah       ; store protocol command
92
93        mov     dl, byte [di+DPT.bSerialPortAndBaud]
94
95; fall-through
96
97;--------------------------------------------------------------------
98; SerialCommand_OutputWithParameters_DeviceInDL
99;   Parameters:
100;       AH:     Protocol Command
101;       DL:     Packed I/O port and baud rate
102;       ES:SI:  Ptr to buffer (for data transfer commands)
103;       SS:BP:  Ptr to IDEREGS_AND_INTPACK
104;   Returns:
105;       AH:     INT 13h Error Code
106;       CF:     Cleared if success, Set if error
107;   Corrupts registers:
108;       AL, BX, CX, DX, (ES:SI for data transfer commands)
109;--------------------------------------------------------------------
110SerialCommand_OutputWithParameters_DeviceInDL:
111
112        push    si
113        push    di
114        push    bp
115        push    es
116
117;
118; Unpack I/O port and baud from DPT
119;       Port to DX more or less for the remainder of the routine
120;       Baud in CH until UART initialization is complete
121;
122        mov     dh, ((DEVICE_SERIAL_PACKEDPORTANDBAUD_STARTINGPORT & 0f00h) >> (8+1))
123        shl     dx, 1       ; port offset already x4, needs one more shift to be x8
124        mov     cl, dl
125
126        and     cl, (DEVICE_SERIAL_PACKEDPORTANDBAUD_BAUDMASK << 1)
127        mov     ch, SerialCommand_UART_divisorLow_startingBaud
128        shr     ch, cl
129        adc     ch, 0
130
131        and     dl, ((DEVICE_SERIAL_PACKEDPORTANDBAUD_PORTMASK << 1) & 0ffh)
132        add     dx, byte (DEVICE_SERIAL_PACKEDPORTANDBAUD_STARTINGPORT & 0ffh)
133
134        mov     al,[bp+IDEPACK.bSectorCount]
135
136;
137; Command byte and sector count live at the top of the stack, pop/push are used to access
138;
139        push    ax
140
141%if 0
142        cld     ; Shouldn't be needed. DF has already been cleared (line 24, Int13h.asm)
143%endif
144
145;----------------------------------------------------------------------
146;
147; Initialize UART
148;
149; We do this each time since DOS (at boot) or another program may have
150; decided to reprogram the UART
151;
152        mov     bl,dl           ; setup BL with proper values for read/write loops (BH comes later)
153
154        mov     al,83h
155        add     dl,SerialCommand_UART_lineControl
156        out     dx,al
157
158        mov     al,ch
159        mov     dl,bl           ; divisor low
160        out     dx,al
161
162        xor     ax,ax
163        inc     dx              ; divisor high
164        push    dx
165        out     dx,al
166
167        mov     al,047h
168        inc     dx              ;  fifo
169        out     dx,al
170
171        mov     al,03h
172        inc     dx              ;  linecontrol
173        out     dx,al
174
175        mov     al,0bh
176        inc     dx              ;  modemcontrol
177        out     dx,al
178
179        inc     dx              ;  linestatus (no output now, just setting up BH for later use)
180        mov     bh,dl
181
182        pop     dx              ; base, interrupts disabled
183        xor     ax,ax
184        out     dx,al
185
186;----------------------------------------------------------------------
187;
188; Send Command
189;
190; Sends first six bytes of IDEREGS_AND_INTPACK as the command
191;
192        push    es              ; save off real buffer location
193        push    si
194
195        mov     si,bp           ; point to IDEREGS for command dispatch;
196        push    ss
197        pop     es
198
199        mov     di,0ffffh       ; initialize checksum for write
200        mov     bp,di
201
202        mov     cx,4            ; writing 3 words (plus 1)
203
204        cli                     ; interrupts off...
205
206        call    SerialCommand_WriteProtocol.entry
207
208        pop     di              ; restore real buffer location (note change from SI to DI)
209                                ; Buffer is primarily referenced through ES:DI throughout, since
210                                ; we need to store (read sector) faster than we read (write sector)
211        pop     es
212
213%if 0
214;;; no longer needed, since the pointer is normalized before we are called and we do not support
215;;; more than 128 sectors (and for 128 specifically, the pointer must be segment aligned).
216;;; See comments below at the point this entry point was called for more details...
217.nextSectorNormalize:
218        call    Registers_NormalizeESDI
219%endif
220
221        pop     ax              ; load command byte (done before call to .nextSector on subsequent iterations)
222        push    ax
223
224;
225; Top of the read/write loop, one iteration per sector
226;
227.nextSector:
228        mov     si,0ffffh       ; initialize checksum for read or write
229        mov     bp,si
230
231        mov     cx,0101h        ; writing 256 words (plus 1)
232
233        shr     ah,1            ; command byte, are we doing a write?
234        jnc     .readEntry
235
236        xchg    si,di
237        call    SerialCommand_WriteProtocol.entry
238        xchg    si,di
239
240        inc     cx              ; CX = 1 now (0 out of WriteProtocol)
241        jmp     .readEntry
242
243;----------------------------------------------------------------------
244;
245; Timeout
246;
247; To save code space, we use the contents of DL to decide which byte in the word to return for reading.
248;
249.readTimeout:
250        push    ax              ; not only does this push preserve AX (which we need), but it also
251                                ; means the stack has the same number of bytes on it as when we are
252                                ; sending a packet, important for error cleanup and exit
253        mov     ah,1
254        call    SerialCommand_WaitAndPoll_Read
255        pop     ax
256        test    dl,1
257        jz      .readByte1Ready
258        jmp     .readByte2Ready
259
260;----------------------------------------------------------------------------
261;
262; Read Block (without interrupts, used when there is a FIFO, high speed)
263;
264; NOTE: This loop is very time sensitive.  Literally, another instruction
265; cannot be inserted into this loop without us falling behind at high
266; speed (460.8K baud) on a 4.77Mhz 8088, making it hard to receive
267; a full 512 byte block.
268;
269.readLoop:
270        stosw                   ; store word in caller's data buffer
271
272        add     bp, ax          ; update Fletcher's checksum
273        adc     bp, 0
274        add     si, bp
275        adc     si, 0
276
277.readEntry:
278        mov     dl,bh
279        in      al,dx
280        shr     al,1            ; data ready (byte 1)?
281        mov     dl,bl           ; get ready to read data
282        jnc     .readTimeout    ; nope not ready, update timeouts
283
284;
285; Entry point after initial timeout.  We enter here so that the checksum word
286; is not stored (and is left in AX after the loop is complete).
287;
288.readByte1Ready:
289        in      al, dx          ; read data byte 1
290
291        mov     ah, al          ; store byte in ah for now
292
293;
294; note the placement of this reset of dl to bh, and that it is
295; before the return, which is assymetric with where this is done
296; above for byte 1.  The value of dl is used by the timeout routine
297; to know which byte to return to (.read_byte1_ready or
298; .read_byte2_ready)
299;
300        mov     dl,bh
301
302        in      al,dx
303        shr     al,1            ; data ready (byte 2)?
304        jnc     .readTimeout
305.readByte2Ready:
306        mov     dl,bl
307        in      al, dx          ; read data byte 2
308
309        xchg    al, ah          ; ah was holding byte 1, reverse byte order
310
311        loop    .readLoop
312
313        sti                     ; interrupts back on ASAP, between packets
314
315;
316; Compare checksums
317;
318        xchg    ax,bp
319        xor     ah,al
320        mov     cx,si
321        xor     cl,ch
322        mov     al,cl
323        cmp     ax,bp
324        jnz     SerialCommand_OutputWithParameters_Error
325
326        pop     ax              ; sector count and command byte
327        dec     al              ; decrement sector count
328        push    ax              ; save
329        jz      SerialCommand_OutputWithParameters_ReturnCodeInALCF    ; CF=0 from "cmp ax,bp" returning Zero above
330
331        cli                     ; interrupts back off for ACK byte to host
332                                ; (host could start sending data immediately)
333        out     dx,al           ; ACK with next sector number
334
335%if 0
336;;; This code is no longer needed as we do not support more than 128 sectors, and for 128 the pointer
337;;; must be segment aligned.  If we ever do want to support more sectors, the code can help...
338
339;
340; Normalize buffer pointer for next go round, if needed.
341;
342; We need to re-normalize the pointer in ES:DI after processing every 7f sectors.  That number could
343; have been 80 if we knew the offset was on a segment boundary, but this may not be the case.
344;
345; We re-normalize based on the sector count (flags from "dec al" above)...
346;    a) we normalize before the first sector goes out, immediately after sending the command packet (above)
347;    b) on transitions from FF to FE, very rare case for writing 255 or 256 sectors
348;    c) on transitions from 80 to 7F, a large read/write
349;    d) on transitions from 00 to FF, very, very rare case of writing 256 sectors
350;       We don't need to renormalize in this case, but it isn't worth the memory/effort to not do
351;       the extra work, and it does no harm.
352;
353; I really don't care much about (d) because I have not seen cases where any OS makes a request
354; for more than 127 sectors.  Back in the day, it appears that some BIOS could not support more than 127
355; sectors, so that may be the practical limit for OS and application developers.  The Extended BIOS
356; function also appear to be capped at 127 sectors.  So although this can support the full 256 sectors
357; if needed, we are optimized for that 1-127 range.
358;
359; Assume we start with 0000:000f, with 256 sectors to write...
360;    After first packet, 0000:020f
361;    First decrement of AL, transition from 00 to FF: renormalize to 0020:000f (unnecessary)
362;    After second packet, 0020:020f
363;    Second derement of AL, transition from FF to FE: renormalize to 0040:000f
364;    After 7f more packets, 0040:fe0f
365;    Decrement of AL, transition from 80 to 7F: renormalize to 1020:000f
366;    After 7f more packets, 1020:fe0f or 2000:000f if normalized
367;    Decrement of AL, from 1 to 0: exit
368;
369        jge     short .nextSector       ; OF=SF, branch for 1-7e, most common case
370                                        ; (0 kicked out above for return success)
371
372        add     al,2                    ; 7f-ff moves to 81-01
373                                        ; (0-7e kicked out before we get here)
374                                        ; 7f moves to 81 and OF=1, so OF=SF
375                                        ; fe moves to 0 and OF=0, SF=0, so OF=SF
376                                        ; ff moves to 1 and OF=0, SF=0, so OF=SF
377                                        ; 80-fd moves to 82-ff and OF=0, so OF<>SF
378
379        jl      short .nextSector       ; OF<>SF, branch for all cases but 7f, fe, and ff
380
381;       jpo     short .nextSector       ; if we really wanted to avoid normalizing for ff, this
382                                        ; is one way to do it, but it adds more memory and more
383                                        ; cycles for the 7f and fe cases.  IMHO, given that I've
384                                        ; never seen a request for more than 7f, this seems unnecessary.
385
386        jmp     short .nextSectorNormalize  ; our two renormalization cases (plus one for ff)
387
388%else
389
390        jmp     short .nextSector
391
392%endif
393
394;---------------------------------------------------------------------------
395;
396; Cleanup, error reporting, and exit
397;
398
399;
400; Used in situations where a call is underway, such as with SerialCommand_WaitAndPoll
401;
402ALIGN JUMP_ALIGN
403SerialCommand_OutputWithParameters_ErrorAndPop4Words:
404        add     sp,8
405;;; fall-through
406
407ALIGN JUMP_ALIGN
408SerialCommand_OutputWithParameters_Error:
409;----------------------------------------------------------------------
410;
411; Clear read buffer
412;
413; In case there are extra characters or an error in the FIFO, clear it out.
414; In theory the initialization of the UART registers above should have
415; taken care of this, but I have seen cases where this is not true.
416;
417.clearBuffer:
418        mov     dl,bh
419        in      al,dx
420        mov     dl,bl
421        test    al,08fh
422        jz      .clearBufferComplete
423        shr     al,1
424        in      al,dx
425        jc      .clearBuffer    ; note CF from shr above
426
427.clearBufferComplete:
428        stc
429        mov     al,1
430
431ALIGN JUMP_ALIGN
432SerialCommand_OutputWithParameters_ReturnCodeInALCF:
433%if 0
434        sti                     ;  all paths here will already have interrupts turned back on
435%endif
436        mov     ah,al
437
438        pop     bp              ;  recover ax (command and count) from stack, throw away
439
440        pop     es
441        pop     bp
442        pop     di
443        pop     si
444
445        ret
446
447;--------------------------------------------------------------------
448; SerialCommand_WriteProtocol
449;
450; NOTE: As with its read counterpart, this loop is very time sensitive.
451; Although it will still function, adding additional instructions will
452; impact the write throughput, especially on slower machines.
453;
454;   Parameters:
455;       ES:SI:  Ptr to buffer
456;       CX:     Words to write, plus 1
457;       BP/DI:  Initialized for Checksum (-1 in each)
458;       DH:     I/O Port high byte
459;       BX:     LineStatus Register address (BH) and Receive/Transmit Register address (BL)
460;   Returns:
461;       BP/DI:  Checksum for written bytes, compared against ACK from server in .readLoop
462;       CX:     Zero
463;       DL:     Receive/Transmit Register address
464;   Corrupts registers:
465;       AX
466;--------------------------------------------------------------------
467ALIGN JUMP_ALIGN
468SerialCommand_WriteProtocol:
469.writeLoop:
470        es lodsw                ; fetch next word
471
472        out     dx,al           ; output first byte
473
474        add     bp,ax           ; update checksum
475        adc     bp,0
476        add     di,bp
477        adc     di,0
478
479        mov     dl,bh           ; transmit buffer empty?
480        in      al,dx
481        test    al,20h
482        jz      .writeTimeout2  ; nope, use our polling routine
483
484.writeByte2Ready:
485        mov     dl,bl
486        mov     al,ah           ; output second byte
487        out     dx,al
488
489.entry:
490        mov     dl,bh           ; transmit buffer empty?
491        in      al,dx
492        test    al,20h
493        mov     dl,bl
494        jz      .writeTimeout1  ; nope, use our polling routine
495
496.writeByte1Ready:
497        loop    .writeLoop
498
499        mov     ax,di           ; fold Fletcher's checksum and output
500        xor     al,ah
501        out     dx,al           ; byte 1
502
503        call    SerialCommand_WaitAndPoll_Write
504
505        mov     ax,bp
506        xor     al,ah
507        out     dx,al           ; byte 2
508
509        ret
510
511.writeTimeout2:
512        mov     dl,ah           ; need to preserve AH, but don't need DL (will be reset upon return)
513        call    SerialCommand_WaitAndPoll_Write
514        mov     ah,dl
515        jmp     .writeByte2Ready
516
517.writeTimeout1:
518%ifndef USE_186
519        mov     ax,.writeByte1Ready
520        push    ax              ; return address for ret at end of SC_writeTimeout2
521%else
522        push    .writeByte1Ready
523%endif
524;;; fall-through
525
526;--------------------------------------------------------------------
527; SerialCommand_WaitAndPoll
528;
529;   Parameters:
530;       AH:     UART_LineStatus bit to test (20h for write, or 1h for read)
531;               One entry point fills in AH with 20h for write
532;       DX:     Port address (OK if already incremented to UART_lineStatus)
533;       BX:
534;       Stack:  2 words on the stack below the command/count word
535;   Returns:
536;       Returns when desired UART_LineStatus bit is cleared
537;       Jumps directly to error exit if timeout elapses (and cleans up stack)
538;   Corrupts registers:
539;       AX
540;--------------------------------------------------------------------
541
542SerialCommand_WaitAndPoll_SoftDelayTicks   EQU   20
543
544ALIGN JUMP_ALIGN
545SerialCommand_WaitAndPoll_Write:
546        mov     ah,20h
547;;; fall-through
548
549ALIGN JUMP_ALIGN
550SerialCommand_WaitAndPoll_Read:
551        push    cx
552        push    dx
553
554;
555; We first poll in a tight loop, interrupts off, for the next character to come in/be sent
556;
557        xor     cx,cx
558.readTimeoutLoop:
559        mov     dl,bh
560        in      al,dx
561        test    al,ah
562        jnz     .readTimeoutComplete
563        loop    .readTimeoutLoop
564
565;
566; If that loop completes, then we assume there is a long delay involved, turn interrupts back on
567; and wait for a given number of timer ticks to pass.
568;
569        sti
570        mov     cl,SerialCommand_WaitAndPoll_SoftDelayTicks
571        call    Timer_InitializeTimeoutWithTicksInCL
572.WaitAndPoll:
573        call    Timer_SetCFifTimeout
574        jc      SerialCommand_OutputWithParameters_ErrorAndPop4Words
575        in      al,dx
576        test    al,ah
577        jz      .WaitAndPoll
578        cli
579
580.readTimeoutComplete:
581        pop     dx
582        pop     cx
583        ret
584
585;--------------------------------------------------------------------
586; SerialCommand_IdentifyDeviceToBufferInESSIwithDriveSelectByteInBH
587;   Parameters:
588;       BH:     Drive Select byte for Drive and Head Select Register
589;       DS:     Segment to RAMVARS
590;       ES:SI:  Ptr to buffer to receive 512-byte IDE Information
591;       CS:BP:  Ptr to IDEVARS
592;   Returns:
593;       AH:     INT 13h Error Code
594;               NOTE: Not set (or checked) during drive detection
595;       CF:     Cleared if success, Set if error
596;   Corrupts registers:
597;       AL, BL, CX, DX, SI, DI, ES
598;--------------------------------------------------------------------
599ALIGN JUMP_ALIGN
600SerialCommand_IdentifyDeviceToBufferInESSIwithDriveSelectByteInBH:
601;
602; To improve boot time, we do our best to avoid looking for slave serial drives when we already know the results
603; from the looking for a master.  This is particularly true when doing a COM port scan, as we will end up running
604; through all the COM ports and baud rates a second time.
605;
606; But drive detection isn't the only case - we also need to get the right drive when called on int13h/25h.
607;
608; The decision tree:
609;
610;    Master:
611;          bSerialPackedPortAndBaud Non-Zero:   -> Continue with bSerialPackedAndBaud (1)
612;          bSerialPackedPortAndBaud Zero:
613;                         bLastSerial Zero:     -> Scan (2)
614;                         bLastSerial Non-Zero: -> Continue with bLastSerial (3)
615;
616;    Slave:
617;          bSerialPackedPortAndBaud Non-Zero:
618;                         bLastSerial Zero:     -> Error - Not Found (4)
619;                         bLastSerial Non-Zero: -> Continue with bSerialPackedAndBaud (5)
620;          bSerialPackedPortAndBaud Zero:
621;                         bLastSerial Zero:     -> Error - Not Found (4)
622;                         bLastSerial Non-Zero: -> Continue with bLastSerial (6)
623;
624; (1) This was a port/baud that was explicitly set with the configurator.  In the drive detection case, as this
625;     is the Master, we are checking out a new controller, and so don't care about the value of bLastSerial.
626;     And as with the int13h/25h case, we just go off and get the needed information using the user's setting.
627; (2) We are using the special .ideVarsSerialAuto structure.  During drive detection, we would only be here
628;     if bLastSerial is zero (since we only scan if no explicit drives are set), so we go off to scan.
629; (3) We are using the special .ideVarsSerialAuto structure.  We won't get here during drive detection, but
630;     we might get here on an int13h/25h call.  If we have scanned COM drives, they are the ONLY serial drives
631;     in use, and so bLastSerial will reflect the port/baud setting for the scanned COM drives.
632; (4) No master has been found yet, therefore no slave should be found.  Avoiding the slave reduces boot time,
633;     especially in the full COM port scan case.  Note that this is different from the hardware IDE, where we
634;     will scan for a slave even if a master is not present.  Note that if ANY master had been previously found,
635;     we will do the slave scan, which isn't harmful, it just wastes time.  But the most common case (by a wide
636;     margin) will be just one serial controller.
637; (5) A COM port scan for a master had been previously completed, and a drive was found.  In a multiple serial
638;     controller scenario being called with int13h/25h, we need to use the value in bSerialPackedPortAndBaud
639;     to make sure we get the proper drive.
640; (6) A COM port scan for a master had been previously completed, and a drive was found.  We would only get here
641;     if no serial drive was explicitly set by the user in the configurator or that drive had not been found.
642;     Instead of performing the full COM port scan for the slave, use the port/baud value stored during the
643;     master scan.
644;
645        mov     dl,[cs:bp+IDEVARS.bSerialPackedPortAndBaud]
646        mov     al, byte [RAMVARS.xlateVars+XLATEVARS.bLastSerial]
647
648        test    bh, FLG_DRVNHEAD_DRV
649        jz      .master
650
651        test    al,al           ; Take care of the case that is different between master and slave.
652        jz      .error          ; Because we do this here, the jz after the "or" below will not be taken
653
654; fall-through
655.master:
656        test    dl,dl
657        jnz     .identifyDeviceInDL
658
659        or      dl,al           ; Move bLast into position in dl, as well as test for zero
660        jz      .scanSerial
661
662; fall-through
663.identifyDeviceInDL:
664
665        push    bp              ; setup fake IDEREGS_AND_INTPACK
666
667        push    dx
668
669        mov     cl,1            ; 1 sector to move
670        push    cx
671
672        mov     bl,0a0h         ; protocol command to ah and onto stack with bh
673        mov     ah,bl
674
675        push    bx
676
677        mov     bp,sp
678        call    SerialCommand_OutputWithParameters_DeviceInDL
679
680        pop     bx
681
682        pop     cx
683        pop     dx
684
685        pop     bp
686;
687; place packed port/baud in RAMVARS, read by FinalizeDPT and DetectDrives
688;
689; Note that this will be set during an int13h/25h call as well.  Which is OK since it is only used (at the
690; top of this routine) for drives found during a COM scan, and we only COM scan if there were no other
691; COM drives found.  So we will only reaffirm the port/baud for the one COM port/baud that has a drive.
692;
693        jc      .notFound                                           ; only store bLastSerial if success
694        mov     byte [RAMVARS.xlateVars+XLATEVARS.bLastSerial], dl
695
696.notFound:
697        ret
698
699;----------------------------------------------------------------------
700;
701; SerialCommand_AutoSerial
702;
703; When the SerialAuto IDEVARS entry is used, scans the COM ports on the machine for a possible serial connection.
704;
705
706.scanPortAddresses: db  DEVICE_SERIAL_COM7 >> 2
707                    db  DEVICE_SERIAL_COM6 >> 2
708                    db  DEVICE_SERIAL_COM5 >> 2
709                    db  DEVICE_SERIAL_COM4 >> 2
710                    db  DEVICE_SERIAL_COM3 >> 2
711                    db  DEVICE_SERIAL_COM2 >> 2
712                    db  DEVICE_SERIAL_COM1 >> 2
713                    db  0
714
715ALIGN JUMP_ALIGN
716.scanSerial:
717        mov     di,.scanPortAddresses-1
718
719.nextPort:
720        inc     di              ; load next port address
721        xor     dh, dh
722        mov     dl,[cs:di]
723        eSHL_IM dx, 2           ; shift from one byte to two
724        jz      .error
725
726;
727; Test for COM port presence, write to and read from registers
728;
729        push    dx
730        add     dl,SerialCommand_UART_lineControl
731        mov     al, 09ah
732        out     dx, al
733        in      al, dx
734        pop     dx
735        cmp     al, 09ah
736        jnz     .nextPort
737
738        mov     al, 0ch
739        out     dx, al
740        in      al, dx
741        cmp     al, 0ch
742        jnz     .nextPort
743
744;
745; Pack into dl, baud rate starts at 0
746;
747        add     dx,-(DEVICE_SERIAL_PACKEDPORTANDBAUD_STARTINGPORT)
748        shr     dx,1            ; dh is zero at this point, and will be sent to the server,
749                                ; so we know this is an auto detect
750
751        jmp     .testFirstBaud
752
753;
754; Walk through 4 possible baud rates
755;
756.nextBaud:
757        inc     dx
758        test    dl,3
759        jz      .nextPort
760
761.testFirstBaud:
762        call    .identifyDeviceInDL
763        jc      .nextBaud
764
765        ret
766
767.error:
768        stc
769%if 0
770        mov     ah,1        ; setting the error code is unnecessary as this path can only be taken during
771                            ; drive detection, and drive detection works off CF and does not check AH
772%endif
773        ret
774
775
Note: See TracBrowser for help on using the repository browser.