Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ
”ХАРКІВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ”
Розрахунково-графічне завдання №1
з курсу
"Мікропроцесорні системи"
Виконав:
ст. гр. xxxxxxx
xxxxxxxxxxxxx
Перевірив:
xxxxxxxxx
Харків 2006
Зміст
1. Індивідуальне завдання
2. Пояснення до змісту роботи
3. Опис програми
4. Текст програми
5. Результати роботи програми
6. Висновки
1. Індивідуальне завдання
Варіант 16
В захищеному режимі виконати наступні дії:
I. Викликати необхідне згідно із індивідуальним завданням виключення
II. Обробити задане виключення двома засобами:
а) прибравши причину виключення;
б) пропустивши команду, що визвала виключення.
III. Обробити задане зовнішнє переривання.
2. Пояснення до змісту роботи
Для виконання завдання необхідно виконати наступні дії:
1) розробити дескриптори усіх необхідних сегментів пам’яті і сформувати з них глобальну дескрипторну таблицю GDT.
2) за допомогою регістра GDTR задати базову адресу і розмір таблиці GDT;
3) розробити дескриптори усіх шлюзів, сформувати з них таблицю IDT.
4) за допомогою регістра IDTR задати базову адресу і розмір таблиці IDT;
5) сформувати дані для повернення в реальний режим;
6) заборонити масковані і немасковані переривання;
7) перевести мікропроцесор у захищений режим;
8) виконати в захищеному режимі дії, задані індивідуальним завданням;
9) повернутися в реальний режим;
10) дозволити масковані і немасковані переривання.
Для розуміння принципів програмування роботи в захищеному режимі необхідно розуміти його особливості. Захищений режим має такі особливості роботи з перериваннями (порівнюючи з реальним режимом):
1) вводиться новий тип переривань – виключення;
2) замість дальніх адрес в таблиці переривань використовуються дескриптори шлюзів;
3) таблиця переривань може знаходитися в будь-якому місці пам’яті.
Виключення поділяються на три типи:
- Помилка (trap);
- Пастка (fault);
- Аварія (abort).
Помилка – це виключення, що виникає в ситуації помилкових дій програми й припускається, що таку помилку можна виправити. Виконання програми продовжується починаючи із команди, при якій виникло виключення.
Пастка – це виключення, що виникає відразу після виконання команди. Виконання програми продовжується із наступної команди,що йде за командою на якій виникло виключення. На пастках строїться механізм відладки програм.
Аварія – це виключення, що не дозволяє продовжити виконання перерваної програми і сигналізує про серйозні порушення цілісності системи.
3. Опис програми
Для написання програми для виконання разрахункового завдання, скористались модулем PROT і програмою P_INT, що поставляються разом із індивідуальним завданням. В модулі PROT містяться основні необхідні константи і функції для створення власних таблиць GDT та IDT, для переходу в захищений режим, містяться також заглушки для всіх апаратних і програмних переривань. Програма P_INT містить перевизначення необхідних для роботи, або заданих за індивідуальним завданням переривань, в ній задається вміст таблиць GDT та IDT (в ній визначаються селектори заглушок, або необхідних переривань, на необхідних місцях), програма реалізує перехід в захищений режим, імітує виникнення програмного переривання, а також реалізує вічний цикл, до виникнення апаратного переривання. Після цього реалізується вихід до реального режиму, шляхом скидання мікропроцесору (не працює на нових моделях мікропроцесорів) або шляхом відновлення старої GDT та IDT, і повернення до реального режиму. Нами було додано необхідні по індивідуальному завданню апаратне і програмне переривання, і реалізовано виключну ситуацію для їх виникнення.
4. Текст програми
{----Модуль содержит константы, типы переменных, переменные,----}
{------процедуры и функции для работы в защищенном режиме-------}
unit prot;
interface
uses crt;
const
hex_tabl:array[0..15] of char='0123456789ABCDEF';
s2:string='Run time error: исключение ';
{--------------Селекторы дескрипторов сегментов---------------}
code_sel =$08; { кода программы, }
code_sel2 =$10; { кода модуля PROT, }
data_sel :word =$18; { данных, }
stack_sel :word =$20; { стека, }
video_sel :word =$28; { видеопамяти, }
mem_sel :word =$30; { расширенной памяти, }
{-----------------Биты байтов доступа сегментов---------------}
present =$80; { P=1 : сегмент есть в памяти }
nosys =$10; { S=1 : сегмент несистемный }
exe =$08; { E=1 : сегмент выполняемый }
down =$04; { ED=1: сегмент расширяется вниз }
wr_ena =$02; { W=1 : разрешена запись в сегмент }
rd_ena =$02; { R=1 : разрешено чтение из сегмента }
{---------Значения поля TYPE системных дескрипторов-----------}
type_int =$06; { шлюза прерывания для 80286 }
type_trap =$07; { шлюза исключения для 80286 }
type_TSS =$01; { сегмента TSS }
type_call =$04; { шлюза вызова }
type_task =$05; { шлюза задачи }
{-----------------Байт доступа сегмента кода------------------}
acc_code=present OR nosys OR exe OR rd_ena;
acc_code1=present OR nosys OR exe ;
{----------------Байт доступа сегмента данных-----------------}
acc_data=present OR nosys OR wr_ena;
{----------------Байт доступа сегмента стека -----------------}
acc_stack=present OR nosys OR wr_ena OR down;
{-----------------Байт доступа шлюза задачи-------------------}
acc_task =present OR type_task;
type
{-------------Структура дескриптора таблицы GDT---------------}
t_gdt=record
lim_l, { граница сегмента (биты 15-0) }
base_l :word; { базовый адрес сегм. (биты 15-0) }
base_h, { базовый адрес сегм. (биты 23-16) }
acc, { байт доступа }
lim_h, { G,D,0,X,граница сегм. (биты 19-16) }
base_hh:byte { базовый адрес сегм. (биты 31-24) }
end;
{-------------Структура дескриптора таблицы IDT---------------}
t_idt=record
off_l, { смещение (биты 15-0) }
sel :word; { селектор }
par, { число параметров }
acc :byte; { байт доступа }
off_h :word { смещение (биты 31-16) }
end;
{---------------Структура регистров GDTR и IDTR---------------}
t_dtr=record
lim :word; { граница и }
base :longint; { базовый адрес таблицы }
end;
{-----------------Структура TSS для МП 80286------------------}
t_tss_286=record
link, { селектор возврата }
sp0,ss0, { указатель стека кольца 0 }
sp1,ss1, { указатель стека кольца 1 }
sp2,ss2, { указатель стека кольца 2 }
ip,flags,ax,cx,dx,bx,sp,bp, { регистры }
si,di,es,cs,ss,ds,ldtr { микропроцессора }
:word;
end;
{--------------Структура TSS для МП 80386 и выше--------------}
t_tss_386=record
link, { селектор возврата }
esp0,ss0, { указатель стека кольца 0 }
esp1,ss1, { указатель стека кольца 1 }
esp2,ss2, { указатель стека кольца 2 }
cr3,eip,eflags,eax,ecx,edx,ebx, { регистры }
esp,ebp,esi,edi,es,cs,ss,ds,fs,gs,ldtr{ МП }
:longint;
bit_t, { бит ловушки задачи }
adr_BKVV:word; { смещение БКВВ }
Sys_inf, { поле для системной информации }
BKVV:longint; { БКВВ }
byte_end:byte; { байт завершения TSS }
end;
var
gdt:array[0..15] of t_gdt; { Таблица GDT }
idt:array[0..$32] of t_idt; { Таблица IDT }
gdtr, { Содержимое GDTR }
idtr, { Содержимое IDTR для работы в защищенном режиме }
idtr_r { Содержимое IDTR для работы в реальном режиме }
:t_dtr;
ofs_ret, { Смещение и }
sel_ret, { селектор точки возврата в реальный режим }
ofs_ret_mov, { Смещение метки ret_mov: }
cs_prot, { Селектор регистра CS в защищенном режиме }
cs1, { Значение сегмента кода модуля PROT }
{ Переменные для хранения значений регистров: }
real_ss, { SS, }
real_es, { ES и }
real_sp:word; { SP }
scan, { Скан-код нажатия клавиши }
cpu_type, { Номер типа микропроцессора }
res, { Признак сброса МП }
rm1, { Содержимое регистров маски 1-го }
rm2, { и 2-го контроллеров прерывания }
excep, { Номер исключения }
acc_int, { Байт доступа прерывания }
acc_trap, { Байт доступа ловушки }
t:byte; { Признак разрядности МП: T=0 - 16; T=8 - 32 }
function lin_adr(seg,off:word):longint;
function hex(p:longint):string;
function hw(p:word):string;
procedure init_gdt(i:byte;limit,base:longint;acces,
procedure init_idt(i:byte;p_off,p_sel:word;acces:byte);
procedure pic(mode:byte);
procedure init_gdtr;
procedure init_idtr_p;
procedure init_idtr_r;
procedure save_ret_real(seg,ofs:word;byte_shut:byte);
procedure not_int;
procedure en_int;
procedure set_unr(base,limit:longint;kseg,byte_6h:byte);
procedure save_sreg;
procedure reset;
procedure test_wr;
procedure init_tss_286 (var tss:t_tss_286; cs,ds,es,
ofs_task,ofs_task_stack,flags:word);
procedure init_tss_386 (var tss:t_tss_386; cs,ds,es,
ofs_task,ofs_task_stack,eflags:word);
procedure get_cpu_type(inf:byte;var cpu:byte);
procedure exc_00;
procedure exc_01;
procedure exc_02;
procedure exc_03;
procedure exc_04;
procedure exc_05;
procedure exc_06;
procedure exc_07;
procedure exc_08;
procedure exc_10;
procedure exc_11;
procedure exc_12;
procedure exc_13;
procedure exc_14;
procedure exc_16;
procedure exc_17;
procedure exc_18;
procedure PIC_1;
procedure PIC_2;
procedure keyb;
procedure int_30h;
procedure int_30hr;
procedure int_32h;
implementation
{------Преобразование логического адреса в линейный адрес-----}
function lin_adr;
begin
lin_adr:=longint(seg) shl 4+off
end;{lin_adr}
{-------------Преобразование данных в 16-ричную форму---------}
function hex(p:longint):string;
var s:string;
begin
s:='h';
repeat
s:=hex_tabl[p and $f]+s;
p:=p shr 4
until p=0;
hex:=s
end;{hex}
function hw(p:word):string;
var
i:byte;
s:string;
begin
s:='';
for i:=0 to 3 do begin
s:=hex_tabl[p and $f]+s;
p:=p shr 4
end;
hw:=s
end;{hw}
{------------Формирование дескриптора таблицы GDT-------------}
procedure init_gdt(i:byte;limit,base:longint;acces,
byte_6h:byte);
begin
with gdt[i] do begin
lim_l :=limit;
base_l :=base;
base_h :=base shr 16;
acc :=acces;
lim_h :=limit shr 16 or byte_6h;
base_hh:=base shr 24;
end
end; {init_gdt}
{------Формирование данных регистра GDTR и его загрузка-------}
procedure init_gdtr;
begin
gdtr.lim:=sizeof(gdt)-1;
gdtr.base:=lin_adr(seg(gdt),ofs(gdt));
asm
db 0fh,01h,16h { LGDT gdtr: }
dw gdtr { загрузка атрибутов GDT в GDTR из gdtr }
end
end; {init_gdtr}
{------------Формирование дескриптора таблицы IDT-------------}
procedure init_idt(i:byte;p_off,p_sel:word;acces:byte);
begin
with idt[i] do begin
off_l:=p_off;
sel:=p_sel;
par:=0;
acc:=acces;
off_h:=0
end
end; {init_idt}
{--------Сохрание и формирование данных регистра IDTR---------}
{--------и его загрузка для работы в защищенном режиме--------}
procedure init_idtr_p;
begin
asm
db 0fh,1,0eh { SIDT idtr: }
dw idtr_r { Сохранение атрибутов IDT в idtr_r }
end;
idtr.lim:=sizeof(idt)-1;
idtr.base:=lin_adr(seg(idt),ofs(idt));
asm
db 0fh,01h,1eh { LIDT idtr: }
dw idtr { Загрузка атрибутов IDT в IDTR из idtr }
end;
end;{init_idtr_p}
{------Формирование данных регистра IDTR и его загрузка-------}
{----------------для работы в реальном режиме-----------------}
procedure init_idtr_r;
begin
idtr_r.lim:=$3ff; { размер таблицы векторов, }
idtr_r.base:=0; { базовый адрес таблицы векторов }
end;{init_idtr_r}
{-------------Формирование данных для возврата----------------}
{-------------в реальлный режим после сброса МП---------------}
procedure save_ret_real;
begin
{-------------Сохранение значений регистров маски-------------}
{-------------1-го и 2-го контроллеров прерываний-------------}
rm1:=port[$21];
rm2:=port[$a1];
{---------Занесение в ячейки 40h:67h и 40h:69h адреса---------}
{------(смещение и сегмент) точки возврата в реальный режим---}
{-------------------после сброса МП---------------------------}
memw[$40:$67]:=ofs;
memw[$40:$69]:=seg;
{--------Занесение в ячейку КМОП памяти с адресом 0Fh---------}
{-----------байта состояния отключения (byte_shut).-----------}
{-------Значение Ah этого байта обеспечивает при сбросе МП----}
{---------переход по адресу в ячейках 40h:67h и 40h:69h;------}
{----код 5 помимо этого осуществляет также инициализацию------}
{----------------контроллеров прерываний----------------------}
port[$70]:=$0f;
port[$71]:=byte_shut;
end;{save_ret_real}
{----------------Запрет аппаратных прерываний-----------------}
procedure not_int;
begin
asm cli end; { маскируемых }
port[$70]:=$80; { и немаскируемых }
end; {not_int}
{---------------Разрешение аппаратных прерываний--------------}
procedure en_int;
begin
asm sti end; { маскируемых }
port[$70]:=$d; { и немаскируемых }
mem[$40:$17]:=0 { Сброс состояния клавиш-переключателей }
end; {en_int}
{------------------Установка режима "Unreal"------------------}
procedure set_unr(base,limit:longint;kseg,byte_6h:byte);
begin
{ Формирование таблицы GDT: }
init_gdt(0,0,0,0,0); { нуль-дескриптор }
init_gdt(1,limit,base,$92,$80); { дескриптор сегмента }
init_gdtr; { Создание данных и загрузка регистра GDTR }
not_int;{ Запрет маскируемых и немаскируемых прерываний }
asm { Переход в защищенный режим: }
db $0f,$20,0c0h { MOV EAX,CR0 }
db 66h,0dh { OR EAX,1 }
dd 1h
db $0f,22h,0c0h { MOV CR0,EAX }
{ Загрузка селектора заданного сегмента (kseg): }
mov ax,8
cmp kseg,0
jnz @3
db 8eh,0c0h { MOV ES,AX }
jmp @k
@3: cmp kseg,3
db 8eh,0d8h { MOV DS,AX }
jmp @k
@4: cmp kseg,4
jnz @5
db 8eh,0e0h { MOV FS,AX }
jmp @k
@5:db 8eh,0e8h { MOV GS,AX }
{ Возврат в реальный режим: }
@k:db 0fh,20h,0c0h { MOV EAX,CR0 }
db 66h,25h { AND EAX,FFFFFFFEh }
dd 0fffffffeh
db 0fh,22h,0c0h { MOV CR0,EAX }
end;
en_int
end;
{------------Программирование ведущего и ведомого-------------}
{-------------контроллеров прерываний для работы-------------}
{------в реальном (mode=0) и защищенном (mode=1) режимах------}
procedure pic(mode:byte);
var k1,k2:byte;
begin
if mode=0 then begin
k1:=8; k2:=$70
end else begin
k1:=$20; k2:=$28
end;
port[$20]:=$11; { 1-й ПКП: ICW1 }
port[$21]:=k1; { 1-й ПКП: ICW2 }
port[$21]:=4; { 1-й ПКП: ICW3 }
port[$21]:=1; { 1-й ПКП: ICW4 }
port[$a0]:=$11; { 2-й ПКП: ICW1 }
port[$a1]:=k2; { 2-й ПКП: ICW2 }
port[$a1]:=2; { 2-й ПКП: ICW3 }
port[$a1]:=1; { 2-й ПКП: ICW4 }
end;{pic}
{----------Сохранение значений сегментных регистров-----------}
procedure save_sreg;
begin
memw[0:4*$60]:=Dseg; { DS, }
real_ss:=Sseg; { SS и }
asm mov real_es,es end { ES }
end;{save_sreg}
{-------------Возврат в реальный режим по команде-------------}
{--------контроллера клавиатуры, выполняющей сброс МП---------}
procedure reset;assembler;
asm
mov res,1 { Установка признака сброса МП }
mov al,0feh { Команда сброса }
out 64h,al { микропроцессора }
@wait_res: { Ожидание во время сброса МП }
hlt
jmp @wait_res
db 0cbh { Межсегментный возврат }
end; {reset}
{---Проверка сохранения запрета записи в сегмент кода после---}
{------возврата МП из защищенного режима по команде MOV:------}
{-----если запрет сохранен - вырабатывается прерывание 13,----}
{-----обработчик которого (процедура reset) сбрасывает МП-----}
procedure test_wr;
begin
Meml[0:13*4]:=Longint(@reset); { Занесение адреса }
{ обработчика прерывания 13 - процедуры reset }
{ в область векторов }
asm
(* db 2eh { CS: }*)
mov ax,cs:[0]
(* db 2eh *)
mov cs:[0],ax { Запись в сегмент кода }
end;
pic(0); { Программирование ПКП для реального режима }
end; {test_wr}
{-----------------Формирование TSS для 80286------------------}
procedure init_tss_286 (var tss:t_tss_286; cs,ds,es,
ofs_task,ofs_task_stack,flags:word);
begin
tss.cs:=cs;
tss.ds:=ds;
tss.es:=es;
tss.ss:=ds;
tss.ip:=ofs_task;
tss.bp:=ofs_task_stack;
tss.sp:=ofs_task_stack;
tss.ldtr:=0;
tss.flags:=flags;
end;{init_tss_286}
{--------------Формирование TSS для 80386 и выше--------------}
procedure init_tss_386(var tss:t_tss_386; cs,ds,es,
ofs_task,ofs_task_stack,eflags:word);
begin
tss.cs:=cs;
tss.ds:=ds;
tss.es:=es;
tss.ss:=ds;
tss.eip:=ofs_task;
tss.ebp:=ofs_task_stack;
tss.esp:=ofs_task_stack;
tss.ldtr:=0;
tss.eflags:=eflags;
tss.bit_t:=0;
tss.adr_bkvv:=108;
tss.BKVV:=0;
tss.byte_end:=$ff
end;{init_tss_386}
{---------Определение типа микропроцессора (cpu_type)---------}
procedure get_cpu_type(inf:byte;var cpu:byte);
var
data_cach:array[1..4,1..4] of byte; { Данные о кэше МП }
max_inp, { Max значение вх. параметра команды CPUID }
EBX_, { Брэнд ID и др. }
feature, { Данные об особенностях МП (регiстр EDX) }
ECX_:longint; { Данные об особенностях МП (регiстр ECX) }
desc_L2:word; { Дескриптор кэша L2 }
{ Серийный номер микропроцессора: }
sn_1, { младшие 32 разряда, }
sn_2, { средние 32 разряда, }
sn_3:longint; { старшие 32 разряда }
vend:array[1..12] of char;{ Название фирмы-изготовителя }
brand_str:array[1..48] of char; { Брэнд-строка }
typ, { Тип МП (0-2) }
model, { Модель МП (4-6) }
i,j,
id_flag, { Флаг исполнения МП команды CPUID }
cpu_type, { Возвращаемый номер типа МП (0, 2-6) }
brand, { Брэнд ID }
CLFSH, { Длина строки кэша }
NMP, { Число логических процессоров в кристалле }
par:byte; { Число параметров команды CPUID }
unknown:boolean; { Признак нераспознавания типа МП }
s:string;
begin
unknown:=false;
id_flag:=0;
asm
pushf { Сохранить FLAGS }
@8086: { Проверка МП i8086: }
{ биты 12-15 регистра FLAGS всегда установлены }
pushf
pop ax
mov cx,ax
and ax,0fffh
push ax
popf
pushf
pop ax
and ax,0f000h
cmp ax,0f000h
mov cpu_type,0 { Микропроцессор: 8086 }
jne @80286
@80286: { Проверка МП i80286: }
{ биты 12-15 регистра FLAGS в реальном режиме всегда сброшены }
or cx,0f000h
push cx
popf
pushf
pop ax
and ax,0f000h
mov cpu_type,2 { Микропроцессор: 80286 }
jnz @80386
jmp @end_cpuid
@80386: { Проверка МП i80386: }
{ флаг AC (бит 18) регистра EFLAGS не может быть установлен }
db 66h { префикс разрядности: 32 разряда }
pushf
db 66h
pop ax { Занести в EAX исходное значение EFLAGS }
db 66h
mov cx,ax { Сохранить исходное значение EFLAGS в ECX }
db 66h,35h { Изменить командой XOR бит AC в EFLAGS }
dd 040000h
db 66h
push ax { Сохранить новое значение EFLAGS в стеке }
db 66h
popf { Заменить текущее значение EFLAGS }
db 66h
pushf
db 66h
pop ax { Запомнить новое значение EFLAGS в EAX }
db 66h
xor ax,cx
mov cpu_type,3
jz @end_cpuid { Если бит AC не меняется: }
db 66h { микропроцессор: 80386 }
push cx
db 66h
popf { Восстановить AC бит в EFLAGS }
@80486: { Проверка МП i486 и последующих моделей: }
{ установка/сброс ID флага (бит 21) в EFLAGS }
{ указывает на выполнимость команды CPUID на данном МП }
mov cpu_type,4 { Микропроцессор: i486 }
db 66h
mov ax,cx { Получить исходное значение EFLAGS }
db 66h,35h { Изменить командой XOR бит ID в EFLAGS }
dd 200000h
db 66h
push ax { Сохранить новое значение в стеке }
db 66h
popf { Занести новое значение в EFLAGS }
db 66h
pushf { Записать его в стек }
db 66h
pop ax { Переписать в EAX }
popf { Восстановить EFLAGS }
db 66h
xor ax,cx { Если бит ID не меняется: }
je @end_cpuid { МП не поддерживает команду CPUID }
{ Выполнение команды CPUID для определения }
{ фирмы, семейства, модели микропроцессора }
mov id_flag,1 { Установка флага }
{ выполнения МП команды CPUID }
db 66h
xor ax,ax { Параметр для CPUID: EAX=0 }
db 0fh,0a2h { Команда CPUID }
db 66h
mov ss:[bp+offset vend],bx { Из регистров EBX, }
db 66h { EDX }
mov ss:[bp+offset vend+4],dx { и ECX }
db 66h { в переменную vend }
mov ss:[bp+offset vend+8],cx { заносится имя фирмы }
cmp al,1 { В AL - наибольшее значение параметра CPUID }
jl @end_cpuid
mov par,al
db 66h
xor ax,ax
db 66h
inc ax { Установка параметра CPUID =1 }
db 0fh,0a2h { Команда CPUID: в AL - сигнатура МП }
db 66h { В sn_3 - старшие 32 разряда }
mov word ptr sn_3,ax { серийного номера МП }
mov word ptr EBX_,bx { В EBX_- Brand ID и др. }
db 66h
mov word ptr ECX_,cx { В EСX_- особенности МП }
db 66h
mov word ptr feature,dx { В EDX_- особенности МП }
mov cx,ax
and ax,0f0h
db 0c1h,0e8h,4 { Сдвиг в AX на 4 разряда вправо }
mov model, al { В AL - модель МП }
mov ax,cx
and ax,0f00h
db 0c1h,0e8h,8 { Сдвиг в AX на 8 разрядов вправо }
mov cpu_type, al { В AL - номер семейства МП }
mov ax,cx
and ax,3000h
db 0c1h,0e8h,12 { Сдвиг в AX на 12 разрядов вправо }
mov typ, al { В AL - номер типа МП }
db 66h
mov word ptr feature,dx { В feature - особенности МП }
cmp par,1
jz @end_cpuid
db 66h,0b8h { MOV EAX,2: установка параметра }
dd 2 { команды CPUID =2 }
db 0fh,0a2h { Команда CPUID }
db 66h
mov ss:[bp+offset data_cach],ax { В регистрах EAX, }
db 66h { EBX, ECX }
mov ss:[bp+offset data_cach+4],bx { и EDX - }
db 66h { информация о }
mov ss:[bp+offset data_cach+8],cx { кэш-памяти МП, }
db 66h { которая заносится в массив }
mov ss:[bp+offset data_cach+12],dx { data_cach }
@end_cpuid:
end;
s:='';
clrscr;
if id_flag=0 then begin { Определение типа МП }
case cpu_type of { без использования команды CPUID }
0:s:='i8086';
2:s:='i80286';
3:s:='i80386';
4:s:='i486';
end;
writeln(s);
end else begin
brand:=EBX_; { Значение брэнд ID }
for i:=1 to 4 do { Определение дескриптора }
for j:=1 to 4 do { кэша второго уровня }
if data_cach[i,4] and 128=0 then
if (data_cach[i,j]=$41) or
(data_cach[i,j]=$42) or
(data_cach[i,j]=$43) or
(data_cach[i,j]=$44) or
(data_cach[i,j]=$45) then begin
desc_L2:=data_cach[i,j];
break
end;
case cpu_type of
4:case model of
0,1:s:='i486 DX';
2:s:='i486 SX';
3:s:='iDX2';
4:s:='i486 SL';
5:s:='iSX2';
7:s:='iDX2 WB';
8:if typ=0 then s:='iiDX4'
else s:='iDX4 OverDrive';
9:s:='AMD DX4';
14:s:='Am5x86 в режиме WT';
15:s:='Am5x86 в режиме WB';
else unknown:=true
end;
5: if vend='GenuineIntel' then
case model of
1:if typ=0 then s:='Pentium (60,66)'
else s:='Pentium OverDrive (60,66)';
2:if typ=0 then
s:='Pentium (75..200)'
else s:='Pentium OverDrive (75..133)';
3:s:='Pentium OverDrive для 486';
4:if typ=0 then s:='Pentium MMX (166,200)'
else s:='Pentium MMX OverDrive (75..133)';
end else if vend='AuthenticAMD' then
case model of
0:s:='AMD-K-PR75,90,100';
1:s:='AMD-K-PR120,133';
2:s:='AMD-K-PR120,166';
end;
6: case model of
1:s:='Pentium Pro';
3:if typ=0 then s:='Pentium II модель 3'
else s:='Pentium II OverDrive';
5:case desc_L2 of
$41:s:='Celeron модель 5';
$43:s:='Pentium II модель 5';
$44:s:='Pentium II Xeon модель 5';
end;
6:s:='Celeron модель 6';
7:case desc_L2 of
$43: s:='Pentium III модель 7';
$44,$45:s:='Pentium III Xeon модель 7';
end;
8:case brand of
1:s:='Celeron модель 8';
2:s:='Pentium III модель 8';
3: if sn_3=$6B1 then s:='Celeron модель 8'
else s:='Pentium III Xeon модель 8';
4: s:='Pentium III модель 8';
6: s:='Мобильный Pentium III-M модель 8';
7: s:='Мобильный Celeron модель 8';
end;
$A:s:='Pentium III Xeon модель A';
$B:s:='Pentium III Xeon модель B';
else unknown:=true
end;
$F:case model of
0: begin
s:='0.18-микронный ';
case brand of
8: s:=s+'Pentium 4';
9: s:=s+'Pentium 4';
$B: s:=s+'Xeon';
end;
end;
1: begin
s:='0.18-микронный ';
case brand of
8: s :=s+'Pentium 4';
9: s:=s+'Pentium 4';
$A: s:=s+'Celeron';
$B: if sn_3<$F13 then s:=s+'Xeon MP'
else s:=s+'Xeon';
$C: s:=s+'Xeon MP';
$E: s:=s+'Xeon';
end;
end;
2: begin
s:='0.13-микронный ';
case brand of
8: s:=s+'Pentium 4';
9: s:=s+'Pentium 4';
$A: s:=s+'Celeron';
$B: if sn_3<$F13 then s:=s+'Xeon MP'
else s:=s+'Xeon';
$C: s:=s+'Xeon MP';
$E: if sn_3<$F13 then s:=s+'Xeon'
else s:=s+'мобильный Pentium 4-M';
$F: s:=s+'мобильный Celeron';
end
end
end {else unknown:=true}
end;
for i:=1 to 12 do write(vend[i]);
if not unknown then writeln(' ',s)
else writeln('МП сiмейства - ',cpu_type, ' модель - ',model);
asm
db 66h,0b8h
dd 80000000h { MOV EAX,80000000h }
db 0fh,0a2h { CPUID }
db 66h
mov word ptr max_inp,ax
end;
if max_inp>$80000000 then begin
asm
db 66h,0b8h { MOV EAX,80000002h }
dd 80000002h
db 0fh,0a2h { CPUID }
db 66h
mov ss:[bp+offset brand_str],ax { Из pегистpов EAX, }
db 66h
mov ss:[bp+offset brand_str+4],bx { EBX, }
db 66h
mov ss:[bp+offset brand_str+8],cx { ECX }
db 66h
mov ss:[bp+offset brand_str+12],dx { и EDX }
{в переменную brand_str заносятся первые 12 символов бренд-строки}
db 66h,0b8h
dd 80000003h { MOV EAX,80000003h }
db 0fh,0a2h { CPUID }
db 66h
mov ss:[bp+offset brand_str+16],ax
db 66h
mov ss:[bp+offset brand_str+20],bx
db 66h
mov ss:[bp+offset brand_str+24],cx
db 66h
mov ss:[bp+offset brand_str+28],dx
db 66h,0b8h { MOV EAX,80000004h }
dd 80000004h
db 0fh,0a2h { CPUID }
db 66h
mov ss:[bp+offset brand_str+32],ax
db 66h
mov ss:[bp+offset brand_str+36],bx
db 66h
mov ss:[bp+offset brand_str+40],cx
db 66h
mov ss:[bp+offset brand_str+44],dx
end;
for i:=1 to 48 do write(brand_str[i]);
writeln;
end;
if inf<>0 then begin
writeln('Особенности микропроцессора:');
for i:=0 to 21 do
if not ((i=10) or (i=20) or (i=28)) then begin
s:='';
case i of
0:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'содержит FPU';
end;
1:begin
if (feature shr i) and 1=0 then s:='не ';
s:='поддерживает расширения для режима ';
s:=s+'виртуального 8086';
end;
2:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает рассширенную отладку и CR4.DE';
end;
3:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает страницы 4 МБ';
end;
4:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команду RDTSC и CR4.TSD';
end;
5:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды RDMSR и WRMSR';
end;
6:begin
if (feature shr i) and 1=0 then s:='не ';
s:='поддерживает расширение физического адреса';
s:=s+' и CR4.PAE';
end;
7:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает исключение 18 (MCE) и CR4.MCE';
end;
8:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команду CMPXCHG8B';
end;
9:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'содержит APIC';
end;
11:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды SYSENTER и SYSEXIT';
end;
12:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает регистры MTRR';
end;
13:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает глобальные страницы и CR4.PGE';
end;
14:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает MCA и регистр MCG_CAP';
end;
15:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды CMOV, FCMOV и FCOMI';
end;
16:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает таблицу атрибутов страниц PAT';
end;
17:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+ 'поддерживает 4 Мб страницы и адреса более 4 Гб';
end;
18:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает 96-разрядный серийный номер МП';
end;
19:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команду CLFLUSH';
end;
21:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает запись истории переходов';
end;
end;
writeln(' ',s);
end;
readkey;
clrscr;
writeln('Особенности микропроцессора:');
for i:=22 to 31 do
if i<>30 then begin
s:='';
case i of
22:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает программный контроль частоты МП';
end;
23:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает MMX команды';
end;
24:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды FXSAVE и FXRSTOR';
end;
25:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды SSE';
end;
26:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает команды SSE2';
end;
27:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает разрешение конфликтов памятi';
end;
28:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+' поддерживает логические процессоры и HT';
end;
29:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'поддерживает температурный мониторинг';
end;
31:begin
if (feature shr i) and 1=0 then s:='не ';
s:=s+'пiдтримує переривання по FERR';
end;
end;
writeln(' ',s);
end;
readkey; clrscr;
if par>1 then begin
writeln('Число повторений команды CPUID с EAX=2 - ',
data_cach[1,1]);
writeln('МП имеет следующие блоки кэш-памяти:');
writeln;
for i:=1 to 4 do
for j:=1 to 4 do
if (i<>1) or (j<>1) then
if data_cach[i,4] and 128=0 then begin
s:='';
if data_cach[i,j]<>0 then begin
case data_cach[i,j] of
1:s:='TLB команд: 4 Кб страницы, 4-напр., 32 входа';
2:s:='TLB команд: 4 Мб стран., полностью ассоц., 2 входа';
3:s:='TLB данных: 4 Кб страницы, 4-напр., 64 входа';
4:s:='TLB данных: 4 Мб страницы, 4-напр., 8 входов';
6:s:='Кэш команд: 8 Кб, 4-напр., строка 32 байта';
8:s:='Кэш команд: 16 Кб, 4-напр., строка 32 байта';
$A:s:='Кэш данных: 8 Кб, 2-напр., строка 32 байта';
$C:s:='Кэш данных: 16 Кб, 4-напр., строка 32 байта';
$22:s:=' Объедин. кэш L3: 512 Кб, 4-напр., строка 64 байта';
$23:s:=' Объедин. кэш L3: 1 Мб, 8-напр., строка 64 байта';
$25:s:=' Объедин. кэш L3: 2 Мб, 8-напр., строка 64 байта';
$29:s:=' Объедин. кэш L3: 4 Мб, 8-напр., строка 64 байта';
$39:s:='Объедин. кэш L2: 128 Кб, 4-напр., строка 64 байта';
$3B:s:='Объедин. кэш L2: 128 Кб, 2-напр., строка 64 байта';
$3C:s:='Объедин. кэш L2: 256 Кб, 4-напр., строка 64 байта';
$40:if cpu_type=6 then s:='Кэш L2: не содержится'
else if cpu_type=$f then s:='Кэш L3: не содержится';
$40:s:='Нет кэша L2 (семейство P6) или L3 (Pentium 4)';
$41:s:='Объедин. кэш: 128 Кб, 4-напр., строка 32 байта';
$42:s:='Объедин. кэш: 256 Кб, 4-напр., строка 32 байта';
$43:s:='Объедин. кэш: 512 Кб, 4-напр., строка 32 байта';
$44:s:='Объедин. кэш: 1 Мб, 4-напр., строка 32 байта';
$45:s:='Объедин. кэш: 2 Мб, 4-напр., строка 32 байта';
$50:begin
s:='TLB команд: 4 Кб,2 Мб или 4 Мб страницы,';
s:=s+'полностью ассоц., 64 входа';
end;
$51:begin
s:='TLB команд: 4 Кб, 2 Мб або 4 Мб страницы,';
s:=s+'полностью ассоц., 128 входов';
end;
$52:begin
s:='TLB команд: 4 Кб, 2 Мб або 4 Мб страницы,';
s:=s+'полностью ассоц., 256 входов';
end;
$5b:begin
s:='TLB данных: 4 Кб или 4 Мб страницы.,';
s:=s+'полностью ассоц., 64 входа';
end;
$5C:begin
s:='TLB команд: 4 Кб або 4 Мб страницы.,';
s:=s+'полностью ассоц., 128 входов';
end;
$5D:begin
s:='TLB команд: 4 Кб або 4 Мб страницы.,';
s:=s+'полностью ассоц., 256 входов';
end;
$66:s:='Кэш данных секторный:8 Кб, 4-напр., строка 64 байта';
$67:s:='Кэш данных секторный: 16 Кб, 4-напр., строка 64 байти';
$68:s:='Кэш данных секторный: 32 Кб, 4-напр., строка 64 байти';
$70:s:='Кэш трас команд: 12 К микроинструкций, 4-напр.';
$71:s:='Кэш трас команд: 16 К микроинструкций, 8-напр. ';
$72:s:='Кэш трас команд: 32 К микроинструкций, 8-напр. ';
$79:begin
s:='Объедин. кэш секторный: 128 Кб, 8-напр.,';
s:=s+' строка 64 байта'
end;
$7A:begin
s:='Объедин. кэш секторный: 256 Кб, 8-напр.,';
s:=s+' строка 64 байта'
end;
$7B:begin
s:='Объедин. кэш секторный: 512 Кб, 8-напр.,';
s:=s+' строка 64 байта'
end;
$7C:begin
s:='Объедин. кэш секторный: 1 Мб, 8-напр.,';
s:=s+' строка 64 байта'
end;
$82:s:='Объедин. кэш: 256 Кб, 8-напр., строка 32 байта';
$83:s:='Объедин. кэш: 512 Кб, 8-напр., рядок 32 байти';
$84:s:='Объедин. кэш: 1 Мб, 8-напр., строка 32 байта';
$85:s:='Объедин. кэш: 2 Мб, 8-напр., строка 32 байта';
else begin
write(' Дескриптор: ',hex(data_cach[i,j]));
s:=''
end
end;
writeln(' ',s);
end
end
end;
if (feature shr 18) and 1<>0 then begin
asm
db 66h,0b8h { MOV EAX,3 }
dd 3 { CPUID с параметром 3: определение }
db 0fh,0a2h { серийного номера микропроцессора }
db 66h { В sn_2 - средние 32 разряда }
mov word ptr sn_2,dx { серийного номера МП }
db 66h { В sn_1 - младшие 32 разряда }
mov word ptr sn_1,cx { серийного номера МП }
end;
writeln('Серийный номер микропроцессора: ',
hw(sn_3 shr 16),'-',hw(word(sn_3)),'-',
hw(sn_2 shr 16),'-',hw(word(sn_2)),'-',
hw(sn_1 shr 16),'-',hw(word(sn_1)));
end;
end
end;
asm { Возврат значения параметра cpu: }
mov bx,ss:[bp+offset cpu] { В BX - адрес cpu }
mov al,cpu_type
mov [bx],al
end;
end; {get_cpu_type}
{--------Обработчики исключений 0-18 (exc_00-exc_18)----------}
{------------выводят на экран номер исключения----------------}
{--------и осуществляют переход в реальный режим:-------------}
procedure exc_00;assembler; { Обработчик исключения 0: }
asm { деление на 0 }
mov excep,0
int 32h { Вывод номера исключения }
cmp cpu_type,2
jz @1
db 0ffh,2eh { Межсегментный переход }
dw ofs_ret_mov { на метку ret_mov: }
@1:db 9ah { Межсегментный вызов }
dw offset reset { процедуры сброса МП reset }
dw code_sel2 { с переходом на метку ret_r }
end;
procedure exc_01;assembler; { Обработчик исключения 1: }
asm { - при TF=1 регистра EFLAGS; }
mov excep,1 { - при T=1 сегмента TSS; }
int 32h { - по контрольным точкам программы; }
cmp cpu_type,2 { - по контрольным точкам данных; }
jz @1 { - по контрольным точкам УВВ; }
db 0ffh,2eh { - при защите регистров отладки }
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_02;assembler; { Обработчик исключения 2: }
asm { немаскируемое прерывание (NMI) }
mov excep,2
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_03;assembler; { Обработчик исключения 3: }
asm { по команде INT 3 }
mov excep,3
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_04;assembler; { Обработчик исключения 4: }
asm { по команде INTO при OF=1 }
mov excep,4
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_05;assembler; { Обработчик исключения 5: }
asm { выход за пределы диапазона }
mov excep,5 { при выполнении команды BOUND }
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_06;assembler; { Обработчик исключения 6: }
asm { неверный код операции }
mov excep,6 { или адресации }
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_07;assembler; { Обработчик исключения 7: }
asm { недоступно устройство FPU }
mov excep,7
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_08;assembler; { Обработчик исключения 8: }
asm { двойная ошибка }
mov excep,8
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_10;assembler; { Обработчик исключения 10: }
asm { недоступен TSS }
mov excep,10
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_11;assembler; { Обработчик исключения 11: }
asm { недоступен сегмент }
mov excep,11
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_12;assembler; { Обработчик исключения 12: }
asm { ошибка доступа к сегменту стека }
mov excep,12
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_13;assembler; { Обработчик исключения 13: }
asm { нарушение общей защиты }
mov excep,13
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_14;assembler; { Обработчик исключения 14: }
asm { недоступна страница }
mov excep,14
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_16;assembler; { Обработчик исключения 16: }
asm { ошибка FPU при NE=1 регистра CR0 }
mov excep,16
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_17;assembler; { Обработчик исключения 17: }
asm { ошибка выравнивания данных }
mov excep,17
int 32h
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
procedure exc_18;assembler; { Обработчик исключения 18: }
asm { ошибка функционирования узлов МП и МПС }
mov excep,18
cmp cpu_type,2
jz @1
db 0ffh,2eh
dw ofs_ret_mov
@1:db 9ah
dw offset reset
dw code_sel2
end;
{---------Обработчики-заглушки аппаратных прерываний,---------}
{----------поступающих на 1-й контроллер прерываний-----------}
procedure PIC_1;assembler;
asm
push ax
mov al,$20
out $20,al { Сброс бита регистра ISR 1-го ПКП }
pop ax
cmp cpu_type,2 { Если 80286 - разрядность 16, }
je @7 { иначе - 32 }
db 66h
@7:iret
end;
{---------Обработчики-заглушки аппаратных прерываний,---------}
{----------поступающих на 2-й контроллер прерываний-----------}
procedure PIC_2;assembler;
asm
push ax
mov al,$20 { Сброс бита регистра ISR }
out $20,al { 1-го и }
out $a0,al { и 2-го контроллеров прерываний }
pop ax
cmp cpu_type,2
je @8
db 66h
@8:iret
end;
procedure keyb;assembler; { Обработчик прерываний }
asm { от клавиатуры: }
mov al,20h
out 20h,al
in al,60h { Чтение скан-кода нажатия/отжатия клавиши }
test al,$80
jnz @k1 { Переход, если клавиша отжата }
mov scan,al
@k1:cmp cpu_type,2
je @k2
db 66h
@k2:iret
end;
procedure int_30h;assembler; { Обработчик программного }
asm { прерывания 30h: }
cmp ah,2 { AH - номер функции }
jz @i2 { Al - номер подфункции }
cmp ah,3 { BL - номер строки экрана }
jz @i3 { BH - номер столбца экрана }
cmp ah,4 { DL/DX/EDX - значение данных }
jz @i4 { (байта/слова/двойного слова) }
cmp ah,5 { CL - видео-атрибут }
jz @i5 { SI - смещение строки символов }
{ Функция 1: установка маркера в заданную точку экрана }
mov ax,bx
xor bh,bh
mov bl,ah
xor ah,ah
mov dl,80
mul dl
add ax,bx
shl ax,1
mov di,ax
jmp @end
@i2: { Функция 2: вывод символа на экран }
mov al,dl
mov ah,cl
stosw
jmp @end
@i3: { Функция 3: вывод данных на экран в 16-ричной форме }
{ AL=0 - вывод байта }
{ AL=1 -вывод слова }
{ AL=2 - вывод двойного слова }
lea bx,hex_tabl
mov ah,cl
cmp al,0
jz @8
cmp al,1
jz @16
add di,14
mov cx,8
jmp @1
@8:add di,2
mov cx,2
jmp @1
@16:add di,6
mov cx,4
@1:push cx
@lp:mov al,dl
and al,0fh
db 66h
shr dx,4
xlat
stosw
sub di,4
loop @lp
pop cx
shl cx,1
add cx,4 {2}
add di,cx
jmp @end
@i4: { Функция 4: вывод строки символов на экран }
mov ah,cl
mov bx,si
inc si
mov cl,[bx]
xor ch,ch
@wxy:
lodsb
stosw
loop @wxy
jmp @end
@i5: { Функция 5: вывод данных на экран в двоичной форме }
{ AL=0 - вывод байта }{ AL=1 -вывод слова }
{ AL=2 - вывод двойного слова }
{ lea bx,duo_tabl}
mov ah,cl
cmp al,0
jz @8_2
cmp al,1
jz @16_2
mov cx,8
jmp @2
@8_2:
mov cx,2
jmp @2
@16_2:
mov cx,4
@2:push cx
push cx
shl cx,3
sub cx,2
add di,cx { di+cx*8-2 }
pop cx
@lp_1:push cx
xor ah,8
mov cx,4
@lp_2:mov al,dl
and al,01h
db 66h
shr dx,1
xlat
stosw
sub di,4
loop @lp_2
pop cx
loop @lp_1
pop cx
shl cx,3
add cx,2 { di+cx*8+2 }
add di,cx
@end:db 66h
iret
end;
procedure int_30hr;assembler; { Обработчик программного }
asm { прерывания 30h: }
cmp ah,2 { AH - номер функции }
jz @i2 { Al - номер подфункции }
cmp ah,3 { BL - номер строки экрана }
jz @i3 { BH - номер столбца экрана }
cmp ah,4 { DL/DX/EDX - значение данных }
jz @i4 { (байта/слова/двойного слова) }
cmp ah,5 { CL - видео-атрибут }
jz @i5 { SI - смещение строки символов }
{ Функция 1: установка маркера в заданную точку экрана }
mov ax,bx
xor bh,bh
mov bl,ah
xor ah,ah
mov dl,80
mul dl
add ax,bx
shl ax,1
mov di,ax
jmp @end
@i2: { Функция 2: вывод символа на экран }
mov al,dl
mov ah,cl
stosw
jmp @end
@i3: { Функция 3: вывод данных на экран в 16-ричной форме }
{ AL=0 - вывод байта } { AL=1 -вывод слова }
{ AL=2 - вывод двойного слова }
lea bx,hex_tabl
mov ah,cl
cmp al,0
jz @8
cmp al,1
jz @16
add di,14
mov cx,8
jmp @1
@8:add di,2
mov cx,2
jmp @1
@16:add di,6
mov cx,4
@1:push cx
@lp:mov al,dl
and al,0fh
db 66h
shr dx,4
xlat
stosw
sub di,4
loop @lp
pop cx
shl cx,1
add cx,4 {2}
add di,cx
jmp @end
@i4: { Функция 4: вывод строки символов на экран }
mov ah,cl
mov bx,si
inc si
mov cl,[bx]
xor ch,ch
@wxy:
lodsb
stosw
loop @wxy
jmp @end
@i5: { Функция 5: вывод данных на экран в двоичной форме }
{ AL=0 - вывод байта }
{ AL=1 -вывод слова }
{ AL=2 - вывод двойного слова }
{ lea bx,duo_tabl}
mov ah,cl
cmp al,0
jz @8_2
cmp al,1
jz @16_2
mov cx,8
jmp @2
@8_2:
mov cx,2
jmp @2
@16_2:
mov cx,4
@2:push cx
push cx
shl cx,3
sub cx,2
add di,cx { di+cx*8-2 }
pop cx
@lp_1:push cx
xor ah,8
mov cx,4
@lp_2:mov al,dl
and al,01h
db 66h
shr dx,1
xlat
stosw
sub di,4
loop @lp_2
pop cx
loop @lp_1
pop cx
shl cx,3
add cx,2 { di+cx*8+2 }
add di,cx
@end: iret
end;
{------------------Вывод номера исключения--------------------}
procedure int_32h;assembler;
asm
mov ah,1 { Функция 1: установка маркера на экране }
mov bl,22 { с координатами - строка 22, }
mov bh,1 { столбец 1 }
int 30h
mov ah,4 { Функция 4: вывод на экран }
mov si, offset s2 { строки символов s2 }
mov cl,1ah { видеоатрибут }
int 30h
mov ax,300h { Функция 3, подфункция 0: }
mov dl,excep { вывод на экран номера исключения }
mov cl,1ch { видеоатрибут }
int 30h
db 66h
iret
end;
end.
(*16. а) Исключение, вызванное запретом чтения из сегмента кода б) Разработать обработчик прерывания от системного таймера, который каждые 5 секунд меняет цвет бордюра.
I. Вызвать требуемое в индивидуальном задании исключение.
II. Обработать это исключение одним из двух способов:
а) устранив причину исключения;
б) пропустив команду, вызвавшую исключение.
III. Обработать заданное внешнее прерывание.*)
program p_intr;
{ Обработка прерываний в защищенном режиме }
uses crt, prot; { Модуль PROT содержит константы, }
{ типы переменных, переменные, процедуры и функции }
{ для работы в защищенном режиме }
label ret_r; { Точка возврата в реальный режим }
const
s:string='Обработка исключений и прерываний в защищенном режиме';
s1:string='CS SS DS ES CR0 EFLAGS: ';
s2:string='Обработано исключение ';
s3:string='Na 5 tik timera menyaem cvet BORDURA.';
s4:string='Press Esc to exit';
var
cs_real, { Значение регистра CS в реальном режиме }
err, { Код ошибки }
lim1,lim2,count:word;
scan,i,al_,ah_,n_exc,row:byte;
sscan:byte;
eflags:longint;
quel,counter,color:byte;
dwd:word;
{--------------Разработка обработчиков исключений--------------}
procedure out_exc;assembler; { Вывод номера исключения }
asm
mov ah,1 { Функция 1: установка маркера на экране }
mov bl,22 { с координатами - строка 22, }
mov bh,1 { столбец 1 }
int 30h
mov ah,4 { Функция 4: вывод на экран }
mov si, offset s2 { строки символов s2 }
mov cl,1eh
int 30h
mov ax,300h { Функция 3, подфункция 0: }
mov dl,excep { вывод на экран номера исключения }
mov cl,1ch
int 30h
mov dx,dwd
ret
end;
procedure exc_00;assembler; { Обработчик исключения 0 }
{-----Два варианта устранения зацикливания обработки отказа----}
mov bl,1 { Вариант 1: устранение причины отказа }
pusha
(* push bp { Вариант 2: изменение в стеке значения }
mov bp,sp { счетчика команд IP на величину длины команды }
inc word ptr [bp+2]
pop bp *)
mov excep,0
call out_exc; { Вывод сообщения об обработке исключения }
popa
cmp cpu_type,2
jz @2
db 66h
@2:iret
end;
procedure exc_13;assembler; { Обработчик исключения 0 }
{-----Два варианта устранения зацикливания обработки отказа----}
asm
cmp cpu_type,2
jz @1
db 66h
@1:pop bx
{-------------Вариант 2: изменяет в стеке значение------------}
{-------------счетчика команд IP на длину команды,------------}
{-----------вызвавшей исключение (div bl - 1 байт)------------}
push bp
mov bp,sp
add word ptr [bp+2],4 { или inc word ptr [bp+2] }
pop bp
{---------------------Вывод сообщения-------------------------}
{---------о возникновении исключения с номером excep----------}
pusha
mov excep,13
int 32h
(*push bx
mov ax,501h { Функция 5: вывод на экран }
mov cl,1eh { кода ошибки в двоичной форме }
pop dx
int 30h *)
popa
{-------Вариант 3: выполняет выход из защищенного режима-------}
{----через межсегментный косвенный переход на метку ret_mov----}
(* db 0ffh,2eh
dw ofs_ret_mov *)
cmp cpu_type,2
jz @2
db 66h
@2:iret
end;
procedure exc_0b;assembler; { Обработчик исключения 11 }
{ вызывается при отсутствии сегмента в памяти и выполняет }
{ коррекцию дескриптора сегмента - востанавливает бит P }
asm
mov excep,0bh
cmp cpu_type,2
jz @1
db 66h
@1:pop bx { Чтение из стека кода ошибки }
mov err,bx { и запись в переменную err }
and bx,not 7 { Выделение смещения селектора }
add bx,offset gdt+5 { Выбор поля байта доступа в GDT }
push ax
mov al, [bx] { Чтение байта доступа сегмента }
or al,80h
mov [bx],al { Установка бита P=1 в байте доступа }
pop ax
cmp cpu_type,2
jz @2
db 66h
@2:iret
end;
procedure keyb;assembler; { Обработчик прерываний }
asm { от клавиатуры: }
mov al,20h
out 20h,al { Сброс контроллера прерываний }
in al,60h { Чтение скан-кода нажатия/отжатия клавиши }
test al,80h
jnz @1 { Переход, если клавиша отжата }
mov scan,al
@1:cmp cpu_type,2
jz @3
db 66h
@3:iret
end;
procedure ttim;assembler; { Обработчик прерываний }
asm { от timer: }
push ax
mov al,$20
out $20,al { Сброс бита регистра ISR 1-го ПКП }
pop ax
inc counter
cmp counter,5
jnz @99
mov counter,0
push dx
push ax
mov dx,3dah
in al,dx
mov dx,3c0h
mov al,11h
out dx,al
inc color
mov al,color
out dx,al
mov al,20h
out dx,al
pop dx
pop ax
@99:cmp cpu_type,2 { Если 80286 - разрядность 16, }
jz @l1 { иначе - 32 }
db 66h
@l1:iret
end;
begin
clrscr;
{------Определение значения сегмента кода cs1 процедур,-----}
{------------------описанных в модуле PROT------------------}
cs1:=Seg(int_30h);
excep:=$ff; { Отличное от FFh значение переменной excep }
{ означает номер возникшего при работе программы исключения }
sscan:=0; { Клавиша не нажата }
res:=0; { МП сброшен не был }
{-----------Определение типа микропроцессора----------------}
get_cpu_type(0,cpu_type); { В cpu_type - номер типа МП }
if cpu_type=2 then t:=0 { 16-разрядный МП }
else t:=8; { 32-разрядный МП }
{ Формирование байта доступа прерывания: }
acc_int:=present OR type_int OR t;
{ Формирование байта доступа ловушки: }
acc_trap:=present OR type_trap OR t;
{-----------------Формирование таблицы GDT--------------------}
{ Нуль-дескриптор: }
init_gdt(0,0,0,0,0);
{ Дескриптор первого сегмента кода: }
init_gdt(1,$ffff,lin_adr(cseg,0),acc_code1,0);
{ Дескриптор второго сегмента кода: }
init_gdt(2,$ffff,lin_adr(cs1,0),acc_code,0);
{ Дескриптор сегмента данных: }
init_gdt(3,$ffff,lin_adr(dseg,0),acc_data,0);
{--------Имитация отсутствия сегмента данных в памяти:--------}
{-------------бит P в его дескрипторе равен нулю--------------}
{ gdt[3].acc:=gdt[3].acc and not present;
{ Дескриптор сегмента стека: }
init_gdt(4,0,lin_adr(sseg,0),acc_stack,0);
{ Дескриптор сегмента видеопамяти: }
init_gdt(5,4000-1,lin_adr($b800,0),acc_data,0);
{------Формирование данных регистра GDTR и его загрузка-----}
init_gdtr;
{----Определение селектора (cs_real) и смещения (ofs_ret)---}
{-------------точки возврата в реальный режим---------------}
cs_real:=Cseg;
asm mov ofs_ret,offset ret_r end;
{---------------------Формирование данных-------------------}
{---------для перехода на метку ret_r после сброса МП-------}
{-----------с инициализацией контроллера прерываний---------}
save_ret_real(cs_real,ofs_ret,5);
{------Запрет маскируемых и немаскируемых прерываний--------}
not_int;
{--------------Формирование таблицы IDT-------------------- }
{ Дескрипторы шлюзов обработчиков исключений 0-18: }
init_idt(0,ofs(exc_00),code_sel,acc_trap);
init_idt(1,ofs(exc_01),code_sel2,acc_trap);
init_idt(2,ofs(exc_02),code_sel2,acc_trap);
init_idt(3,ofs(exc_03),code_sel2,acc_trap);
init_idt(4,ofs(exc_04),code_sel2,acc_trap);
init_idt(5,ofs(exc_05),code_sel2,acc_trap);
init_idt(6,ofs(exc_06),code_sel2,acc_trap);
init_idt(7,ofs(exc_07),code_sel2,acc_trap);
init_idt(8,ofs(exc_08),code_sel2,acc_trap);
init_idt(10,ofs(exc_10),code_sel2,acc_trap);
init_idt(11,ofs(exc_0b),code_sel,acc_trap);
init_idt(12,ofs(exc_12),code_sel2,acc_trap);
init_idt(13,ofs(exc_13),code_sel,acc_trap);
init_idt(14,ofs(exc_14),code_sel2,acc_trap);
init_idt(16,ofs(exc_16),code_sel2,acc_trap);
init_idt(17,ofs(exc_17),code_sel2,acc_trap);
init_idt(18,ofs(exc_18),code_sel2,acc_trap);
{ Дескриптор шлюза обработчика прерывания от таймера: }
init_idt($20,ofs(ttim),code_sel,acc_int);
{ Дескриптор шлюза обработчика прерывания от клавиатуры : }
init_idt($21,ofs(keyb),code_sel,acc_int);
{ Дескрипторы шлюзов обработчиков прерываний IRQ2-IRQ7: }
for i:=2 to 7 do
init_idt($20+i,ofs(PIC_1),code_sel2,acc_int);
{ Дескрипторы шлюзов обработчиков прерываний IRQ8-IRQ15: }
for i:=8 to 15 do
init_idt($20+i,ofs(PIC_2),code_sel2,acc_int);
{ Дескриптор шлюза обработчика программного прерывания: }
init_idt($30,ofs(int_30h),code_sel2,acc_trap);
init_idt($32,ofs(int_32h),code_sel2,acc_int);
{-------Сохрание данных регистра IDTR в переменной IDTR-----}
asm
db 0fh,1,0eh { SIDT idtr }
dw idtr_r
end;
{------Формирование данных регистра IDTR и его загрузка-----}
{--------------для работы в защищенном режиме---------------}
init_idtr_p;
(* {--------------Формирование данных регистра IDTR------------}
{---------------для работы в реальном режиме---------------}
init_idtr_r; *)
{----------Программирование контроллера прерываний----------}
{--------------для работы в защищенном режиме---------------}
pic(1);
{-------Сохранение содержимого регистров DS,SS,ES и SP------}
save_sreg;
real_sp:=SPtr;
if cpu_type=2 then
{---------Переход в защищенный режим для МП 80286-----------}
asm { Установка бита PE=1 в регистре MSW: }
db 0fh,01h,0e0h { SMSW AX }
or ax,1
db 0fh,01h,0f0h { LMSW AX }
end else
{-------Переход в защищенный режим для МП 80386 и выше-----}
asm { Установка бита PE=1 в регистре управления CR0: }
db 0fh,20h,0c0h { MOV EAX,CR0 }
db 66h,0dh { OR EAX,1 }
dd 1h
db 0fh,22h,0c0h { MOV CR0,EAX }
end;
asm
push code_sel { Дальний переход на метку @prot }
push offset @prot { для загрузки CS и сериализации }
retf
{----------------Работа в защищенном режиме-----------------}
{---------------Загрузка сегментных регистров---------------}
{---------------соответствующими селекторами----------------}
@prot:
mov ds,data_sel { DS, }
mov ss,stack_sel { SS }
mov es,video_sel { и ES }
{-------------------Вывод на экран строки-------------------}
{---------"Обработка прерываний в защищенном режиме"--------}
{-----------с помощью функций 1 и 4 прерывания 30h----------}
mov ah,1 { Установка маркера: }
mov bx,903h { строка 3, столбец 9 }
int 30h
mov ah,4 { Вывод строки s на экран: }
mov cl,1eh { видеоатрибут, }
mov si,offset s { адрес строки }
int $30
mov ah,1
mov bx,705h
int 30h
mov ah,4 { Функция 4: вывод на экран }
mov si, offset s1 { строки символов s1 }
mov cl,1ch
int 30h
mov ax,301h { Функция 3, подфункция 1: }
mov dx,cs
mov cl,1ch
int 30h { Вывод на экран CS }
mov ax,301h
mov dx,ss
mov cl,1ch { Вывод на экран SS }
int 30h
mov ax,301h
mov dx,ds
mov cl,1ch
int 30h { Вывод на экран DS }
mov ax,301h
mov dx,es
mov cl,1ch
int 30h { Вывод на экран ES }
mov ax,302h { Функция 3, подфункция 2: }
db 0fh,20h,0c2h { MOV EDX,CR0 }
mov cl,1ch
int 30h { Вывод на экран CR0 }
mov ax,302h
db 66h
pushf
db 66h
pop dx
mov cl,1ch
int 30h { Вывод на экран EFLAGF }
mov ah,1
mov bx,510h
int 30h
mov ah,4 { Функция 4: вывод на экран }
mov si, offset s3 { строки символов s3 }
mov cl,1ch
int 30h
mov ah,1
mov bx,511h
int 30h
mov ah,4 { Функция 4: вывод на экран }
mov si, offset s4 { строки символов s3 }
mov cl,1ch
int 30h
{Virabotka zad isklucheniya}
mov ax,cs:[0]
{-------------Разрешение маскируемых прерываний-------------}
sti
{----Ожидание и обработка прерываний до установки семафора----}
{mov ax,cs:[0]}
@wait:
cmp scan,1h
jnz @wait
{int 13}
cmp cpu_type,2
jnz @mov
{----Возврат в реальный режим по сбросу микропроцессора-----}
push code_sel2
push offset reset
retf
{---Подготовка к возврату в реальный режим по команде MOV---}
{---------Установка параметров сегментов DS, SS и ES--------}
{---------------для работы в реальном режиме----------------}
@mov:
(* ARBEITEST an seleron 6 version !!!
push code_sel2
push offset reset
retf
*) cli
mov ds,data_sel
mov ss,data_sel
mov es,data_sel
{---------------Восстановление атрибутов IDT----------------}
{---------------для работы в реальном режиме----------------}
{-------Возврат в реальный режим по команде MOV-------------}
db 0fh,01h,1eh { LIDT idtr_r }
dw idtr_r
db 0fh,20h,0c0h { MOV EAX,CR0 }
db 66h,25h { AND EAX,FFFFFFFEh }
dd 0fffffffeh
db 0fh,22h,0c0h { MOV CR0,EAX }
push cs_real
push ofs_ret
retf
{-----------------Работа в реальном режиме------------------}
{---------------Восстановление регистров после--------------}
{------------------возврата в реальный режим----------------}
ret_r:
xor ax,ax
mov ds,ax
mov ds,[4*60h] { DS, }
mov ss,real_ss { SS, }
mov es,real_es { ES }
mov sp,real_sp { и SP }
end;
if res=0 then
{-------Перепрограммирование контроллеров прерываний--------}
{-------------для работы в реальном режиме------------------}
pic(0)
else
{---------Размаскирование контроллеров прерываний-----------}
{---------------после сброса микропроцессора----------------}
begin
port[$21]:=184;
port[$a1]:=13;
end;
{---Разрешение маскируемых и немаскируемых прерываний---}
en_int;
{-----В случае возникновения исключения вывод его номера-----}
gotoXY(1,20);
{----------Анализ возврата МП из защищенного режима---------}
if res=0 then s:='по команде MOV' else s:='через сброс МП';
writeln('Возврат из защищенного режима выполнен ',s);
writeln('Скан-код нажатой клавиши - ',scan,' - ESC');
end.
5. Результати роботи програми
Розроблена програма реалізує перехід у захищений режим і виводить на екран відомості про тип процесора і виводить вміст регістру флагів і іншу інформацію о системі. Потім реалізується цикл чекання переривання від клавіатури при натисканні клавіші ESC, під час цього обробляються переривання від таймеру і по кожному п’ятому тіку таймеру виконується змінення кольору бордюру. Після завершення циклу чекання натиску клавіші ESC програма реалізує виняткову ситуацію для виникнення 13 переривання, яке обробляється створеним перериванням, яке вилучає із стеку дескриптор помилки і обминає виняткову ситуацію. В кінці програма повертається у реальний режим і відновлює старі таблиці GDT та IDT.
6. Висновки
В даній розрахунково-графічній роботі розроблено програму, що реалізує захищений режим роботи мікропроцесора, обробку апаратних і програмних переривань, засвоєно основні принципи роботи мікропроцесора у захищеному режимі при використанні сегментної моделі пам’яті, порядок обробки переривань, структуру таблиць GDT та IDT.