Qué es DMA: el dispositivo lee la RAM sin la CPU

Un SSD NVMe de 2026 mueve más de diez gigabytes por segundo. Si la CPU tuviera que copiar cada palabra desde un registro del dispositivo a la RAM con un bucle de instrucciones de E/S, no le quedaría un solo ciclo para ejecutar programas. DMA es la respuesta: el dispositivo se convierte en maestro del bus y escribe la memoria él solo. Pero para lograrlo necesita ver la RAM con sus propios ojos —direcciones de bus—, que no son las direcciones virtuales del kernel.

De la E/S programada al DMA

En la E/S programada (PIO) la CPU es la que mueve cada byte: ejecuta una instrucción de lectura o escritura por cada palabra que cruza entre el dispositivo y la memoria. Es correcto, pero letal para el rendimiento: un núcleo entero se consume copiando datos que nunca mira.

/* PIO: la CPU ejecuta un acceso por cada palabra transferida */
static void leer_pio(struct mi_dev *d, u32 *buf, size_t n)
{
	size_t i;
	for (i = 0; i < n; i++)
		buf[i] = readl(d->regs + REG_DATA);  /* un acceso de CPU por palabra */
}

Con DMA (Direct Memory Access) la CPU delega. Le dice al dispositivo dónde está el buffer y cuánto transferir, arranca la operación y se marcha a hacer otra cosa. El motor de DMA del propio dispositivo bombea los datos hacia la RAM y, al terminar, levanta una interrupción. La CPU solo trabaja al principio y al final; el trasiego de bytes ocurre en paralelo con el resto del sistema.

/* DMA: la CPU solo arranca; el dispositivo hace el resto y avisa al terminar */
static void arrancar_dma(struct mi_dev *d, dma_addr_t dst, size_t len)
{
	writel(lower_32_bits(dst), d->regs + REG_DMA_ADDR_LO);
	writel(upper_32_bits(dst), d->regs + REG_DMA_ADDR_HI);
	writel(len,                d->regs + REG_DMA_LEN);
	writel(DMA_GO,             d->regs + REG_DMA_CTRL);  /* y la CPU queda libre */
}

flowchart LR
subgraph PIO
  C1[CPU] -->|copia cada palabra| R1[RAM]
  D1[Dispositivo] -->|registro de datos| C1
end
subgraph DMA
  C2[CPU] -->|programa direccion y longitud| D2[Dispositivo]
  D2 -->|transfiere solo| R2[RAM]
  D2 -. interrupcion al terminar .- C2
end

El dispositivo como maestro del bus

En PCI Express, un dispositivo puede iniciar transacciones de memoria en la malla del bus, igual que hace la CPU. A eso se le llama ser maestro del bus (bus master). El dispositivo emite lecturas y escrituras que llegan al controlador de memoria sin que la CPU intervenga. Deja de existir un único iniciador: la CPU es solo uno más entre varios.

/* habilitar al dispositivo PCI para que inicie transacciones de memoria */
pci_set_master(pdev);   /* activa el bit Bus Master en el registro de comando PCI */

Históricamente el motor de DMA era un chip central (el 8237 de la era ISA) que otros dispositivos pedían prestado; hoy cada dispositivo serio lleva su propio motor —first-party DMA— y programa sus transferencias mediante descriptores en memoria. El resultado es el mismo: alguien que no es la CPU escribe en tu RAM.

Por qué no valen las direcciones virtuales del kernel

Aquí está el corazón de todo el nivel. El puntero que devuelve kmalloc es una dirección virtual del kernel, y solo tiene sentido tras pasar por la MMU de la CPU y sus tablas de página. El dispositivo no atraviesa la MMU de la CPU: pone una dirección cruda en el bus que el controlador de memoria —o un IOMMU— interpreta. Esa dirección es una dirección de bus o dirección de DMA, y puede no coincidir con la física.

void *va = kmalloc(len, GFP_KERNEL);   /* direccion VIRTUAL del kernel */
writel(virt_to_phys(va), d->regs + REG_DMA_ADDR_LO);  /* MAL: ni virtual ni fisica sirven */

Entregar virt_to_phys(va) al dispositivo parece razonable en un x86 sencillo, donde la dirección de bus suele igualar a la física. Pero es incorrecto y no portable: ignora los desplazamientos de bus de muchos SoC, la traducción de un IOMMU y los buffers de rebote (nivel 27.3). La forma correcta de obtener la dirección que el dispositivo debe usar es la DMA API (nivel 27.2), nunca virt_to_phys.

dma_addr_t: la dirección que ve el dispositivo

El tipo dma_addr_t representa una dirección de bus. Es opaco: lo guardas, lo programas en los registros o descriptores del dispositivo, y jamás lo desreferencias desde la CPU (no es un puntero válido para el núcleo). Su anchura la fija la plataforma con CONFIG_ARCH_DMA_ADDR_T_64BIT; un dispositivo de 32 bits solo podrá recibir valores por debajo de los 4 GiB, un límite que se declara con la máscara de DMA (nivel 27.5).

En la práctica, un dispositivo rápido no recibe una sola dma_addr_t por transferencia sino que lee un anillo de descriptores en memoria: cada descriptor lleva una dirección de bus, una longitud y unas banderas, y el dispositivo los consume en orden. La CPU rellena descriptores y toca un registro “timbre” (doorbell); el dispositivo transfiere y marca cada descriptor como completado, levantando una interrupción cada tantos para amortizar su coste. Ese patrón —anillo más timbre más interrupción— es el esqueleto de casi todo driver de red o almacenamiento, y lo construirás con la DMA API en el nivel 27.2.