El emparejamiento driver-dispositivo: match, probe y remove

Un dispositivo y su driver aparecen en momentos distintos y por caminos distintos: el firmware enumera el hardware cuando quiere, y los módulos se cargan cuando el sistema lo decide. El emparejamiento es el mecanismo que los hace encontrarse sin importar quién llegó primero. Dos disparadores independientes convergen en la misma secuencia —match, really_probe, .probe— y de ella sale un enlace vivo entre una instancia de hardware y el código que la gobierna.

Dos disparadores, un mismo encuentro

El emparejamiento se intenta en dos ocasiones simétricas. Cuando se añade un dispositivo con device_add, el core recorre los drivers del bus buscando uno que case. Cuando se registra un driver con driver_register, el core recorre los dispositivos del bus buscando cuáles case. Ambos caminos terminan en la misma comprobación: driver_match_device.

/* drivers/base/dd.c — la ultima palabra la tiene el bus */
static inline int driver_match_device(const struct device_driver *drv,
				      struct device *dev)
{
	/* si el bus no define match, todo device casa con todo driver del bus */
	return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}

Da igual el orden en que aparezcan device y driver: el que llega segundo encuentra al primero esperando en la lista del bus. Esa simetría es lo que permite cargar módulos en cualquier orden y conectar hardware en caliente.

De match a probe

Si match devuelve verdadero, el core llama a really_probe. Esta función hace una apuesta: fija dev->driver provisionalmente, ejecuta el probe del driver (o el del bus, si lo interpone) y, según el resultado, sella el enlace o lo deshace por completo.

/* drivers/base/dd.c — really_probe, esencia */
static int really_probe(struct device *dev, const struct device_driver *drv)
{
	dev->driver = drv;                  /* apuesta: este driver gobernara el device */

	if (dev->bus->probe)
		ret = dev->bus->probe(dev);     /* algunos buses interponen su probe */
	else if (drv->probe)
		ret = drv->probe(dev);          /* el caso habitual: el probe del driver */

	if (ret) {
		dev->driver = NULL;             /* la apuesta falla: se deshace todo */
		goto probe_failed;
	}

	driver_bound(dev);                  /* sella: enlaces en sysfs y notificacion */
	return 0;
}

driver_bound es el punto donde el enlace se hace oficial: crea el enlace simbólico driver en el directorio del dispositivo y el enlace inverso en el del driver, y notifica a quien escuche. A partir de ahí el dispositivo está bound y su driver lo gobierna.

flowchart TD
A[device_add] --> M{bus match}
B[driver_register] --> M
M -->|casa| P[really_probe fija dev.driver]
M -->|no casa| X[queda sin enlazar]
P --> PR[.probe del driver]
PR -->|devuelve 0| OK[driver_bound enlace sellado]
PR -->|EPROBE_DEFER| D[lista de reintento]
PR -->|otro error| X

Un driver de plataforma real

El patrón anterior rara vez se escribe a mano: los buses ofrecen envoltorios. Un platform_driver declara su tabla de compatibilidad, y module_platform_driver genera el registro y la baja. El probe recibe la instancia ya emparejada y arranca el hardware; los recursos gestionados con devm_ se liberan solos al desenlazar.

static const struct of_device_id mi_of_match[] = {
	{ .compatible = "acme,widget-v2" },
	{ }
};
MODULE_DEVICE_TABLE(of, mi_of_match);   /* deja que udev autocargue el modulo */

static int mi_probe(struct platform_device *pdev)
{
	struct mi_dev *d;

	d = devm_kzalloc(&pdev->dev, sizeof(*d), GFP_KERNEL);
	if (!d)
		return -ENOMEM;

	d->regs = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(d->regs))
		return PTR_ERR(d->regs);

	platform_set_drvdata(pdev, d);
	dev_info(&pdev->dev, "enlazado a %pOF\n", pdev->dev.of_node);
	return 0;
}

static void mi_remove(struct platform_device *pdev)
{
	/* nada que liberar: los recursos devm_ se deshacen automaticamente */
}

static struct platform_driver mi_driver = {
	.probe  = mi_probe,
	.remove = mi_remove,
	.driver = {
		.name		= "mi-widget",
		.of_match_table	= mi_of_match,
	},
};
module_platform_driver(mi_driver);

Probe diferido y enlace manual

El probe no siempre puede triunfar en el primer intento: quizá el reloj o el regulador que necesita todavía no tienen driver. Devolver -EPROBE_DEFER le dice al core “aún no, reinténtalo más tarde”, y el dispositivo vuelve a una lista que se reintenta cada vez que aparece un driver nuevo. Así, el orden de carga de módulos deja de importar.

	d->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(d->clk))
		/* si el proveedor del reloj aun no existe, esto da -EPROBE_DEFER
		   y el core reintentara el probe cuando el reloj aparezca */
		return dev_err_probe(&pdev->dev, PTR_ERR(d->clk), "sin reloj todavia\n");

El emparejamiento también puede forzarse desde userspace escribiendo en los ficheros bind y unbind del driver en sysfs. Es la vía para depurar, para ceder un dispositivo a otro driver, o para reiniciar un enlace sin recargar módulos.

# desenlazar un dispositivo de su driver, y volver a enlazarlo a mano
echo 0000:03:00.0 > /sys/bus/pci/devices/0000:03:00.0/driver/unbind
echo 0000:03:00.0 > /sys/bus/pci/drivers/nvme/bind