Minkus
Member | Редактировать | Профиль | Сообщение | ICQ | Цитировать | Сообщить модератору
aequit
Цитата:| Порылся в закромах, нашел |
Это что досовая, что ли. Там нет СДЛД.Genue
Сам ваять что ли будешь?
Держи, может еще кто подключится. Давно бы уж всем миром начали бы ваять, что нибудь типа st mem.
С) А.Stepanov.Опубликовано в ФИДО.
>> Я же написал не D, а d. Если ты, судя по нижеописанному, нашел в
>> коде таблицу команд, то должен видеть разницу.
IM> барракуде (шуршит и скрежещет, ИМХО, хуже ей уже не будет). А что
IM> вообще эта команда делает? Мой сабж по ней толи виснет, толи ждёт
IM> некий блок,
Он ждет синхропоследовательности CC 33, на которые отвечает, соответственно,
77 и 88, затем ждет блок данных, # блока и контрольную сумму.
Подробно описывать лень, если интересно и знаком с ассемблером
Motorola 68HC11, могу выслать текст подпрограммы, обрабатывающей
эту команду.
Hу, держи, раз так хочешь. Только вряд ли тебе это сильно поможет -
с куском чужого кода в отрыве от остального разбираться - занятие еще то.
Впрочем, может быть, кому и пригодится.
Core:C2EB ; --------------- S U B R O U T I N E
Core:C2EB
Core:C2EB ; Прием CERT-модуля через итерфейс
Core:C2EB ;
Core:C2EB ; Блоки идут 1-2-3-4 итд, а последним идет блок 0
Core:C2EB ; Все размещается по адресам 1000-FFFF буферной памяти.
Core:C2EB ;
Core:C2EB ; Порядок приема блоков такой:
Core:C2EB ;
Core:C2EB ; HS - блок1 - блок2 - блок3 - ..... - блок34 - блок0 - общая КС
Core:C2EB ;
Core:C2EB ; HS - синхропоследовательность ( ->CC 77-> ->33 88->)
Core:C2EB ;
Core:C2EB ; блок имеет формат
Core:C2EB ;
Core:C2EB ; HS - 512 байт блока - 1 байт # блока - HS - 2 байта КС
Core:C2EB ;
Core:C2EB
Core:C2EB Recv_CERT_module: ; CODE XREF: CMD_1_d+C P
Core:C2EB ; CMD_T_f+9 P
Core:C2EB pshx
Core:C2EC tsx
Core:C2ED xgdx
Core:C2EE subd #$E
Core:C2F1 xgdx ; выделяем место в стеке
Core:C2F2 txs
Core:C2F3 std 0,x ; аргумент - адрес
Core:C2F5 clr 2,x
Core:C2F7 inc 2,x ; =1 номера блоков
Core:C2F9 ldd 0,x ; адрес
Core:C2FB addd #$200 ; следующий блок
Core:C2FE xgdy ; -> Y
Core:C300 jsr Handshake_start ; начинаем обмен
Core:C303
Core:C303 loc_C303: ; CODE XREF:
Core:C303 ; Recv_CERT_module+72 j
Core:C303 ldd #0
Core:C306 std 4,x ; счетчик
Core:C308 jsr Handshake_start ; синхронизация
Core:C30B
Core:C30B loc_C30B: ; CODE XREF:
Core:C30B jsr Recv_wait_byte ; читаем байт
Core:C30E jsr Print_wait_byte ; возвращаем как эхо
Core:C311 jsr Store_buf ; засовываем в буфер
Core:C314 iny ; адрес в буфере ++
Core:C316 ldd 4,x
Core:C318 addd #1 ; счетчик ++
Core:C31B std 4,x
Core:C31D cpd #$1FF ; сектор закончен?
Core:C321 ble loc_C30B ; нет - вычитываем весь
; сектор
Core:C323 jsr Recv_wait_byte ; читаем номер блока
Core:C326 jsr Print_wait_byte ; эхо
Core:C329 staa 6,x ; временно сохраненный #
Core:C32B beq loc_C330 ; # блока = 0
Core:C32D inca
Core:C32E staa 2,x ; новый # блока
Core:C330
Core:C330 loc_C330: ; CODE XREF:
Core:C330 jsr Handshake_start ; синхронизация
Core:C333 jsr Recv_wait_byte ; читаем 1 байт КС
Core:C336 staa 8,x
Core:C338 jsr Print_wait_byte
Core:C33B jsr Recv_wait_byte ; читаем 2 байт КС
Core:C33E staa 9,x
Core:C340 jsr Print_wait_byte
Core:C343 jsr Check_cert_buf_csum ; проверяем КС
Core:C346 beq loc_C356 ; совпала
Core:C348 ldaa #$15
Core:C34A jsr Print_wait_byte ; 15 - признак несовпадения
; КС
Core:C34D xgdy
Core:C34F subd #$200 ; блок назад
Core:C352 xgdy
Core:C354 bra loc_C303 ; перечитываем
Core:C356
Core:C356 loc_C356:
Core:C356 ldaa #6
Core:C358 jsr Print_wait_byte ; 6 - КС совпала
Core:C35B ldaa 6,x ; # блока
Core:C35D bne loc_C303 ; != 0 - продолжаем прием
; блоков
Core:C35F jsr Recv_wait_byte
Core:C362 staa 8,x ; 1 байт сигнатуры
Core:C364 jsr Recv_wait_byte
Core:C367 staa 9,x ; 2 байт сигнатуры
Core:C369 xgdy
Core:C36B subd #$200
Core:C36E std 6,x ; конечный адрес
Core:C370 ldd 0,x
Core:C372 std 4,x ; начальный адрес
Core:C374
Core:C374 loc_C374: ; CODE XREF:
Core:C374 ldy 6,x
Core:C377 jsr Get_buf ; 1 байт последнего сектора
Core:C37A ldy 4,x
Core:C37D jsr Store_buf ; в 1 байт 1 сектора
Core:C380 clra
Core:C381 ldy 6,x ; очищаем байт
Core:C381 ; последнего сектора
Core:C384 jsr Store_buf
Core:C387 ldd 6,x ; адрес конца++
Core:C389 addd #1
Core:C38C std 6,x
Core:C38E ldd 4,x ; адрес начала++
Core:C390 addd #1
Core:C393 std 4,x
Core:C395 ldd 0,x
Core:C397 addd #$1FF ; и так идем до конца сектора
Core:C39A cpd 4,x
Core:C39D bcc loc_C374
Core:C39F ldy 0,x ; адрес начала буфера
Core:C3A2 jsr calc_common_cs ; вычисляем общую КС
Core:C3A5 beq loc_C3B3 ; правильная
Core:C3A7 ldaa #$15
Core:C3A9 jsr Print_wait_byte ; неправильная КС
Core:C3AC ldaa #$20 ; ' '
Core:C3AE staa Err_code
Core:C3B1 bne loc_C3B9
Core:C3B3
Core:C3B3 loc_C3B3: ; CODE XREF:
Core:C3B3 ldaa #6 ; правильная КС
Core:C3B5 jsr Print_wait_byte
Core:C3B8 clra
Core:C3B9
Core:C3B9 loc_C3B9: ; CODE XREF:
Core:C3B9 ldd 8,x ; принятая сигнатура
Core:C3BB tsx
Core:C3BC xgdx
Core:C3BD addd #$E ; восстанавливаем стек
Core:C3C0 xgdx
Core:C3C1 txs
Core:C3C2 pulx
Core:C3C3 rts
Core:C3C3 ; End of function Recv_CERT_module
Core:C3C3
Core:C3C4
Core:C3C4 ; --------------- S U B R O U T I N E
Core:C3C4
Core:C3C4 ; ачало процедуры заливки церта -
Core:C3C4 ;
Core:C3C4 ; Послылка CC
Core:C3C4 ; Ответ 77
Core:C3C4 ; Посылка 33
Core:C3C4 ; Ответ 88
Core:C3C4
Core:C3C4 Handshake_start: ; CODE XREF:
Core:C3C4 ; Recv_CERT_module+1D P ...
Core:C3C4 jsr Recv_wait_byte ; читаем байт с компорта
Core:C3C7 cmpa #$CC ; '¦' ; CC ?
Core:C3C9 bne Handshake_start ; нет - ждем CC
Core:C3CB ldaa #$77 ; 'w'
Core:C3CD jsr Print_wait_byte ; Эхо-ответ = 77
Core:C3D0 jsr Recv_wait_byte ; читаем следующий байт
Core:C3D3 cmpa #$33 ; '3' ; 33 ?
Core:C3D5 bne Handshake_start ; нет - начинаем цепочку
;сначала
Core:C3D7 ldaa #$88 ; 'И' ; эхо-ответ = 88
Core:C3D9 jsr Print_wait_byte
Core:C3DC rts
Core:C3DC ; End of function Handshake_start
Core:C3DC
Core:C3DD
Core:C3DD ; --------------- S U B R O U T I N E
Core:C3DD
Core:C3DD ; Вычисление контрольной суммы полученного CERT-блока
Core:C3DD ;
Core:C3DD ; КС считается так.
Core:C3DD ;
Core:C3DD ; КС=0
Core:C3DD ;
Core:C3DD ;
Core:C3DD
Core:C3DD Calc_Cert_buf_CS: ; CODE XREF:
Core:C3DD ldd #0
Core:C3E0 std 4,x ; счетчик байтов
Core:C3E2 std $A,x ; будущая КС
Core:C3E2 ; End of function Calc_Cert_buf_CS
Core:C3E2
Core:C3E4
Core:C3E4 ; --------------- S U B R O U T I N E
Core:C3E4
Core:C3E4
Core:C3E4 sub_C3E4: ; CODE XREF: sub_C3E4+1E j
Core:C3E4 ; calc_common_cs+B P
Core:C3E4 ldab $B,x ; младший байт будущей КС
Core:C3E6 andb #$AA ; 'к' ; выделяем только
Core:C3E6 ; нечетные байты
Core:C3E8 stab 3,x ; заготовка для XOR
Core:C3EA jsr Get_buf ; байт из буфера
Core:C3ED tab ; a = b - оба байты КС
Core:C3EE eorb 3,x ; XORим с заготовкой
Core:C3F0 clra ; старший байт = 0
Core:C3F1 addd $A,x ; + КС
Core:C3F3 std $A,x ; новая КС
Core:C3F5 iny ; адрес++
Core:C3F7 ldd 4,x
Core:C3F9 addd #1 ; счетчик ++
Core:C3FC std 4,x
Core:C3FE cpd #$1FF ; конец буфера?
Core:C402 ble sub_C3E4 ; нет - считаем КС дальше
Core:C404 rts
Core:C404 ; End of function sub_C3E4
Core:C404
Core:C405
Core:C405 ; --------------- S U B R O U T I N E
Core:C405
Core:C405 ; Сравнение вычисленной и полученной КС
Core:C405
Core:C405 Compare_CS: ; CODE XREF:
Core:C405 ; calc_common_cs+1B P
Core:C405 ldd $A,x ; вычисленная КС
Core:C407 cpd 8,x ; полученная КС
Core:C40A beq loc_C410 ; совпала
Core:C40C ldaa #$FF
Core:C40E bne locret_C411 ; не совпала
Core:C410
Core:C410 loc_C410: ; CODE XREF: Compare_CS+5 j
Core:C410 clra
Core:C411
Core:C411 locret_C411: ; CODE XREF: Compare_CS+9 j
Core:C411 rts
Core:C411 ; End of function Compare_CS
Core:C411
Core:C412
Core:C412 ; --------------- S U B R O U T I N E
Core:C412
Core:C412 ; Проверка КС блока полученного церта
Core:C412
Core:C412 Check_cert_buf_csum: ; CODE XREF:
Core:C412 pshy
Core:C414 xgdy
Core:C416 subd #$200 ; встаем на начало сектора
Core:C419 xgdy
Core:C41B jsr Calc_Cert_buf_CS ; считаем его сумму -> 0A,0B
Core:C41E ldab $B,x ; младший байт КС
Core:C420 andb #$AA ; 'к'
Core:C422 stab 3,x
Core:C424 ldab 6,x ; # блока
Core:C426 eorb 3,x
Core:C428 clra
Core:C429 addd $A,x ; добавляем и # блока к КС
Core:C42B std $A,x
Core:C42D jsr Compare_CS ; сравниваем КС
Core:C430 puly
Core:C432 rts
Core:C432 ; End of function Check_cert_buf_csum
По окончании заливки церт-модуля в память резидентная программа пытается
записать этот модуль в служебную зону. В случае проблем - форматирует ее
(пишет formatting CERT track) и еще раз пытается залить. Если не пишется -
возвращает код ошибки. |
