Cómo sabe el kernel qué hardware tiene mi teléfono
Qué es un device tree, por qué un teléfono lo necesita y una PC no, y cómo el bootloader arma el que recibe el kernel, contado con los datos reales de mi OnePlus 10 Pro.
En la entrada anterior escribí 228 líneas de device tree para mi OnePlus 10 Pro y lo describí en una frase: el archivo que le dice al kernel qué hardware hay. Mientras lo escribía me di cuenta de que esa frase no alcanzaba, y de que la pregunta de fondo era justo la que me trajo aquí: cómo sabe el kernel qué hardware tiene. Así que antes de intentar arrancar nada, vale la pena detenerse en qué es un device tree, por qué existe y por qué el que recibe el kernel de Android no es ningún archivo que puedas abrir.
Parte 1: cómo empecé a portar Omarchy a mi OnePlus 10 Pro
Cómo empecé a portar Omarchy a mi OnePlus 10 Pro
Conozco Linux como sistema operativo, pero el kernel siempre fue otro mundo. Para entender cómo se encuentran el hardware y el software, quiero correr Omarchy en un OnePlus 10 Pro que nadie ha portado. Primera parte: preparar todo y aprender lo básico sin flashear nada.
Por qué el kernel no puede descubrir el hardware de un teléfono
En una PC, el kernel puede descubrir casi todo el hardware por su cuenta. El firmware de la placa madre le entrega unas tablas (se llaman ACPI) que describen la máquina, y los buses a los que se conectan las tarjetas, como PCI, se pueden recorrer preguntando "¿quién está aquí?": cada dispositivo responde con quién es. Por eso el mismo kernel arranca en miles de computadoras distintas sin saber de antemano en cuál está, y por eso nunca tuve que pensar en esto.
En un teléfono no pasa eso. El controlador del almacenamiento de mi teléfono vive en la dirección de memoria 0x1d84000, y ahí se queda, callado. No hay bus que recorrer ni dispositivo que se presente. Para usarlo, el kernel tiene que saber varias cosas que nadie le va a anunciar: que en esa dirección hay un controlador de almacenamiento, por qué interrupción avisa (la señal con la que un dispositivo le dice al procesador "terminé, hazme caso"), qué relojes necesita (las señales que marcan el ritmo de cada bloque del chip) y qué reguladores le dan su voltaje. Si no lo sabe, para él ese controlador simplemente no existe.
Durante años, en los chips ARM (la familia de los teléfonos) la respuesta fue escribir esa información en C: un archivo por placa dentro del propio kernel. Con cientos de placas eso se volvió inmanejable, y alrededor de 2011 se terminó de adoptar la alternativa que ya usaban otras arquitecturas: describir el hardware en un archivo aparte, que el bootloader le entrega al kernel al arrancar. Eso es el device tree.
Cómo se lee un device tree, con el almacenamiento como ejemplo
Es literalmente un árbol de nodos con propiedades, escrito en texto y compilado a un formato binario (el DTB) antes de dárselo al kernel. Este es el nodo del controlador de almacenamiento en la descripción del SM8450 que trae mainline, recortado:
ufs_mem_hc: ufshc@1d84000 {
compatible = "qcom,sm8450-ufshc", "qcom,ufshc", "jedec,ufs-2.0";
reg = <0 0x01d84000 0 0x3000>;
interrupts = <GIC_SPI 265 IRQ_TYPE_LEVEL_HIGH>;
phys = <&ufs_mem_phy>;
...
};
ufshc@1d84000es el nombre del nodo, con su dirección. Es la misma que vi en la captura de Android.regdice dónde están sus registros y cuánto ocupan. Los registros son pequeñas zonas de memoria por las que el software controla un dispositivo: escribir en una le da una orden, leer otra le pregunta su estado.interruptsdice cuál es su interrupción.&ufs_mem_phyes una referencia a otro nodo, el de su PHY: la parte que maneja las señales eléctricas hacia el chip de memoria. Así se conecta el árbol: los nodos se apuntan entre sí para decir "este reloj", "este regulador", "este PHY".compatiblees la propiedad más importante. Es la lista de nombres con los que el kernel busca un driver, del más específico al más genérico. El driverufs-qcomdice que maneja"qcom,ufshc", así que se engancha a este nodo. Es el mismo módulo que, según la entrada anterior, el initramfs tendría que cargar antes de abrir el sistema.
El fabricante del chip y el del teléfono describen partes distintas
Lo que más me ayudó a entenderlo fue ver cómo se reparte el trabajo entre dos archivos. La descripción del chip (un archivo .dtsi) declara todo lo que viene dentro del SM8450, pero mucho de eso viene apagado. El PHY del USB, por ejemplo:
usb_1_hsphy: phy@88e3000 {
compatible = "qcom,sm8450-usb-hs-phy", "qcom,usb-snps-hs-7nm-phy";
reg = <0 0x088e3000 0 0x400>;
status = "disabled";
...
};
El chip lo trae, pero no sabe de qué reguladores se alimenta en cada teléfono, porque eso lo decidió el fabricante al diseñar su placa. Así que lo deja en disabled, y la descripción de cada teléfono (un .dts) lo completa y lo enciende. En el Galaxy S22:
&usb_1_hsphy {
vdda-pll-supply = <&vreg_l5b_0p88>;
vdda18-supply = <&vreg_l1c_1p8>;
vdda33-supply = <&vreg_l2b_3p07>;
status = "okay";
};
&usb_1_hsphy no crea un nodo nuevo: abre el que ya declaró el chip y le agrega lo que falta. Escribir el device tree de un teléfono es, en buena parte, eso: ir abriendo nodos del chip, decir cómo están conectados en esta placa y encenderlos. Cuando seguí los reguladores del PHY en la descripción de Android salieron exactamente esas tres fuentes de voltaje, porque el S22 y el 10 Pro parten de la misma placa de pruebas de Qualcomm.
En Android, el bootloader arma el device tree al arrancar
Aquí viene lo que no esperaba. En el teléfono, con Android, no hay un archivo que sea "el device tree del OnePlus 10 Pro". El que recibe el kernel lo arma ABL, el bootloader, en el momento de arrancar, a partir de tres fuentes:
- El DTB base, dentro de una partición de arranque llamada
vendor_boot. Describe el chip, igual que el.dtside mainline, pero en el vocabulario del kernel de Qualcomm: ahí el SM8450 se llamawaipio. En mi teléfono hay cuatro, uno por cada revisión del chip, y ABL elige el suyo con los números que identifican al chip. - Un overlay de la placa, dentro de otra partición,
dtbo. Un overlay es como un parche: se aplica encima del árbol base y lo modifica. La partición trae doce, incluidos los de placas de desarrollo de OnePlus, y ABL elige el suyo con el número que identifica a la placa. Ese overlay agrega el modelo, describe el panel y el resto de lo que soldó OnePlus. - Lo que ABL agrega por su cuenta: cuánta memoria hay, la línea de comandos del kernel (las opciones con las que arranca, como los argumentos de un programa) y lo que detectó al encender, como qué panel tiene montado este teléfono en particular.
Cómo arma ABL el device tree de mi teléfono
Así arma el bootloader el device tree de mi teléfono.
- SoC
vendor_boot
DTB base, el chip (waipio)
- Placa
dtbo
Overlay de OnePlus, elegido por board-id
board-id 0x10008 · coincide
- ABL
Bootloader
Lo que inyecta al arrancar
Árbol que recibe el kernel
= /sys/firmware/fdt
- SoC/
- Placamodel = "Qualcomm Technologies, Inc. Waipio MTP with PM8010, wly"
- Placacompatible = "qcom,waipio-mtp", "qcom,waipio", "qcom,mtp"
- Placaqcom,board-id = <0x10008 0x00>
- SoCmemory
- ABLreg = <…> /* 12 GB */
- SoCchosen
- ABLbootargs = "… qcom,mdss_dsi_panel_samsung_amb670yf07_1440_3216_dsc_cmd … synaptics-s3908 …"
- SoCreserved-memory
- SoChyp_region@80000000
- SoC/* …y 38 regiones más */
- SoCsoc@0
- SoCufshc@1d84000
- SoChsphy@88e3000
- Placa/* panel Samsung AMB670YF07, 8 timings */
Simplificado: unos cuantos de los 3171 nodos del árbol en vivo, con sus valores reales (los … abrevian). Las capas del chip y de la placa coinciden con el vendor_boot y el dtbo de la 1302; el árbol final, en cambio, no guarda de dónde vino cada cosa.
Árbol completo: el DTB base, el overlay de la placa y lo que inyectó ABL.
El kernel deja ver el resultado final en /sys/firmware/fdt. Por eso valió tanto la pena el root de la entrada anterior: las particiones me daban las piezas por separado, pero solo con root pude leer la versión ya armada, con la memoria, la línea de comandos y el panel que eligió el bootloader. Esas 39 213 líneas son lo que el kernel de Android cree que es la verdad, y lo que el kernel mainline va a tener que reproducir.
El panel es un buen ejemplo de cómo se reparten las capas. El overlay describe el panel con ocho modos de pantalla distintos, y es el bootloader, al arrancar, quien dice en la línea de comandos cuál está montado: samsung_amb670yf07_1440_3216_dsc_cmd. Con el táctil pasa algo parecido: Android trae drivers para tres controladores distintos, y la línea de comandos es la que dice que este teléfono tiene un Synaptics S3908.
Por qué el device tree de Android no sirve para el kernel oficial de Linux
Mi primera idea fue la obvia: tomar ese árbol y dárselo al kernel mainline. No funciona, por varias razones.
- El vocabulario es otro. El kernel que trae el teléfono no es mainline: es una versión de Qualcomm, modificada después por OnePlus. Su device tree usa otros nombres en los
compatible(waipioen lugar desm8450) y otras propiedades: el PHY del USB que en Android pide un regulador llamadovdd, en mainline lo pide comovdda-pll. Los drivers de mainline no reconocerían casi nada. - Los números no se pueden copiar. El árbol de Android está compilado, y las referencias entre nodos ya no son nombres como
&tlmmsino números (se llaman phandles). El botón de volumen, por ejemplo, dicegpios = <0x5a9 0x06 0x01>, y ese0x5a9solo significa algo dentro de ese árbol. Otros números sí sirven: el proyecto tiene una regla de nunca copiar números de interrupción entre chips distintos, pero aquí el chip es el mismo, así que las interrupciones de Android sí son las del hardware. - No hay capas. En mainline, cada teléfono es un solo archivo que incluye la descripción del chip y se compila junto con el kernel. Lo que en Android aportan el overlay y el bootloader, ahí lo tengo que escribir yo, a mano, en el vocabulario de mainline.
Así que el árbol de Android no es algo que se copia: es la referencia contra la que se compara. El PHY del USB sirve de ejemplo de cómo fue esa traducción, y para seguirlo hay que saber un poco de cómo se reparte la energía en el teléfono. Los voltajes los dan los PMIC, chips dedicados a la energía; este teléfono tiene varios, y cada uno tiene muchos reguladores numerados (los LDO son un tipo de regulador). En los Snapdragon, además, Linux no maneja esos reguladores directamente: se los pide a un pequeño procesador dedicado a la energía, que junta los pedidos de todos y decide, por medio de un protocolo llamado RPMh.
En el árbol de Android, el nodo hsphy@88e3000 pide tres alimentaciones, y cada una apunta a su regulador con un phandle. Así fue la traducción de la primera, en dos pasos:
- Lo que vi en Android. La entrada
vddapunta a un phandle. Buscando el nodo que tiene ese número llegué a un regulador llamadopm8350_l5, con un voltaje de 0.88 a 0.912 V. Ese nodo trae además el nombre con el que Linux se lo pide al procesador de energía:ldob5, que se lee "LDO 5 del PMICb". - Lo que comprobé en mainline. Ahí los reguladores se declaran agrupados por PMIC: un bloque marcado como PMIC
b(el PM8350) con un nodoldo5adentro. Mainline arma con esas dos piezas el mismo nombre,ldob5, así que es el mismo regulador. En el S22 ese nodo se llamavreg_l5b_0p88, y su voltaje coincide: 0.88 V.
Las otras dos entradas se resolvieron igual: el nombre que usa el procesador de energía dice el PMIC y el número, y el voltaje confirma que es la misma fuente.
| Entrada en Android | Entrada en mainline | Regulador de Android | Voltaje | En mainline |
|---|---|---|---|---|
vdd | vdda-pll | pm8350_l5 | 0.88–0.912 V | l5b |
vdda18 | vdda18 | pm8350c_l1 | 1.8 V | l1c |
vdda33 | vdda33 | pm8350_l2 | 3.072 V | l2b |
El nombre de la entrada puede cambiar (vdd pasa a llamarse vdda-pll), pero la fuente de voltaje es la misma: mismo PMIC, mismo número de LDO, mismo voltaje. Esa es la comprobación que hice con cada nodo, buscando su equivalente en el S22 o en las placas de prueba de Qualcomm antes de traducirlo. La tabla también muestra lo que no conviene copiar a ciegas del S22: en el OnePlus, el máximo de l5b es 0.912 V, no 0.888 V.
Un error en la memoria reservada corrompe datos sin avisar
Casi todos los errores en un device tree se notan. Si describo mal el USB, no hay USB. Si me equivoco con un regulador, algo no enciende. Es frustrante, pero por lo menos uno sabe dónde buscar.
La excepción es reserved-memory. Esa sección le dice al kernel qué partes de la RAM no son suyas, porque las usan otros procesadores del chip (el módem, los de audio y sensores, TrustZone) o el propio bootloader. Si falta una región, el kernel no se queja: simplemente la usa. Y el procesador que también la usa empieza a ver sus datos cambiar sin aviso. Por eso, en la entrada anterior, comparé las 39 regiones de Android contra las de mainline y reservé cada hueco antes de compilar nada. Es la parte del device tree donde un error no se ve como error.
El kernel cree todo lo que dice el device tree
Lo que me llevo de todo esto es que el device tree es un contrato que el kernel firma sin leer. Cree todo lo que dice: que en 0x1d84000 hay un controlador de almacenamiento, que el framebuffer mide 1080×2412, que cierta zona de memoria está libre. No tiene forma de comprobarlo. Si el árbol miente, el kernel va a actuar con total seguridad sobre información equivocada.
Mi sm8450-oneplus-wly.dts es mi primera versión de ese contrato, escrita a partir de lo que leí en el teléfono. Todavía no sé cuántas cláusulas están bien. Algunas preguntas quedan abiertas para el primer arranque: si la resolución del framebuffer era la correcta, y qué va a hacer el bootloader cuando le entregue un device tree que no es el suyo, con el overlay de OnePlus todavía en su partición.