PDF de programación - doc manual linux controladores raton

Controladores de Ratón

Alan Cox
[email protected]

Controladores de Ratón
by Alan Cox

Copyright © 2000 by Alan Cox

Esta documentación es software libre; puedes redistrubuirla y/o modificarla bajo los términos de la GNU General Public License tal como ha sido
publicada por la Free Software Foundation; por la versión 2 de la licencia, o (a tu elección) por cualquier versión posterior.
Este programa es distribuido con la esperanza de que sea útil, pero SIN NINGUNA GARANTIA; sin incluso la garantía implicada de
COMERCIABILIDAD o ADECUACCION PARA UN PROPOSITO PARTICULAR. Para más detalles refiérase a la GNU General Public
License.
Debería de haber recibido una copia de la GNU General Public License con este programa; si no es así, escriba a la Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Para más detalles véase el archivo COPYING en la distribución fuente de Linux.

Table of Contents

1. Introducción ...........................................................................................................................................1
2. Un controlador simple de ratón............................................................................................................3
3. Depurando el Controlador del Ratón ................................................................................................11
4. E/S Asíncrona.......................................................................................................................................15
5. Sobre la traducción..............................................................................................................................18

iii

List of Tables

1-1. Codificación de Datos del Ratón ..........................................................................................................1

iv

Chapter 1. Introducción

Publicación Anterior: Algunas partes de este documento aparecieron primero en Linux Magazine
bajo una exclusividad de noventa dias.

Los ratones son conceptualmente uno de los interfaces de dispositivos más simples en el sistema
operativo Linux. No todos los ratones son manejados por el núcleo. Es vez de eso, hay una abstracción
de dos capas.

Los controladores de ratón del núcleo y los controladores del espacio de usuario para los ratones serie
son todos administrados por un demonio del sistema llamado gpm - el controlador de propósito general
de ratón. gpm maneja la acción de cortar y pegar en los textos de las consolas. Suministra una biblioteca
general para aplicaciones que conocen el ratón y administra la compartición de los servicios del ratón
con la interfaz de usuario del X Window System.

Algunas veces un ratón habla un protocolo suficientemente complicado como para que sea manejado por
el propio Gpm. La mayoría de los controladores de ratón siguen una interfaz común llamada protocolo
de bus del ratón.

Cada lectura de un dispositivo de una interfaz del bus de ratón retorna un bloque de datos. Los tres
primeros bytes de cada lectura están definidos de la siguiente forma:

Table 1-1. Codificación de Datos del Ratón

Byte 0
Byte 1

Byte 2

0x80 + los botones actualmente pulsados.
Un valor con signo para el desplazamiento en la
posición X
Un valor con signo para el desplazamiento en la
posición Y

Una aplicación puede escoger leer más de 3 bytes. El resto de los bytes serán cero, o quizás
opcionalmente retornen alguna información específica del dispositivo.

Los valores de la posición son truncados si es que exceden del rango de los 8 bits (que es -127 <= delta
<= 127). Como el valor -128 no encaja en un byte no es permitido.

Los botones son numerados de izquierda a derecha como 0, 1, 2, 3.. y cada botón establece el bit
relevante. Por lo tanto un usuario presionando los botonoes de la izquierda y de la derecha en un ratón de
tres botones establecerán los bits 0 y 2.

Todos los ratones están requeridos a soportar la operación poll. Sería algo verdaderamente muy bonito
si todos los usuarios de un controlador de un dispositivo usaran poll para esperar a que tuvieran lugar

1

los eventos.

Finalmente el soporte asíncrono de E/S de los ratonoes. Este es un tópico que todavía no hemos cubierto
pero que explicaré más tarde, después de mirar en un controlador simple de ratón.

Chapter 1. Introducción

2

Chapter 2. Un controlador simple de ratón

Primero necesitaremos inicializar las funciones para nuestro dispositivo ratón. Para mantener esto
simple, nuestro dispositivo imaginario de ratón tiene tres puertos de E/S en las direcciones de E/S 0x300
y siempre vivirá en la interrupción 5. Los puertos serán la posición X, la posición Y y los botones, en
este orden.

#define OURMOUSE_BASE

0x300

static struct miscdevice our_mouse = {

OURMOUSE_MINOR, "ourmouse", &our_mouse_fops

};

__init ourmouse_init(void)
{

if(check_region(OURMOUSE_BASE, 3))

return -ENODEV;

request_region(OURMOUSE_BASE, 3, "ourmouse");

misc_register(&our_mouse);
return 0;

}

El miscdevice es nuevo aquí. Linux normalmente divide los dispositivos por su número mayor, y cada
dispositivo tiene 256 unidades. Para cosas como los ratones esto es extremadamente derrochador para la
existencia de un dispositivo que es usado para acumular todos los dispositivos individuales sueltos que
las computadoras tienden a tener.

Los números menores en este espacio son asignados por un código central, aunque puedes mirar en el el
archivo Documentation/devices.txt del núcleo y coger uno libre para un uso de desarrollo. Este
archivo de núcleo también contiene instrucciones para registrar un dispositivo. Esto puede cambiar con
respecto al tiempo y es, por lo tanto, una buena idea obtener primero una copia actualizada de este
archivo.

Nuestro código es entonces bastante simple. Chequeamos si nadie más ha tomado nuestro espacio de
direcciones. Habiéndolo hecho, lo reservamos para asegurarnos de que nadie pisa a nuestro dispositivo
mientras estamos probando otros dispositivos del bus ISA. Ya que una prueba quizás confunda a nuestro
dispositivo.

Entonces le decimos al controlador misc que queremos nuestro propio número menor. También cogemos
nuestro nombre (que es usado en /proc/misc) y establecemos las operaciones de archivo que van a ser
usadas. Las operaciones de archivo trabajan exactamente como las operaciones de archivo para registrar
un dispositivo de carácter normal. El dispositivo misc simplemente actúa como redirector para las
peticiones.

3

Lo siguiente, en orden a ser capaz de usar y probar nuestro propio código, es que necesitamos añadir
algún código de módulo para soportarlo. Esto también es bastante simple:

Chapter 2. Un controlador simple de ratón

#ifdef MODULE

int init_module(void)
{

if(ourmouse_init()<0)

return -ENODEV:

return 0;

}

void cleanup_module(void)
{

misc_deregister(&our_mouse);
free_region(OURMOUSE_BASE, 3);

}

#endif

El código del módulo suministra las dos funciones normales. La función init_module es llamada
cuando el módulo es cargado. En nuestro caso simplemente llama a la función de inicialización que
escribimos y retorna un error si esta falla. Esto asegura que el módulo sólo será cargado si fue
correctamente configurado.

La función cleanup_module es llamada cuando el módulo es descargado. Devolvemos nuestra entrada
de dispositivo misceláneo, y entonces liberamos nuestros recursos de E/S. Si no liberamos nuestros
recursos de E/S entonces la siguiente vez que el módulo es cargado pensaremos que alguien tiene este
espacio de E/S.

Una vez que misc_deregister ha sido llamada cualquier intento de abrir el dispositivo del ratón
fallará con el error ENODEV (No tal dispositivo).

Lo siguiente que necesitamos es rellenar nuestras operaciones de archivo. Un ratón no necesita muchas
de estas. Necesitamos suministrar open (abrir), release (liberar), read (leer) y poll (encuesta). Esto hace
una bonita y simple estructura:

struct file_operations our_mouse_fops = {

owner: THIS_MODULE,
read: read_mouse,
write: write_mouse,
poll: poll_mouse,
open: open_mouse,
release: close_mouse,

/* Automática administración de uso */
/* Puedes leer un ratón */
/* Esto debería de hacer un montón */
/* Encuesta */
/* Llamado en open */
/* Llamado en close */

};

4

Chapter 2. Un controlador simple de ratón

No hay nada particularmente especial necesitado aquí. Suministramos funciones para todas las
operaciones relevantes o requiridas y algunas pocas más. No hay nada que nos pare para suministrar una
función ioctl para este ratón. Verdaderamente si tienes un ratón configurable quizás sea muy apropiado
suministrar interfaces de configuración a través de llamadas ioctl.

La sintaxis que usamos no es la del C estándar. GCC suministra la habilidad de inicializar campos por el
nombre, y esto generalmente hace la tabla de métodos mucho más fácil de leer y contar a través de los
punteros NULL y de recordar el orden a mano.

El dueño del campo es usado para administrar el bloqueo de la carga y descarga de un módulo. Esto es
obviamente importante para que un módulo no sea descargado mientras esté siendo usado. Cuando tu
dispositivo es abierto, el módulo especificado por "owner" es bloqueado. Cuando el módulo es
finalmente liberado es desbloqueado.

Las rutinas open y close necesitan administrar el habilitamiento y deshabilitamiento de las interrupciones
para el ratón y también el parar el ratón siendo descargado cuando no se requiere más.

static int mouse_users = 0;
static int mouse_dx = 0;
static int mouse_dy = 0;
static int mouse_event = 0;

/* Cuenta de Usuarios */
/* Cambios de Posición */

/* El ratón se movió */

static int open_mouse(struct inode *inode, struct file *file)
{

if(mouse_users++)
return 0;

if(request_irq(mouse_intr, OURMOUSE_IRQ, 0, "ourmouse", NULL))
{

mouse_users--;
return -EBUSY;

}
mouse_dx = 0;
mouse_dy = 0;
mouse_event = 0;
mouse_buttons = 0;

return 0;
}

La función open tiene que hacer una pequeña cantidad de tareas domésticas. Mantenemos una cuenta del
número de veces que el ratón está ab