Прерывания таймера и клавиатуры

Какой номер прерывания отвечает за таймер и клавиатуру? К одном месте написано, что 0x08 и 0x09, а в другом 0x32 и 0x33. Вот часть проги по адресу 0x1000:0000. Компилятор fasm. Не реагирует на таймер.

Код (Text):

1.              ...
2.     xor eax, eax
3.     mov ax, cs
4.     shl eax, 4
5.     add eax, idt
6.     mov [cs:idt_addr], eax
7.    
8.     lidt         fword ptr idtr
9.  
10.              ...
11.  
12. idt:   
13.     dq  0 ;0
14.     dq  0 ;1
15.     dq  0 ;2
16.     dq  0 ;3
17.     dq  0 ;4
18.     dq  0 ;5
19.     dq  0 ;6
20.     dq  0 ;7
21.     dq  0 ;8
22.     dq  0 ;9
23.     dq  0 ;10
24.     dq  0 ;11
25.     dq  0 ;12
26.    
27. exGP:   dw  (gp+0x10000) and 0xFFFF    
28.     dw  00001000b      
29.     dw  1000111000000000b  
30. exGP2:  dw  (gp+0x10000) shr 16
31.        
32.              rb          idt+32*8-$
33.              
34. extimer:  dw      (timer+0x10000) and 0xFFFF              
35.              dw      00001000b              
36.              dw      1000111000000000b      
37. extimer2: dw      (timer+0x10000) shr 16      
38.            
39.     rb idt+256*8-$
40.  
41. idt_end:
42. idtr:  
43.     idt_size:   dw      idt_end - idt
44.     idt_addr:   dd      0x6c00
45.  
46.              ...
47.  
48.     in     al, 070h
49.     and    al, 7Fh
50.     out    70h, al
51.     sti
52.  
53.              ...
54.  
55. gp: pop eax
56.     pusha
57.     mov eax, 0xB8000+80*2*4+2
58.     mov esi, eax
59.     inc byte [ds:esi]
60.     popa
61.     iretd
62.  
63. timer:  mov eax, 0xB800
64.     shl eax, 4
65.     add eax, 80*2*4+4
66.     mov esi, eax
67.     inc byte [ds:esi]
68.     jmp int_EOI
69. int_EOI:
70.     mov al, 20h
71.     out 020h, al
72.     out 0a0h, al
73.     iretd

Почему-то в начале генерируется GP с кодом 43. основной цикл программы вывода на экран выполняется, а обработчик таймера - нет.

 

Как инициализирован контроллер прерываний, такие номера и будут.

 

SII
Конкретнее, чего-то про это я не читал.

 

Я читал про то что нужно разрешать прерывания, чтобы они работали, но не было написано как.

Не это их инициализация?

Код (Text):

1.       mov     al, 0x00
2.       out     0x21, al
3.       out     0xA1, al

 

PIC - PROGRAMMABLE INTERRUPT CONTROLLER
Программируемый контроллер прерываний - ПКП
Или также известный как 8259А
Контроллер этот появился так давно, что совместим с процессорами 8080/8085 . Так как современные компьютеры их не используют. То нас больше интересует его работа в режиме совместимости с 8086/8088.
Поэтому будет описана только часть относящаяся к нему.

Контроллер имеет 8 линий прерываний, называемых IRQ. Этого мало, поэтому была разработана возможность каскадного подключения контроллеров. Когда к видущему Master контроллеру подключались, ведомые Slave контроллеры. Теоретически возможно, что мы имеем один ведущей и восемь подчиненных. Но в стандартном компьютере всего два - первый ведущий и второй ведомый.
Первый контроллер прерываний 8259А использует порты 20h-21h, второй 8259А использует 0A0h-0A1h
Второй контроллер сидит на IRQ2 первого контроллера.


Стандартное назначение прерываний следующее. Согласно документации на Award BIOS и ряда других спецификаций.

Код (Text):

1. +-----+-------+----------------------------------------+
2. | INT |  IRQ  | Назначение                             |
3. +-----+-------+----------------------------------------+
4. | 08h |  IRQ0 | Системный таймер (канал 0 8253/8254)   |
5. +-----+-------+----------------------------------------+
6. | 09h |  IRQ1 | Клавиатура                             |
7. +-----+-------+----------------------------------------+
8. | 0Ah |  IRQ2 | Каскадное подключение #2 8259A         |
9. +-----+-------+----------------------------------------+
10. | 0Bh |  IRQ3 | COM2                                   |
11. +-----+-------+----------------------------------------+
12. | 0Ch |  IRQ4 | COM1                                   |
13. +-----+-------+----------------------------------------+
14. | 0Dh |  IRQ5 | LPT2                                   |
15. +-----+-------+----------------------------------------+
16. | 0Eh |  IRQ6 | FDC(Floppy Disk Controller)            |
17. +-----+-------+----------------------------------------+
18. | 0Fh |  IRQ7 | LPT1                                   |
19. +-----+-------+----------------------------------------+
20. +-----+-------+----------------------------------------+
21. | 70h |  IRQ8 | Real time clock                        |
22. +-----+-------+----------------------------------------+
23. | 71h |  IRQ9 | Резерв, используется PCI               |
24. +-----+-------+----------------------------------------+
25. | 72h |  IRQ10| Резерв, используется PCI               |
26. +-----+-------+----------------------------------------+
27. | 73h |  IRQ11| Резерв, используется PCI               |
28. +-----+-------+----------------------------------------+
29. | 74h |  IRQ12| Мышь PS/2, Резерв, используется PCI    |
30. +-----+-------+----------------------------------------+
31. | 75h |  IRQ13| 80387 математический сопроцессор       |
32. +-----+-------+----------------------------------------+
33. | 76h |  IRQ14| Первичный канал IDE HDD                |
34. +-----+-------+----------------------------------------+
35. | 77h |  IRQ15| Вторичный канал IDE HDD                |
36. +-----+-------+----------------------------------------+

Пример программирования PIC.
В защищенном режиме процессора прерывания от процессора занимают вектора с 0 по 13h и c 14h по 1Fh зарезервированы для внутренних исключений и прерываний процессора. Так что аппаратные прерывания надо подвинуть.


ПКП может находиться в двух основных состояниях: настройки
и обслуживания запросов на прерывания. В состоянии настройки
контроллер принимает управляющие слова инициализации
(Initialization Command Words, ICW), в состоянии обслуживания -
операционные управляющие слова (Operation Control Words, OCW).

Initialization Command Words (ICW1- ICW4)
Командные слова для инициализации.

Operation Command Words (OCW1- OCW3)
Командные слова для действий.

Перед началом работы процессор должен инициировать контроллер. Последовательностью из 2-4 команд ICW. После инициализации можно отправлять OCW.

Команды инициализации подаются одна за другой. Сначала ICW1 затем ICW2 если был выбран каскадный режим, то подается ICW3 и если был запрошен то ICW4.

Формат команд 9битный. 8 бит сама команда, а 9 бит это бит с шины адреса, он задается номером порта. Четный порт соответствует 0, а нечетный 1.



Для вывода информации в ПКП используются 2 порта
ввода-вывода. Порт с четным адресом (обычно это порт 20h) и порт
с нечетным адресом (обычно 21h). Через эти порты могут быть
переданы 4 слова инициализации (Initialization Control Word,
ICW1 - ICW4), задающие режим работы ПКП, и 3 операционных
управляющих слова (слова рабочих приказов, Operation Control
Words, OCW1 - OCW3). В порт с четным адресом выводятся ICW1,
OCW2 и OCW3. OCW2 отличается от OCW3 тем, что бит 3 в ocw2 равен
0, а в OCW3 равен 1. В то же время бит 4 в OCW2 и OCW3 равен 0,
а в ICW1 равен 1. Таким образом по значению, выводимому в порт с
четным адресом, однозначно определяется, в какой регистр (ICW1,
OCW2 или OCW3) заносятся данные.

Порт с нечетным адресом используется для вывода ICW2, ICW3,
ICW4 и OCW1. Неоднозначности интерпретации данных в этом случае
так же не возникает, т. к. слова инициализации ICW2 - ICW4
должны непосредственно следовать за ICW1, выведенным в порт с
четным адресом и выводить в промежутке между ними OCW1 не
следует, онo не будет опознанo контроллером.

Выводом в порт с четным адресом управляющего слова
инициализации ICW1 начинается инициализация ПКП. В процессе
инициализации контроллер последовательно принимает управляющие
слова ICW1 - ICW4. При наличии в системе одного контроллера ICW3
не выводится. Наличие ICW4 определяется содержанием ICW1. При
наличии каскада из нескольких ПКП каждый из них инициализируется
отдельно.

Код (Text):

1.    A0   7    6    5    4    3    2    1    0
2.  +----+----+----+----+----+----+----+----+----+
3.  |  1 | T7 | T6 | T5 | T4 | T3 |  0 |  0 |  0 |
4.  +----+----+----+----+----+----+----+----+----+

Формат ICW2 , это номер начального вектора прерывания. Биты 0-2 должны быть 0. При приходе прерывания. Номер линии, на которую пришло прерывание, складывается с этим числом. И выставляется на шину адреса.

Пример инициализации ПКП. Вектора ведущего будут иметь базу 20h, а ведомого 28h

Код (Text):

1.         MOV    DX, 20h     // Ведущий
2.         MOV    AH, 20h    //Номер начального прерывания для ведущего контроллера 08 стандартное для реального режима
3.                                 // Для защищенного Я выбрал 20h
4.         MOV     AL,11h     //ICW1 бит 0=1 сигнализирует, что будет послан ICW4
5.         OUT     DX,AL
6.         MOV     AL,AH      //ICW2  - начальный номера прерываний биты 2-0=0.
7.         INC      DX
8.         OUT     DX,AL
9.         MOV     AL,4       //ICW3 ведущий 00000100 -  ведомый подключен ко второй линии
10.         OUT     DX,AL
11.         MOV     AL,1       //ICW4 режим 86/88  
12.         OUT     DX,AL
13.  
14.         MOV    DX, 0A0h     // Ведомый
15.         MOV    AH, 28h    //Номер начального прерывания для ведомого контроллера 70h стандартное для реального режима
16.                                 // Для защищенного Я выбрал 28h
17.         MOV     AL,11h     //ICW1 бит 0=1 сигнализирует, что будет послан ICW4
18.         OUT     DX,AL
19.         MOV     AL,AH      //ICW2  - начальный номера прерываний биты 2-0=0.
20.         INC     DX
21.         OUT     DX,AL
22.         MOV     AL,2       //ICW3 ведомый, ведомый подключен ко второй линии ведущего
23.         OUT     DX,AL
24.         MOV     AL,1       //ICW4 режим 86/88  
25.         OUT     DX,AL

Управляющее слово OCW1

Код (Text):

1.    A0   7    6    5    4    3    2    1    0
2.  +----+----+----+----+----+----+----+----+----+
3.  |  1 | M7 | M6 | M5 | M4 | M3 | M2 | M1 | M0 |
4.  +----+----+----+----+----+----+----+----+----+

Установленный в 1 бит маскирует соответствующее прерывание. Это значит, что пришедшее прерывание не будет обрабатываться.

 

Замаскировать прерывания можно по разному. К примеру в ЦП, а именно в регистре EFLAG
Командами
CLI // сбрасывает флаг прерываний IF. Тем самым запрещает прерывания.
STI // устанавливает флаг прерываний IF. Тем самым разрешает прерывания.

Также как я уже писал прерывания можно замаскировать в самом ПКП

Код (Text):

1. MOV  AL, 0FFh  // маскируем все прерывания
2. OUT  21h, AL  // OCW1
3.  
4.  
5. MOV  AL, 000h  // разрешаем все прерывания на ведущем
6. OUT  21h, AL  // OCW1
7. MOV  AL, 000h  // разрешаем все прерывания на ведомом
8. OUT  0A1h, AL  // OCW1

 

BVOG
А ты какой таймер программируешь? Интервальный? Так от него прерывания и так разрешены. И генерирует он IRQ0 / INT8 18.2 раза в секунду.
И прерывания от клавиатуры разрешены. IRQ1 / INT9

И несколько вопросов, так как в твоем коде откровенно не разобрался.
Ты бы подсказал, где у тебя точки входа в обработчики......
И как ты определяешь, что обработчики не вызываются?

И вызывает интерес, вот такой еще разрез...
Ты уверен, что при входе в твой обработчик процессор переходит в 32 битный режим?

 

MisHel64
Вот весь код

Код (Text):

1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2. ;;
3. ;;       Protected Mode Initialization
4. ;;
5. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
6. pmode_init:
7.     in  al, 092h
8.     or  al, 2
9.     out 092h, al
10.        
11.     in  al, 070h
12.     or  al, 080h
13.     out 070h, al
14.    
15.     xor eax, eax
16.     mov ax, cs
17.     shl eax, 4
18.     add eax, gdt
19.     mov [cs:addr], eax
20.    
21.     lgdt    fword ptr gdtr
22.    
23.     xor eax, eax
24.     mov ax, cs
25.     shl eax, 4
26.     add eax, idt
27.     mov [cs:idt_addr], eax
28.    
29.     lidt   fword ptr idtr
30.    
31.     mov eax, cr0
32.     or  ax, 1
33.     mov cr0, eax
34.    
35.     jmp    pword 0x08:pmode+0x10000
36.  
37. gdt:    null db 8 dup(0)
38.     code db 0ffh, 0ffh, 00h, 00h, 00h, 10011010b, 11001111b, 00h
39.     data db 0ffh, 0ffh, 00h, 00h, 00h, 10010010b, 11001111b, 00h
40.     video db 0ffh, 00h, 080h, 0bh, 00h, 10010010b, 01000000b, 00h
41. gdt_end:
42. gdtr:
43.     size:   dw  gdt_end - gdt
44.     addr:   dd  0x7400
45. idt:   
46.     dq  0 ;0
47.     dq  0 ;1
48.     dq  0 ;2
49.     dq  0 ;3
50.     dq  0 ;4
51.     dq  0 ;5
52.     dq  0 ;6
53.     dq  0 ;7
54.     dq  0 ;8
55.     dq  0 ;9
56.     dq  0 ;10
57.     dq  0 ;11
58.     dq  0 ;12
59.    
60. exGP:   dw  (gp+0x10000) and 0xFFFF        
61.     dw  00001000b              
62.     dw  1000111000000000b          
63. exGP2:  dw  (gp+0x10000) shr 16        
64.        
65.     rb idt+32*8-$
66.    
67. extm:   dw      (timer+0x10000) and 0xFFFF              
68.     dw      00001000b                          
69.     dw      1000111000000000b                  
70. extm2:  dw      (timer+0x10000) shr 16            
71.     rb idt+256*8-$
72. idt_end:
73. idtr:  
74.     idt_size:   dw      idt_end - idt
75.     idt_addr:   dd      0x6c00
76.    
77.     rb start+512+1024*4-$
78.  
79. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
80. ;;
81. ;;       Protected Mode Entry Point
82. ;;
83. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
84.  
85. Use32
86. pmode: 
87.     ; Загрузить сегментные регистры и инициализировать стек
88.     mov ax, 00010000b
89.     mov ds, ax
90.     mov ss, ax
91.     mov fs, ax
92.     mov gs, ax
93.     mov esp, 0x2FFFC
94.     mov ax, 00011000b
95.     mov es, ax
96.    
97.     mov eax, 0xB800
98.     shl eax, 4
99.     add eax, 80*2*3
100.     mov esi, eax
101.    
102.     mov eax, 0x1000
103.     shl eax, 4
104.     add eax, pm
105.     mov edi, eax
106.    
107.     mov ah, 0x0f
108.     mov cx, 68
109.     cirpm:
110.         mov al, [ds:edi]
111.         mov [ds:esi], ax
112.         inc edi
113.         inc esi
114.         inc esi
115.     loop    cirpm
116.    
117.     ;include "gui.inc"
118.    
119.     mov cl, 0x20
120.     mov ch, 0x28
121.  
122.     mov   al, 0x11                ; IWC1
123.     out   0x20, al
124.     out   0xA0, al
125.  
126.     mov   al, cl                  ; IWC2
127.     out   0x21, al
128.     mov   al, ch
129.     out   0xA1, al
130.  
131.     mov   al, 0x04                ; IWC3
132.     out   0x21, al
133.     mov   al, 0x02
134.     out   0xA1, al
135.  
136.     mov   al, 0x01                ; IWC4
137.     out   0x21, al
138.     out   0xA1, al
139.    
140.     mov al, 0x00
141.     out 0x21, al
142.     out 0xA1, al
143.    
144.     in     al, 070h
145.     and    al, 7Fh
146.     out    70h, al
147.     sti
148.    
149.     mov eax, 0xB800
150.     shl eax, 4
151.     add eax, 80*2*4+20
152.     mov esi, eax
153. circle:
154.     inc    byte [ds:esi]
155.     jmp circle
156.    
157. pm  db  ' Protected mode initializated. To return in Real Mode Reset Computer '
158.  
159. hextostr:
160.     mov edx, ebx
161.    
162.     xor ecx, ecx
163.    
164.     xor eax, eax
165.     mov eax, 0x1000
166.     shl eax, 4
167.     add eax, hex
168.    
169.     and ebx, 0x0000000F
170.     add eax, ebx
171.     mov esi, eax
172.     mov cl, [ds:esi]
173.        
174.     xor eax, eax
175.     mov eax, 0xB800
176.     shl eax, 4
177.     add eax, 80*2*4+8
178.     mov edi, eax
179.     mov ch, 0x0F
180.     mov [ds:edi], cx
181.    
182.     mov ebx, edx
183.    
184.     xor ecx, ecx
185.    
186.     xor eax, eax
187.     mov eax, 0x1000
188.     shl eax, 4
189.     add eax, hex
190.    
191.     and ebx, 0x000000F0
192.     shr ebx, 4
193.     add eax, ebx
194.     mov esi, eax
195.     mov cl, [ds:esi]
196.        
197.     xor eax, eax
198.     mov eax, 0xB800
199.     shl eax, 4
200.     add eax, 80*2*4+6
201.     mov edi, eax
202.     mov ch, 0x0F
203.     mov [ds:edi], cx
204.    
205.     ret
206. hex db  '0123456789ABCDEF'
207.    
208. gp: pop eax
209.     pusha
210.     mov ebx, eax
211.     call    hextostr
212.     mov eax, 0xB8000+80*2*4+2
213.     mov esi, eax
214.     inc byte [ds:esi]
215.     popa
216.     iretd
217. timer:  pusha
218.     mov eax, 0xB800
219.     shl eax, 4
220.     add eax, 80*2*4+4
221.     mov esi, eax
222.     inc byte [ds:esi]
223.     popa
224.     jmp int_EOI
225. int_EOI:
226.     mov al, 20h
227.     out 020h, al
228.     out 0a0h, al
229.     iretd
230.        
231.     rb start+65536-2-$
232.     dw 0xB0B0

Проверку на 32-битный режим япроводил двумя способами: выводом на экран в текством режиме и графическом VESA в высших адресах. Проверку прошёл. К памяти свыше 1МБ адресуется как положено.

 

Прости, но огромное количество комментариев, так усложнило разбор кода, что мой мозг просто не с правился с поиском кода устанавливающего прерывания и точек входа в обработчики.
Успехов!

 

Не знаю, мне всё понятно. Если нужно, могу коммменты потавить.

 

Прошу прощения за оффтоп, но помню у меня не получилось обрабатывать прерывания от клавы в RM. Контроллер прерываний настроен на базовый адрес. Прерывание 1Сh обрабатывается прекрасно. А вот 09h никак не обрабатывается, хотя ставлю аналогично 1Ch (но если 09h вызвать ручками, то всё прекрасно работает). В чём может быть проблема?

 

Что вы подразумеваете под RM?

 

Real Mode

 

Вот я индус. EOI не послал. Обратно атас.

 

Ан нет... Ладно, попробую приоритет поменять.

 

Что то странно. В регистр команд клавы прописал следующее:

Код (Text):

1. mov al, 11110010b
2. out 64h, al

Нет результата. Может что-нибудь не так с приоритетами?

 

Вот кусок кода:

Код (Text):

1. off_09h    equ 9h*4
2. xor es, es
3. mov ax, keyboard ;адрес обработчика
4. mov [es:off_09h], ax
5. push cs
6. pop ax
7. mov [es:off_09h+2], ax
8.  
9. keyboard:
10. push ax
11. push bx
12. push es
13. push ds
14. push cs
15. pop ds
16.  
17. in  al, 60h; показываем что нажали
18. mov ah, 07h
19. mov bx, 0b800h
20. mov es, bx
21. mov [es:0], ax
22.  
23. mov al, 20h; шлём EOI
24. out 0A0h, al
25. out 20h, al
26. pop ds
27. pop es
28. pop bx
29. pop ax
30. iret

 

Я вот не совсем понял, как вы обрабатываете прерывания клавиатуру в реальном режиме? Я знаю только один вариант - перезаписать адресы обработчиков c адреса 0000 по адрес 0x03F0 .

 

Таблица прерываний находится в 1'ом кб. Я по смещению 09h*4 в первые 2 байта записываю адрес обработчика, в остальные 2 - сегмент.