Universidad Nacional de San Agustín

F a c u l t a d d e I n g en ie r í a d e P r o d u c c ió n y S e r v ic io s

Escuela Profesional de Ingeniería Electrónica

ARQUITECTURA DE COMPUTADORAS

LABORATORIO N° 7
GRUPO “A”

CMOS Programas residentes y manejo de interrupciones

Alumno:
- García Mamani Roger Alex CUI: 20103986 ………….……

AREQUIPA - PERU

2014 – A
INDICE
1. Programas residentes tipeados de los textos especializados en algún lenguaje pequeño
portable. (asembler, basic, c std, pascal, etc.) ................................................................. 3
2. Describa la dirección base de reloj de tiempo real de la PC. ............................................ 9
3. Describir las interrupciones por hardware usadas en la PC cuales están ocupadas y
cuales disponibles. ......................................................................................................... 10
4. Describir las interrupciones por software usadas en la PC cuales están ocupadas y
cuales disponibles. ......................................................................................................... 11
5. Describir el setup de la PC, las opciones de configuración y los parámetros. ............... 12

BIBLIOGRAFIA .............................................................................................................................. 15

2
1. Traer programas residentes tipeados de los textos especializados en algún lenguaje
pequeño portable. (asembler, basic, c std, pascal, etc.)
El siguiente programa residente no realiza tarea alguna, tan sólo es una demostración
de la manera general de proceder para crear un programa residente. En principio, el
código de instalación está colocado al final, con objeto de no dejarlo residente y
economizar memoria. La rutina de instalación (MAIN) se encarga de preservar el
vector de la interrupción periódica y desviarlo para que apunte a la futura rutina
residente. También se instala una rutina de control de la interrupción 10h. Finalmente,
se libera el espacio de entorno para economizar memoria y se termina residente. El
procedimiento CONTROLA_INT8 puede ser modificado por el lector para que el
programa realice una tarea útil cualquiera 18,2 veces por segundo: de la manera que
está, se limita a llamar al anterior vector de la INT 8 y a comprobar que no se está
ejecutando ninguna función de vídeo de la BIOS (que no se ha interrumpido la
ejecución de una INT 10h). Esto significa que el lector podrá utilizar libremente los
servicios de vídeo de la BIOS, si bien para utilizar por ejemplo los de disquetes habría
que desviar y monitorizar también INT 13h; por supuesto además que no se
puede llamar al DOS en este TSR (no se puede hacer INT 21h directamente desde el
código residente). Por cierto, si se fija el lector en la manera de controlar la INT 10h
verá que al final se retorna al programa principal con IRET: los flags devueltos son los
del propio programa que llamó y no los de la INT 10h real. Con la INT 10h se puede
hacer esto, ya que los servicios de vídeo de la BIOS no utilizan el registro de estado
para devolver ninguna condición. Sin embargo, con otras interrupciones BIOS (ej. 16h)
o las del DOS habría que actuar con más cuidado para que la rutina de control no
altere nada el funcionamiento normal.

Puede que el lector haya visto antes programas residentes que no toman la precaución
de monitorizar la interrupción 10h o la 13h de la BIOS, y tal vez se pregunte si ello es
realmente necesario. La respuesta es tajantemente que sí. Como se verá en el futuro
en otro programa de ejemplo, reentrar a la BIOS sin más puede provocar conflictos.

demores SEGMENT
ASSUME CS:demores, DS:demores

ORG 100h
inicio:
JMP main

controla_int08 PROC
PUSHF
CALL CS:ant_int08 ; llamar al gestor normal de
INT 8
STI
CMP CS:in10,0
JNE fin_int08 ; estamos dentro de INT 10h

;
; Colocar aquí el proceso a ejecutar 18,2
veces/seg.
; que puede invocar funciones de INT 10h
fin_int08:
IRET
controla_int08 ENDP

3
controla_int10 PROC
INC CS:in10 ; indicar entrada en INT 10h
PUSHF
CALL CS:ant_int10
DEC CS:in10 ; fin de la INT 10h
IRET
controla_int10 ENDP

in10 DB 0 ; mayor de 0 si hay INT 10h

ant_int08 LABEL DWORD
ant_int08_off DW ?
ant_int08_seg DW ?
ant_int10 LABEL DWORD
ant_int10_off DW ?
ant_int10_seg DW ?

; Dejar residente hasta aquí.

main: PUSH ES
MOV AX,3508h
INT 21h ; obtener vector de INT 8
MOV ant_int08_seg,ES
MOV ant_int08_off,BX
MOV AX,3510h
INT 21h ; obtener vector de INT
10h
MOV ant_int10_seg,ES
MOV ant_int10_off,BX
POP ES

LEA DX,controla_int08
MOV AX,2508h
INT 21h ; nueva rutina de INT 8

LEA DX,controla_int10
MOV AX,2510h
INT 21h ; nueva rutina de INT 10h

PUSH ES
MOV ES,DS:[2Ch] ; dirección del entorno
MOV AH,49h
INT 21h ; liberar espacio de
entorno
POP ES

LEA DX,main ; fin del código

residente
ADD DX,15 ; redondeo a párrafo
MOV CL,4
SHR DX,CL ; bytes -> párrafos
MOV AX,3100h ; terminar residente
INT 21h

demores ENDS
END inicio

4
A continuación se listan dos rutinas que habrá de incorporar todo programa que desee
emplear este convenio (u otras equivalentes). Las rutinas las he
denominado mx_get_handle y mx_find_tsr. La primera permite buscar un valor para la
interrupción Multiplex aún no empleado por otra tarea residente, tanto si ésta es del
convenio como si no. La segunda sirve para que el programa residente se busque a sí
mismo en la memoria. En esta segunda rutina se indica el tamaño de la cadena de
identificación (la que contiene el nombre del fabricante, programa y versión) en CX. Si
no se encuentra el programa residente en la memoria, puede repetirse la búsqueda
con CX indicando sólo el tamaño del nombre del fabricante y el programa, sin incluir el
de la versión: así se podría advertir al usuario que tiene instalada ya otra versión
distinta.

; ------------ Buscar entrada no usada en la interrupción

Multiplex.
; A la salida, CF=1 si no hay hueco (ya hay 64
programas
; residentes instalados con esta técnica). Si CF=0,
se
; devuelve en AH un valor de entrada libre en la
INT 2Fh.

mx_get_handle PROC
MOV AH,0C0h
mx_busca_hndl: PUSH AX
MOV AL,0
INT 2Fh
CMP AL,0FFh
POP AX
JNE mx_si_hueco
INC AH
JNZ mx_busca_hndl
mx_no_hueco: STC
RET
mx_si_hueco: CLC
RET
mx_get_handle ENDP

; ------------ Buscar un TSR por la interrupción Multiplex. A la

; entrada, DS:SI cadena de identificación del
programa
; (CX bytes) y ES:DI protocolo de búsqueda
(normalmente
; 1492h:1992h). A la salida, si el TSR ya está
instalado,
; CF=0 y ES:DI apunta a la cadena de identificación
del
; mismo. Si no, CF=1 y ningún registro alterado.

mx_find_tsr PROC
MOV AH,0C0h
mx_rep_find: PUSH AX
PUSH CX
PUSH SI
PUSH DS
PUSH ES
PUSH DI
MOV AL,0
PUSH CX
INT 2Fh

5
 POP CX
CMP AL,0FFh
JNE mx_skip_hndl ; no hay TSR ahí
CLD
PUSH DI
REP CMPSB ; comparar identificación
POP DI
JE mx_tsr_found ; programa buscado
hallado
mx_skip_hndl: POP DI
POP ES
POP DS
POP SI
POP CX
POP AX
INC AH
JNZ mx_rep_find
STC
RET
mx_tsr_found: ADD SP,4 ; «sacar» ES y DI de la
pila
POP DS
POP SI
POP CX
POP AX
CLC
RET
mx_find_tsr ENDP

/********************************************************************/
/* */
/* TSRKILL 1.3 - Utilidad de desinstalación de TSRs normalizados. */
/* Compilar en el modelo «Large» de Borland C. */
/* */
/********************************************************************/

#include <dos.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

struct tsr_info {
unsigned segmento_real;
unsigned offset_real;
unsigned ltsr;
unsigned char info_extra;
unsigned char multiplex_id;
unsigned vectores_id;
unsigned extension_id;
unsigned long validacion;
char autor_nom_ver[80];
};

int tsr_convenio(),
mx_unload(),
existe_xms();
void liberar_umb(),

6
 desinstalar();

void main (int argc, char **argv)

{
int mxid;
struct tsr_info far *tsr;

printf ("\nTSRKILL 1.3\n");

if ((((mxid=atoi(argv[1]))<0xc0) || (mxid>0xFF)) && (mxid!=-1)) {
printf (" - Indicar número Mx. ID (TSRLIST) entre 192 y 255");
printf (" (-1 todos los TSR).\n");
exit (1); }

if (mxid==-1) {
for (mxid=0xc0; mxid<=0xFF; mxid++)
if (tsr_convenio(mxid, &tsr)) desinstalar (mxid);
}
else
desinstalar (mxid);
}

void desinstalar (int mxid)

{
int vector, correcto;
char far *nombre, *p,
cadena [80], cadaux[80];

correcto=mx_unload (mxid, &vector, &nombre);

if (correcto || (vector<0x100)) {
strcpy (cadaux, nombre); p=cadaux;
while (*p) if ((*p++)==':') *(p-1)=0; p=cadaux;
while (*p++); strcpy (cadena, p); /* nombre programa */
strcat (cadena, " ");
while (*p++); strcat (cadena, p); /* versión */
strcat (cadena, " de ");
strcat (cadena, cadaux); /* autor */
}

if (correcto)
printf(" - Desinstalado el %s\n", cadena);
else {
if (vector==0x100)
printf (" - No hay TSR %u o no es del convenio.\n", mxid);
else if (vector==0x101)
printf (" - HBREAK es «demasiado fuerte» para TSRKILL.\n");
else if (vector==0x102)
printf (" - 2MGUI es «demasiado fuerte» para TSRKILL.\n");
else {
printf (" - El %s no se puede desinstalar: ", cadena);
printf ("fallo en el vector %02X.\n", vector);
}
}
}

int mx_unload (int mxid, int *interrupción, char far **tsrnombre)

{
int mx, posible, vx, vector, i, nofincadena;

7
unsigned intptr, iniciotsr, tablaptr[256][2], sgm, ofs;
char numvect;
struct tsr_info far *tsr, far *tsrx;
struct REGPACK r;
void interrupt (*interr)();

if (!tsr_convenio (mxid, &tsr)) {

*interrupción=0x100;
return (0);
}

numvect = peekb(FP_SEG(tsr), tsr->vectores_id-1);

for (i=0; i<256; i++) tablaptr[i][0]=tablaptr[i][1]=0;

for (posible=1, vx=0; posible && (vx<numvect); vx++) {

vector = peekb(FP_SEG(tsr), tsr->vectores_id+5*vx);
intptr = FP_SEG(getvect(vector)) + (FP_OFF(getvect(vector)) >> 4);
nofincadena=1; mx=0xC0;
while (posible && nofincadena) {
if (tsr_convenio (mx, &tsrx)) {
iniciotsr=tsrx->segmento_real; /* el OFFSET se desprecia */
i=peekb(FP_SEG(tsrx), tsrx->vectores_id-1);
while ((peekb(FP_SEG(tsrx),tsrx->vectores_id+5*(i-1))!=vector)
&& i) i--;
if (i && (intptr>=iniciotsr)&&(intptr<=iniciotsr+tsrx->ltsr))
if (mx==mxid) nofincadena=0;
else {
tablaptr[vx][0]=FP_SEG(tsrx);
tablaptr[vx][1]=tsrx->vectores_id+5*(i-1)+1;
intptr=peek(tablaptr[vx][0],tablaptr[vx][1]+2) +
((unsigned) peek(tablaptr[vx][0],tablaptr[vx][1]) >>4);
mx=0xBF; /* compensar incremento posterior */
}
}
if (mx==0xFF) posible=0; else mx++;
}
}

*interrupción = vector;
*tsrnombre = tsr->autor_nom_ver;

if (strstr(*tsrnombre, "HBREAK")!=NULL) {
posible=0; *interrupción=0x101; }

if (strstr(*tsrnombre, "2MGUI")!=NULL) {
posible=0; *interrupción=0x102; }

if (posible) {
for (i=0; i<numvect; i++) {
vector = peekb(FP_SEG(tsr), tsr->vectores_id+5*i);
sgm = peek(FP_SEG(tsr), tsr->vectores_id+5*i+3);
ofs = peek(FP_SEG(tsr), tsr->vectores_id+5*i+1);
if ((tablaptr[i][0]==0) && (tablaptr[i][1]==0)) {
interr=MK_FP(sgm, ofs);
setvect (vector, interr);
}
else {
asm cli
poke (tablaptr[i][0], tablaptr[i][1], ofs);
poke (tablaptr[i][0], tablaptr[i][1]+2, sgm);
asm sti

8
 }
}

switch (tsr->info_extra & 3) {

case 0: r.r_es=tsr->segmento_real; r.r_ax=0x4900;
intr (0x21, &r); break;
case 1: if (existe_xms()) liberar_umb (tsr->segmento_real);
break;
}
}
return (posible);
}

int tsr_convenio (int entrada, struct tsr_info far **info)

{
struct REGPACK r;

r.r_ax=entrada << 8;
r.r_es=0x1492; r.r_di=0x1992;
intr (0x2f, &r);
*info = MK_FP(r.r_es, r.r_di-16);
return ((r.r_ax==0xFFFF) &&
(peek(r.r_es,r.r_di-4)==9002) && (peek(r.r_es,r.r_di-2)==10787));
}
int existe_xms ()
{
struct REGPACK r;

r.r_ax=0x4300; intr (0x2F, &r); return ((r.r_ax & 0xFF)==0x80);

}

void liberar_umb (unsigned segmento)

{
long controlador;

asm {
push es; push si; push di;
mov ax,4310h
int 2Fh
mov word ptr controlador,bx
mov word ptr controlador+2,es
mov ah,11h
mov dx,segmento
call controlador
pop di; pop si; pop es;
}
}

2. Describa la dirección base de reloj de tiempo real de la PC y realizar un programa

para poder tener acceso a dicho reloj en lectura y escritura.

IRQ8 70 No existe Reloj de tiempo real*

9
3. Describir las interrupciones por hardware usadas en la PC cuales están ocupadas y
cuales disponibles.

Las interrupciones de hardware son aquellas interrupciones que se producen como

resultado de, por lo general, una operación de E/S. No son producidas por ninguna
instrucción de un programa sino por las señales que emiten los dispositivos
periféricos para indicarle al procesador que necesitan ser atendidos.
Cuando el microprocesador accede a un periférico (disco duro, puerto de
comunicación...), puede transcurrir algún tiempo antes de que los datos sean
obtenidos o transmitidos. La solución más simple es esperar hasta recibir los datos o
hasta que se haya efectuado la transmisión (polling), pero esta solución bloquea todos
los programas en ejecución, y eso no puede admitirse en un sistema multitarea. Por
ello, en los sistemas modernos se prefiere un funcionamiento mediante
interrupciones, ya que éstas permiten mejorar la productividad del procesador, de
forma que este último puede ordenar una operación de E/S y, en lugar de tener que
realizar una espera activa, se puede dedicar a atender a otro proceso o aplicación
hasta que el dispositivo esté de nuevo disponible, siendo dicho dispositivo el
encargado de notificar al procesador mediante la línea de interrupción que ya está
preparado para continuar/terminar la operación de E/S.
Las excepciones son un tipo de interrupción sincrónica típicamente causada por una
condición de error en un programa, como por ejemplo una división entre 0 o un
acceso inválido a memoria en un proceso de usuario. Normalmente genera un cambio
de contexto a modo supervisor para que el sistema operativo atienda el error. Así
pues, las excepciones son un mecanismo de protección que permite garantizar la
integridad de los datos almacenados tanto en el espacio de usuario como en el
espacio kernel. Cuando el Sistema Operativo detecta una excepción intenta
solucionarla, pero en caso de no poder simplemente notificará la condición de error a
la aplicación/usuario y abortará la misma.

4. Describir el procedimiento para acceder a una interrupción.

En sistemas más modernos utilizan la arquitectura APIC de Intel con 24 líneas y 8

extra para enrutar las interrupciones PCI.
Cuando un periférico desea acceder a un recurso, envía un pedido de interrupción al
procesador para llamar su atención. Los periféricos cuentan con un número de
interrupción que se denomina IRQ (Peticiones de Interrupción. Es como si cada
periférico tirara de un "hilo" que está atado a una campana para señalarle al equipo
que desea que le preste atención.
Este "hilo" es, de hecho, una línea física que conecta cada ranura de expansión así
como cada interfaz E/S a la placa madre. Para una ranura ISA de 8 bits, por ejemplo,
hay 8 líneas IRQ que unen ranuras ISA de 8 bits a la placa madre (IRQ0 a IRQ7). Estos
IRQ están controlados por un "controlador de interrupción" que se encarga de
“cederle la palabra” al IRQ que posee la mayor prioridad.

10
 Al aparecer las ranuras de 16 bits, se agregaron IRQ 8 a 15. En consecuencia , fue
necesario agregar un segundo controlador de interrupción. Los dos grupos de
interrupciones están unidos por IRQ 2 el cual se conecta (o "produce una cascada") a
IRQ9. En cierto modo, esta cascada "inserta" IRQ 8 a 15 entre IRQ1 y 3:

Dado que la prioridad va del IRQ inferior al superior y que se insertan IRQ 8 a 15 entre
IRQ 1 y 3, el orden de prioridad es el siguiente:

0 > 1 > 8 > 9 > 10 > 11 > 12 > 13 > 14 > 15 > 3 > 4 > 5 > 6 > 7

5. Describir las interrupciones por software usadas en la PC cuales están ocupadas y

cuales disponibles.

Las interrupciones por software, también denominadas llamadas al sistema, son aquellas
generadas por un programa mientras este está ejecutándose. En general, actúan de la
siguiente manera:

1. Un programa que se venía ejecutando luego de su instrucción I5 , llama al Sistema

Operativo, por ejemplo para leer un archivo de disco (cuando un programa
necesita un dato exterior , se detiene y pasa a cumplir con las tareas de recoger
ese dato).

11
 2. A tal efecto, luego de I5 existe en el programa, la instrucción de código de
máquina CD21, simbolizada INT 21 en Assembler, que realiza el requerimiento del
paso 1. Puesto que no puede seguir la ejecución de la instrucción I6 y siguientes
del programa hasta que no se haya leído el disco y esté en memoria principal
dicho archivo, virtualmente el programa se ha interrumpido, siendo, además, que
luego de INT 21, las instrucciones que se ejecutarán no serán del programa, sino
del Sistema Operativo. ( se detiene el programa y ordena en este caso mediante
INT21 ( interrupción predefinida ) que recoge el dato solicitado, para poder sequir
el programa que la ordeno ).
3. La ejecución de INT 21 permite hallar la subrutina del Sistema Operativo.
4. Se ejecuta la subrutina del Sistema Operativo que prepara la lectura del disco.
5. Luego de ejecutarse la subrutina del Sistema Operativo, y una vez que se haya
leído el disco y verificado que la lectura es correcta, el Sistema Operativo
ordenará reanudar la ejecución del programa autointerrumpido en espera.
6. La ejecución del programa se reanuda.

6. Describir el setup de la PC, las opciones de configuración y los parámetros.

12
Parámetros del Setup

Standart CMOS SETUP

Pantalla de presentación del programa SETUP

Esta pantalla muestra información con respecto de los siguientes ítems:

 Fecha y hora del sistema.

 Parámetros de los dispositivos IDE.
 Tipo de unidad de disquete.
 Tipo de video instalado.
 En que situaciones el sistema deberá detenerse durante el arranque.

BIOS FEATURES SETUP o ADVANCED CMOS SETUP

Las opciones más importantes son:

-Virus Warning: Permite, habilitar o deshabilitar la protección del sector de arranque

del disco duro.

-CPU L2 Caché: habilita o deshabilita la memoria cache externa (L2).

-Quick Power On Self Test: esta opción permite habilitar o deshabilitar la

velocidad para el test de arranque (POST).

-Boot Sequence: Este parámetro permite determinar el orden de búsqueda con

respecto a la unidad por la que arrancará el sistema operativo.

-Boot Up Numlock Status: habilita o deshabilita la tecla Numlock, la habilitación de

la misma permite que el trabajo con el teclado numérico, se cargue automáticamente.

-Security Option Mediante esta opción se determina si el (password) definido en la

opción

PASSWORD SETTING, será solicitado solamente para ingresar al setup, o al sistema.

CHIPSET FEATURES SETUP

-SDRAM Frequency: permite indicar la frecuencia de la SDRAM.

-AGP Mode: permite configurar el modo AGP de trabajo.

-USB Controller: se utiliza para habilitar o deshabilitar los puertos USB.

-Onchip Sound: permite habilitar o deshabilitar la placa de sonido onboard.

POWER MANAGEMENT SETUP

En esta opción podemos determinar los tiempos a los cuales se desea que los
dispositivos se apaguen temporalmente, controlando su consumo de energía.

13
PNP/PCI CONFIGURATION

Maneja las variables que afectan al sistema Plug & Play y a los buses PCI,
administrando los recursos del sistema, con el fin de evitar conflictos. El valor por
defecto es automático.

INTEGRATED PERIPHERALS

En él están integrados los controladores del disco rígido, del disco flexible, de los
puertos series, del puerto paralelo, USB, etc. Con está opción podemos determinar los
parámetros de cada uno de estos dispositivos periféricos.
El uso más común es en un caso de reparación, cuando por algún motivo se daña
este control y debemos recurrir a placas externas. Con el fin de no crear un conflicto,
se debe deshabilitar el dispositivo dañado en la placa madre.

CPU PNP SETUP

Permite configurar la frecuencia base y el factor de multiplicación del

microprocesador.

PASSWORD SETTING o CHANGE PASSWORD

En esta opción puede definir la clave, para la entrada al Setup o al sistema.

IDE HDD AUTO DETECTION

Detecta en forma automática los dispositivos IDE, en los Setup actuales estos
dispositivos son detectados automáticamente sin necesidad de entrar al Setup.

SAVE & EXIT SETUP o EXIT

Solicita la confirmación de salir del Setup y almacenar los cambios realizados.

EXIT WITHOUT SAVING

Abandona el programa Setup sin efectuar el almacenamiento de los cambios

realizados.

HARDWARE MONITOR SETUP

Esta opción la encontramos en los Setup actuales y nos permite ver la temperatura del
micro y del sistema. También nos informa las RPM de los ventiladores y las tensiones
de la fuente de alimentación.
A partir de los procesadores de sexta generación (80686), los chips de memoria ROM
son del tipo EEPROM (Electricaly Erasable Programable Read Only Memory) conocidos
como Flash-BIOS, este tipo de chip es actualizable mediante software.

14
BIBLIOGRAFIA

- http://www.ecured.cu/index.php/Interrupci%C3%B3n_de_Hardware
- http://isa.uniovi.es/docencia/TiempoReal/Recursos/temas/hardware_rt.pdf
- http://www.informaticamoderna.com/Setup.htm
- http://es.kioskea.net/contents/383-interrupciones-irq-y-conflictos-del-
hardware
- es.wikipedia.org

15