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

Last change on this file since 207 was 207, checked in by gregli@…, 13 years ago

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