regmap: un único acceso a registros sobre I2C, SPI o MMIO

Muchísimos chips se venden en dos sabores: una variante I2C y una variante SPI, con un mapa de registros idéntico. Sin ayuda, escribirías la lógica del dispositivo dos veces, una por bus, y la mantendrías por duplicado para siempre. regmap es la abstracción que separa qué registro tocar de cómo llegan los bytes hasta él. Escribes regmap_read y regmap_write una sola vez, contra una interfaz de registros abstracta, y eliges el transporte con una única línea en el probe. La misma lógica sirve al chip por I2C, por SPI o mapeado en memoria, sin cambiar nada más.

El problema: el mismo chip por dos buses

Un IMU o un códec de audio típico existe como pieza I2C y como pieza SPI con los mismos registros y la misma semántica. Antes de regmap, un driver que quisiera servir a ambos arrastraba punteros a función read_reg/write_reg, una implementación por bus, y toda la lógica de dispositivo llena de indirecciones. Peor: cada driver reinventaba su propio esquema, y el árbol acumulaba decenas de variantes del mismo patrón. regmap, introducido por Mark Brown, factorizó ese patrón en una biblioteca central: el driver deja de saber por qué bus habla.

regmap_config y la inicialización por bus

Todo empieza describiendo la geometría del mapa: cuántos bits ocupa la dirección de registro, cuántos el valor, y cuál es el último registro válido.

#include <linux/regmap.h>

static const struct regmap_config sensor_regmap_config = {
	.reg_bits = 8,           /* la direccion de registro ocupa 8 bits */
	.val_bits = 8,           /* cada registro son 8 bits */
	.max_register = 0x7f,    /* ultimo registro valido */
};

Con esa misma config, la elección del transporte es una sola línea en el probe. Todo lo que viene después —la lógica del dispositivo— es idéntico:

/* variante I2C */
map = devm_regmap_init_i2c(client, &sensor_regmap_config);

/* variante SPI: misma config, misma logica despues */
map = devm_regmap_init_spi(spi, &sensor_regmap_config);

/* variante mapeada en memoria, un IP dentro del SoC */
map = devm_regmap_init_mmio(dev, base, &sensor_regmap_config);

if (IS_ERR(map))
	return PTR_ERR(map);

Cada inicializador sabe cómo enmarcar un acceso en su bus: por I2C, escribe el registro y lee con start repetido; por SPI, suele marcar lectura o escritura en el bit alto del byte de dirección; por MMIO, traduce a readl/writel sobre base más el desplazamiento. Ese detalle de transporte se declara, cuando hace falta, en la propia config:

static const struct regmap_config sensor_spi_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = 0x7f,
	.read_flag_mask = 0x80,  /* el bit alto del byte de registro marca lectura */
};

regmap_read, regmap_write, regmap_update_bits

El núcleo del API es agnóstico del bus. El valor sale por puntero y el retorno es limpio —cero o -errno—, sin la ambigüedad de SMBus, que multiplexaba dato y error en un mismo s32:

unsigned int val;
int ret;

ret = regmap_read(map, SENSOR_REG_WHOAMI, &val);
if (ret)
	return ret;

ret = regmap_write(map, SENSOR_REG_CTRL, 0x01);

/* lee-modifica-escribe bajo el candado interno del regmap */
ret = regmap_update_bits(map, SENSOR_REG_CTRL,
			 SENSOR_MODE_MASK, SENSOR_MODE_CONT);

/* rafaga contigua en una sola operacion de bus */
u8 raw[6];
ret = regmap_bulk_read(map, SENSOR_REG_DATA, raw, sizeof(raw));

regmap_update_bits merece atención: hace un lee-modifica-escribe serializado por el candado interno del regmap, así que dos hilos que toquen bits distintos del mismo registro no se pisan. Antes, ese patrón era una carrera clásica que cada driver resolvía —o no— por su cuenta.

Por qué regmap borra el transporte

La lógica del driver depende ahora de un struct regmap *, una interfaz de registros abstracta, y del bus concreto solo se decide una vez, en el probe. Las mismas quinientas líneas de lógica de dispositivo sirven a la variante I2C y a la SPI. El transporte pasa de ser una decisión que impregna todo el código a ser un plugin elegido en el borde:

flowchart TB
LOGIC[Logica del driver regmap_read y regmap_write] --> RM[regmap nucleo]
RM --> I2C[regmap-i2c]
RM --> SPI[regmap-spi]
RM --> MMIO[regmap-mmio]
I2C --> B1[Tramas I2C]
SPI --> B2[Tramas SPI]
MMIO --> B3[readl y writel]