Cómo funciona un driver: desde el bajo al alto nivel

Si no sabes aún cómo funciona un driver o controlador de hardware, aquí te lo vamos a explicar todo paso por paso, para que sepas cómo estos códigos pueden hacer que un dispositivo de hardware funcione en conjunción con tu sistema operativo.

Índice de contenidos

Para comprender mejor este artículo, deberías leer también:

¿Qué es un driver o controlador?

Un controlador o driver consiste en un conjunto de archivos que deben ser instalados para posibilitar la comunicación entre uno o varios dispositivos y el sistema operativo. Sin ellos, el sistema no podría enviar ni recibir datos del dispositivo de hardware, resultando en un mal funcionamiento. Por tanto, ya sea el controlador genérico incluido en el sistema operativo o el controlador específico proporcionado por el fabricante del dispositivo, es necesario para su correcto funcionamiento.

Numerosos dispositivos de hardware requieren controladores, como la tarjeta gráfica, el chipset, el lector de tarjetas, la impresora, la tarjeta de red, la tarjeta de sonido, entre otros. En algunos casos, un solo controlador puede ser utilizado por múltiples unidades distintas. Por ejemplo, un pendrive empleará el controlador USB para su funcionamiento, lo que significa que no es necesario instalar otro controlador al cambiar de pendrive.

El controlador se encarga de gestionar las solicitudes de acceso al dispositivo, ya sea desde éste o hacia él. De lo contrario, el sistema operativo no sería capaz de interactuar con el dispositivo, dejando de reconocer su existencia. Además, el controlador también debe definir los mensajes y los mecanismos empleados para las comunicaciones.

Inicialmente, los controladores se solían desarrollar en lenguaje ensamblador en lugar de utilizar lenguajes de programación de alto nivel. Esto brindaba la posibilidad de acceder al hardware a un nivel más bajo y establecer una comunicación directa con la CPU para controlar el dispositivo correspondiente. Sin embargo, en la actualidad, debido a la creciente complejidad de los controladores, se tiende a escribirlos principalmente en lenguajes de programación como C o C++. Estos lenguajes también permiten acceder a un nivel más bajo en ciertos casos, lo que los hace adecuados para el desarrollo de controladores y ofrecen un rendimiento óptimo. No obstante, algunos controladores podrían incluir secciones escritas en lenguaje ensamblador con el objetivo de maximizar el rendimiento.

Por ejemplo, aquí puedes ver un caso de un driver muy simple escrito en C para el kernel Linux que se encarga de hacer titilar un LED conectado a los GPIO de una placa base:

*/Ejemplo de driver simple para ProfesionalReview/* 

#include <linux/init.h> 
#include <linux/module.h> 
#include <linux/gpio.h> 
#include <linux/timer.h> 

MODULE_LICENSE("Ninguna"); 
MODULE_AUTHOR("Isaac"); 
MODULE_DESCRIPTION("Driver para hacer parpadear un LED conectado a los GPIO"); 

#define LED_GPIO 17 // Número del pin GPIO al que está conectado el LED 
#define BLINK_PERIOD_MS 500 // Periodo de parpadeo del LED en milisegundos 

static struct timer_list blink_timer; 
static int led_state = 0; 

// Función para cambiar el estado del LED 
static void toggle_led(unsigned long data) 
{ 
led_state = !led_state; gpio_set_value(LED_GPIO, led_state); 
mod_timer(&blink_timer, jiffies + msecs_to_jiffies(BLINK_PERIOD_MS)); } 

// Función de inicialización del driver 
static int __init led_driver_init(void) { 
int ret; 

// Configurar el pin GPIO para el LED como salida 
ret = gpio_request_one(LED_GPIO, GPIOF_OUT_INIT_LOW, "LED"); 
if (ret < 0) { pr_err("No se pudo configurar el pin GPIO %d\n", LED_GPIO); 
return ret; } 

// Configurar y activar el temporizador para el parpadeo del LED 
setup_timer(&blink_timer, toggle_led, 0); 
mod_timer(&blink_timer, jiffies + msecs_to_jiffies(BLINK_PERIOD_MS)); 
pr_info("Driver del LED iniciado\n"); 
return 0; } 

// Función de limpieza y descarga del driver 
static void __exit led_driver_exit(void) { 

// Detener y eliminar el temporizador del_timer(&blink_timer); 
// Liberar el pin GPIO del LED gpio_free(LED_GPIO); 

pr_info("Driver del LED finalizado\n"); } 
module_init(led_driver_init); 
module_exit(led_driver_exit);

Como ves, se trata simplemente de un código que describe qué es lo que tiene que hacer el hardware cuando se haga uso de él. Entonces, cuando el sistema operativo, a través del kernel, necesite usar un periférico o componente, usará el driver para «comunicarse» con el hardware y obtener el resultado que se busca. En este caso simplemente hacer titilar un LED…

En ocasiones, los controladores o drivers no se limitan únicamente a dispositivos de hardware físicos o tangibles, sino que también pueden existir para dispositivos virtuales. Estos se refieren a emulaciones de hardware generadas mediante software.

Desarrollo de un driver

Recuerda que a veces los fabricantes de hardware no dan detalles y muchos controladores libres o de código abierto tienen que ser diseñados usando ingeniería inversa. Además, la etapa de desarrollo consta de diferentes puntos, como:

Identificación del hardware: se debe identificar el dispositivo de hardware para el cual se desea desarrollar el driver. Puede ser una tarjeta gráfica, un controlador de red, un dispositivo de almacenamiento, entre otros.
Investigación y documentación: implica investigar y recopilar información relevante sobre el dispositivo de hardware. Esto puede incluir el fabricante, el modelo, las especificaciones técnicas y las interfaces utilizadas para la comunicación.
Entorno de desarrollo: esto puede incluir la instalación de herramientas de compilación, bibliotecas y el sistema operativo compatible con el dispositivo de hardware.
Especificación del driver: define la funcionalidad que se espera del driver. Esto implica determinar las operaciones que el driver debe realizar, como enviar y recibir datos, configurar parámetros, manejar interrupciones, entre otros.
Escribir el código: utilizando un lenguaje de programación adecuado como C o C++, escribe el código del driver. Esto incluye la implementación de las funciones necesarias para comunicarse con el dispositivo de hardware, realizar operaciones específicas y manejar eventos.
Compilación: compila el código fuente del driver para generar un archivo ejecutable o una biblioteca que se pueda cargar en el sistema operativo.
Instalación del driver: instala el driver en el sistema operativo. Esto generalmente implica copiar el archivo del driver en una ubicación específica del sistema o utilizar un instalador proporcionado por el fabricante del dispositivo.
Carga del driver: carga el driver en el sistema operativo, ya sea como parte del kernel o como un módulo del kernel, para que esté disponible para su uso. Esto puede implicar el uso de comandos o herramientas específicas según el sistema operativo.
Pruebas y depuración: realiza pruebas exhaustivas del driver para verificar su funcionamiento correcto. Esto puede incluir pruebas de comunicación, pruebas de rendimiento y pruebas de estabilidad. Si se encuentran errores o problemas, se debe depurar el código y realizar ajustes necesarios.
Lanzamiento: ahora es cuando la versión del driver se libera para que los usuarios puedan descargarlo, instalarlo y usarlo.
Mantenimiento y actualización: el driver puede requerir mantenimiento y actualizaciones periódicas. Esto puede ser para agregar nuevas funcionalidades, corregir errores o garantizar la compatibilidad con versiones actualizadas del sistema operativo o del hardware.

Un ejemplo de driver USB

Por poner un ejemplo, a la hora de conectar un dispositivo USB, como puede ser un pendrive, lo que sucede es lo siguiente:

Conexión física: se conecta un dispositivo al puerto USB del ordenador mediante un cable USB. El dispositivo puede ser, por ejemplo, una impresora, una memoria USB o un teléfono móvil.
Detección del dispositivo: el controlador del bus USB del sistema operativo detecta la conexión del dispositivo y genera una interrupción para notificar que un nuevo dispositivo USB ha sido conectado.
Enumaración del dispositivo: el driver del bus USB inicia el proceso de enumeración, que implica asignar una dirección única al dispositivo y obtener información básica sobre sus capacidades y características.
Identificación del dispositivo: el sistema operativo consulta el descriptor de dispositivo del dispositivo conectado para obtener información detallada sobre el fabricante, el modelo, los protocolos de comunicación y otros atributos.
Carga del controlador: basándose en la información proporcionada por el descriptor de dispositivo, el sistema operativo busca y carga el controlador o driver USB correspondiente para ese dispositivo en particular. Este controlador es responsable de establecer la comunicación con el dispositivo y proporcionar las funcionalidades necesarias.
Configuración del dispositivo: el controlador USB envía comandos de configuración al dispositivo para establecer la comunicación y configurar sus características específicas. Esto puede incluir la configuración de velocidades de transferencia, modos de operación o parámetros de energía.
Interacción con el dispositivo: una vez que el dispositivo ha sido configurado correctamente, el controlador USB establece canales de comunicación y proporciona una interfaz para que el sistema operativo y las aplicaciones se comuniquen con el dispositivo. Esto permite enviar y recibir datos, enviar comandos de control y realizar operaciones específicas según las capacidades del dispositivo.
Desconexión del dispositivo: cuando se desconecta el dispositivo del puerto USB, el controlador USB detecta esta acción y notifica al sistema operativo que el dispositivo ha sido removido. El controlador realiza las tareas necesarias para liberar los recursos asignados al dispositivo y finaliza la comunicación adecuadamente.

Es importante destacar que este es un proceso general y que los detalles específicos pueden variar según el sistema operativo, el tipo de dispositivo y el controlador USB utilizado. Sin embargo, en líneas generales, estos son los pasos fundamentales involucrados en el funcionamiento de un driver USB al conectar un dispositivo al puerto USB de un ordenador.

Y ahora, veamos un ejemplo de driver USB para Linux. Se trata de un ejemplo básico de un código de driver USB en C para Linux que configura el dispositivo y establece una comunicación simple, pero para que lo comprendas basta:

MODULE_LICENSE("Ninguna");
MODULE_AUTHOR("Isaac");
MODULE_DESCRIPTION("Driver USB de ejemplo para Linux - ProfesionalReview");

#include <linux/module.h>
#include <linux/usb.h>
#include <linux/kernel.h>

// IDs de Vendor y Product del dispositivo USB
#define USB_VENDOR_ID 0x1234
#define USB_PRODUCT_ID 0x5678

// Estructura para almacenar la información del dispositivo USB
struct usb_device_id my_usb_device_id_table[] = {
    { USB_DEVICE(USB_VENDOR_ID, USB_PRODUCT_ID) },
    { },
};
MODULE_DEVICE_TABLE(usb, my_usb_device_id_table);

// Función de inicialización del driver
static int my_usb_driver_probe (struct usb_interface *interface, const struct usb_device_id *id)
{
    struct usb_device *udev = interface_to_usbdev(interface);

    // Información básica del dispositivo
    pr_info("Dispositivo USB conectado --> Vendor ID: 0x%04X, Product ID: 0x%04X\n",
            udev->descriptor.idVendor, udev->descriptor.idProduct);

    // Configuración del dispositivo (pueden ser necesarios más pasos para una funcionalidad completa)
    // ...

    return 0; // Éxito
}

// Función de limpieza y descarga del driver
static void my_usb_driver_disconnect (struct usb_interface *interface)
{
    struct usb_device *udev = interface_to_usbdev(interface);

    pr_info(<"Dispositivo USB desconectado --> Vendor ID: 0x%04X, Product ID: 0x%04X\n",
            udev->descriptor.idVendor, udev->descriptor.idProduct);

    // Limpiar y liberar recursos del dispositivo (si es necesario)
    // ...
}

// Estructura del controlador USB
struct usb_driver my_usb_driver = {
    .name = "my_usb_driver",
    .id_table = my_usb_device_id_table,
    .probe = my_usb_driver_probe,
    .disconnect = my_usb_driver_disconnect,
};

// Función de inicialización del módulo del driver
int __init my_usb_driver_init(void)
{
    int ret;

    // Registrar el controlador USB
    ret = usb_register(&my_usb_driver);
    if (ret)
        pr_err(<"Error al registrar el driver USB: %d\n", ret);

    return ret;
}

// Función de limpieza y descarga del módulo del driver
static void __exit my_usb_driver_exit(void)
{
    // Desregistrar el controlador USB
    usb_deregister(&my_usb_driver);
}

module_init(my_usb_driver_init);
module_exit(my_usb_driver_exit);

Isaac22 julio, 2023

7 minutos de lectura aproximada.