From 3fdd891e1593a54a2510751870f8cc27577b0f72 Mon Sep 17 00:00:00 2001 From: Nate Crawford Date: Sun, 8 Nov 2026 07:05:24 +0000 Subject: [PATCH 1/2] dt-bindings: arm: google: Add Pixel 9 Pro Fold (comet) Add the Google Pixel 9 Pro Fold, a Tensor G4 board, as google,zumapro-comet with the google,zumapro fallback, next to the Pixel 9a. The bootloader's selector properties are the SoC's and are already described. Assisted-by: LLM Signed-off-by: Nate Crawford --- Documentation/devicetree/bindings/arm/google.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/Documentation/devicetree/bindings/arm/google.yaml b/Documentation/devicetree/bindings/arm/google.yaml index 087c6cdbe7..372251d431 100644 --- a/Documentation/devicetree/bindings/arm/google.yaml +++ b/Documentation/devicetree/bindings/arm/google.yaml @@ -58,6 +58,7 @@ properties: - description: Google Tensor G4 (zumapro) boards items: - enum: + - google,zumapro-comet - google,zumapro-tegu - const: google,zumapro From fb760828d9680e063d768f2c74302bde56275715 Mon Sep 17 00:00:00 2001 From: Nate Crawford Date: Wed, 18 Nov 2026 14:34:48 -0600 Subject: [PATCH 2/2] arm64: dts: exynos: google: Add the Pixel 9 Pro Fold Add the Google Pixel 9 Pro Fold (comet), a Tensor G4 board, on the zumapro SoC description the Pixel 9a uses, with what it needs to boot from UFS with its keys, both watchdogs and the USB gadget: - the bootloader's selectors for comet's FOPLP and IPOP parts, its bootargs and the firmware carve-outs its own DT reserves, less the three it inserts itself; - the UFS supply on gpp0-1 and the key banks' interrupts; - comet's CPU levels from its own ACPM table (the inherited levels it doesn't have are deleted, those above what has run on it are turbo-mode) and its lower thermal trips; - the ramoops layout stock uses; - the Pixel 9a's plain DWC3 configuration for USB 2.0 peripheral mode with four clocks and both PHYs enabled. Described but disabled, each to be enabled once it has its own review: - the MAX77779 charger, gauge and USB-C port controller, and the second cell's MAX17201; - the CS40L26A haptics, the LM3644 torch and the ST54L NFC controller; - the fold's Hall switch; - the GPU's ACPM clock and its levels up to 940 MHz. The cover and inner displays, touch, cameras, AoC sensors and audio, Wi-Fi, Bluetooth, the modem, fingerprint, UWB, the board thermistors and wireless charging are left out: their drivers or bindings are not in this tree yet, or need SoC nodes the zumapro description doesn't have. Tested on comet with a cold boot through the bootloader of this DT (with the three inserted carve-outs still listed, which only logged overlaps) on the v7.3-rc6 based 7.3.0-rc6-omamobile-comet-rc2-cand21 kernel: the board booted from UFS to the root file system, both watchdogs were taken over, and dwc3 bound 11210000.usb directly; the gadget was up 3.2 s into boot and the host configured it. Link: https://android.googlesource.com/kernel/devices/google/comet/+/c826c913562277d8d7ee4c089d4a0aab54507637/dts/zumapro-comet-mp.dts Assisted-by: LLM Signed-off-by: Nate Crawford --- arch/arm64/boot/dts/exynos/google/Makefile | 2 + .../exynos/google/zumapro-comet-battery.dtsi | 130 +++++ .../dts/exynos/google/zumapro-comet-dvfs.dtsi | 265 ++++++++++ .../google/zumapro-comet-haptics-torch.dtsi | 81 ++++ .../dts/exynos/google/zumapro-comet-nfc.dtsi | 41 ++ .../boot/dts/exynos/google/zumapro-comet.dts | 454 ++++++++++++++++++ 6 files changed, 973 insertions(+) create mode 100644 arch/arm64/boot/dts/exynos/google/zumapro-comet-battery.dtsi create mode 100644 arch/arm64/boot/dts/exynos/google/zumapro-comet-dvfs.dtsi create mode 100644 arch/arm64/boot/dts/exynos/google/zumapro-comet-haptics-torch.dtsi create mode 100644 arch/arm64/boot/dts/exynos/google/zumapro-comet-nfc.dtsi create mode 100644 arch/arm64/boot/dts/exynos/google/zumapro-comet.dts diff --git a/arch/arm64/boot/dts/exynos/google/Makefile b/arch/arm64/boot/dts/exynos/google/Makefile index 3f8e377c7a..c34908b77d 100644 --- a/arch/arm64/boot/dts/exynos/google/Makefile +++ b/arch/arm64/boot/dts/exynos/google/Makefile @@ -10,6 +10,7 @@ dtb-$(CONFIG_ARCH_EXYNOS) += \ gs201-panther.dtb \ zuma-akita.dtb \ zuma-husky.dtb \ + zumapro-comet.dtb \ zumapro-tegu.dtb # ABL applies board overlays, so keep symbols for labels @@ -22,4 +23,5 @@ DTC_FLAGS_gs201-lynx += -@ DTC_FLAGS_gs201-panther += -@ DTC_FLAGS_zuma-akita += -@ DTC_FLAGS_zuma-husky += -@ +DTC_FLAGS_zumapro-comet += -@ DTC_FLAGS_zumapro-tegu += -@ diff --git a/arch/arm64/boot/dts/exynos/google/zumapro-comet-battery.dtsi b/arch/arm64/boot/dts/exynos/google/zumapro-comet-battery.dtsi new file mode 100644 index 0000000000..543b523c38 --- /dev/null +++ b/arch/arm64/boot/dts/exynos/google/zumapro-comet-battery.dtsi @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Google Pixel 9 Pro Fold (comet): the MAX77779 gauge, charger and USB-C port + * controller on USI6's I2C bus (HSI2C6, gpp12-0/1), all disabled. + * + * The Pixel 9a has the same parts on the same bus and its board file is the + * pattern. The Fold has two cells in parallel: this MAX77779 gauges the base + * cell only, and a MAX17201 on USI10 gauges the second. Every client and the + * TCPC's interrupt bank stay disabled. + */ + +#include +#include +#include +#include +#include "../exynos-pinctrl.h" + +/* + * The MAX77779's bus: its fuel gauge, its charger and its USB-C port + * controller, a sink with no link to the USB controller's role yet. + */ +&hsi2c6 { + /* Stock asks for 1 MHz, which would switch the controller to HS mode. */ + clock-frequency = <950000>; + pinctrl-names = "default"; + pinctrl-0 = <&hsi2c6_bus>; + + comet_tcpc: tcpc@25 { + compatible = "maxim,max77779-tcpc"; + reg = <0x25>; + interrupt-parent = <&gpa8>; + interrupts = <3 IRQ_TYPE_LEVEL_LOW>; + pinctrl-names = "default"; + pinctrl-0 = <&usb_pd_irq>; + status = "disabled"; + + connector { + compatible = "usb-c-connector"; + label = "USB-C"; + data-role = "dual"; + power-role = "sink"; + self-powered; + op-sink-microwatt = <2600000>; + sink-pdos = ; + }; + }; + + /* The base cell only; the 2 mOhm shunt is the MAX77779 profile's. */ + comet_base_gauge: fuel-gauge@36 { + compatible = "maxim,max77779-fg"; + reg = <0x36>; + shunt-resistor-micro-ohms = <2000>; + power-supplies = <&comet_charger>; + status = "disabled"; + }; + + comet_charger: charger@69 { + compatible = "maxim,max77779-charger"; + reg = <0x69>; + status = "disabled"; + }; +}; + +/* + * The second cell's gauge, a MAX17201 with its nonvolatile memory at 0x0b, + * on USI10 (gpp20-0/1, 400 kHz). The same bus carries the pack EEPROM + * (0x50), the direct charger (0x57) and the wireless receiver (0x61), not + * described here. The gauge's alert is gpa6-5; nothing uses it yet. + * Google's driver forces a 3 mOhm sense resistor, which the max1720x + * binding can't express yet: the gauge stays disabled until it can. + */ +&hsi2c10 { + clock-frequency = <400000>; + pinctrl-names = "default"; + pinctrl-0 = <&hsi2c10_bus>; + + comet_second_gauge: fuel-gauge@36 { + compatible = "maxim,max17201"; + reg = <0x36>, <0x0b>; + reg-names = "m5", "nvmem"; + status = "disabled"; + }; +}; + +/* The USB-C port controller's interrupt (gpa8-3), held inactive with it. */ +&gpa8 { + interrupt-controller; + #interrupt-cells = <2>; + interrupts = , + , + , + ; + status = "disabled"; +}; + +&pinctrl_alive { + /* The MAX77779's INTB, for its PMIC block; nothing takes it yet. */ + if_pmic_irq: if-pmic-irq-pins { + samsung,pins = "gpa8-0"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; + + usb_pd_irq: usb-pd-irq-pins { + samsung,pins = "gpa8-3"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; + +&pinctrl_peric1 { + hsi2c10_bus: hsi2c10-bus-pins { + samsung,pins = "gpp20-0", "gpp20-1"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; + +&pinctrl_peric0 { + hsi2c6_bus: hsi2c6-bus-pins { + samsung,pins = "gpp12-0", "gpp12-1"; + samsung,pin-function = ; + /* Stock pulls this bus up; the Pixel 9a's DT has no pull. */ + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; diff --git a/arch/arm64/boot/dts/exynos/google/zumapro-comet-dvfs.dtsi b/arch/arm64/boot/dts/exynos/google/zumapro-comet-dvfs.dtsi new file mode 100644 index 0000000000..f3c3702ac3 --- /dev/null +++ b/arch/arm64/boot/dts/exynos/google/zumapro-comet-dvfs.dtsi @@ -0,0 +1,265 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Google Pixel 9 Pro Fold (comet): CPU levels and thermal trips. + * + * The CPU levels and per-core power are comet's own ACPM table, as stock's + * exynos_acme and cpu_cooling log them at boot; ACPM owns voltage selection. + * Levels above the ceilings that ran on comet (1328/1549/1745 MHz) are + * turbo-mode, so cpufreq-dt offers them only with boost on. The tables stop + * at stock's brownout limits, 1696/1795/1999 MHz: higher levels need a + * working brownout throttle first. + */ + +#include + +&cpucl0_opp { + /delete-node/ opp-1849000000; + /delete-node/ opp-1950000000; + /delete-node/ opp-324000000; + /delete-node/ opp-610000000; + + opp-820000000 { + opp-hz = /bits/ 64 <820000000>; + opp-microwatt = <18000>; + clock-latency-ns = <500000>; + }; + + opp-955000000 { + opp-hz = /bits/ 64 <955000000>; + opp-microwatt = <23000>; + clock-latency-ns = <500000>; + }; + + opp-1098000000 { + opp-hz = /bits/ 64 <1098000000>; + opp-microwatt = <28000>; + clock-latency-ns = <500000>; + }; + + opp-1197000000 { + opp-hz = /bits/ 64 <1197000000>; + opp-microwatt = <32000>; + clock-latency-ns = <500000>; + }; + + opp-1328000000 { + opp-hz = /bits/ 64 <1328000000>; + opp-microwatt = <39000>; + clock-latency-ns = <500000>; + }; + + opp-1425000000 { + opp-hz = /bits/ 64 <1425000000>; + opp-microwatt = <44000>; + clock-latency-ns = <500000>; + turbo-mode; + }; + + opp-1548000000 { + opp-hz = /bits/ 64 <1548000000>; + opp-microwatt = <52000>; + clock-latency-ns = <500000>; + turbo-mode; + }; + + opp-1696000000 { + opp-hz = /bits/ 64 <1696000000>; + opp-microwatt = <61000>; + clock-latency-ns = <500000>; + turbo-mode; + }; +}; + +&cpucl1_opp { + /delete-node/ opp-1945000000; + /delete-node/ opp-2130000000; + /delete-node/ opp-2245000000; + /delete-node/ opp-2367000000; + + opp-357000000 { + opp-hz = /bits/ 64 <357000000>; + opp-microwatt = <46000>; + clock-latency-ns = <500000>; + }; + + opp-578000000 { + opp-hz = /bits/ 64 <578000000>; + opp-microwatt = <85000>; + clock-latency-ns = <500000>; + }; + + opp-648000000 { + opp-hz = /bits/ 64 <648000000>; + opp-microwatt = <98000>; + clock-latency-ns = <500000>; + }; + + opp-787000000 { + opp-hz = /bits/ 64 <787000000>; + opp-microwatt = <124000>; + clock-latency-ns = <500000>; + }; + + opp-910000000 { + opp-hz = /bits/ 64 <910000000>; + opp-microwatt = <150000>; + clock-latency-ns = <500000>; + }; + + opp-1065000000 { + opp-hz = /bits/ 64 <1065000000>; + opp-microwatt = <188000>; + clock-latency-ns = <500000>; + }; + + opp-1221000000 { + opp-hz = /bits/ 64 <1221000000>; + opp-microwatt = <234000>; + clock-latency-ns = <500000>; + }; + + opp-1328000000 { + opp-hz = /bits/ 64 <1328000000>; + opp-microwatt = <271000>; + clock-latency-ns = <500000>; + }; + + opp-1418000000 { + opp-hz = /bits/ 64 <1418000000>; + opp-microwatt = <300000>; + clock-latency-ns = <500000>; + }; + + opp-1549000000 { + opp-hz = /bits/ 64 <1549000000>; + opp-microwatt = <362000>; + clock-latency-ns = <500000>; + }; + + opp-1795000000 { + opp-hz = /bits/ 64 <1795000000>; + opp-microwatt = <492000>; + clock-latency-ns = <500000>; + turbo-mode; + }; +}; + +&cpucl2_opp { + /delete-node/ opp-2147000000; + /delete-node/ opp-2294000000; + /delete-node/ opp-2363000000; + /delete-node/ opp-2499000000; + /delete-node/ opp-2687000000; + + opp-700000000 { + opp-hz = /bits/ 64 <700000000>; + opp-microwatt = <170000>; + clock-latency-ns = <500000>; + }; + + opp-1164000000 { + opp-hz = /bits/ 64 <1164000000>; + opp-microwatt = <330000>; + clock-latency-ns = <500000>; + }; + + opp-1396000000 { + opp-hz = /bits/ 64 <1396000000>; + opp-microwatt = <446000>; + clock-latency-ns = <500000>; + }; + + opp-1557000000 { + opp-hz = /bits/ 64 <1557000000>; + opp-microwatt = <537000>; + clock-latency-ns = <500000>; + }; + + opp-1745000000 { + opp-hz = /bits/ 64 <1745000000>; + opp-microwatt = <669000>; + clock-latency-ns = <500000>; + }; + + opp-1885000000 { + opp-hz = /bits/ 64 <1885000000>; + opp-microwatt = <775000>; + clock-latency-ns = <500000>; + turbo-mode; + }; + + opp-1999000000 { + opp-hz = /bits/ 64 <1999000000>; + opp-microwatt = <864000>; + clock-latency-ns = <500000>; + turbo-mode; + }; +}; + +&{/thermal-zones/big-thermal/cooling-maps/map1} { + cooling-device = <&cpu7 6 THERMAL_NO_LIMIT>; +}; + +&{/thermal-zones/mid-thermal/cooling-maps/map1} { + cooling-device = <&cpu4 10 THERMAL_NO_LIMIT>; +}; + +&{/thermal-zones/little-thermal/cooling-maps/map1} { + cooling-device = <&cpu0 7 THERMAL_NO_LIMIT>; +}; + +/* + * Comet's trips, lower than the SoC defaults: step-wise cooling from 60 C, + * the clusters' force-down trip at 65 C and the critical trip at 85 C, with + * the GPU zone polled as the CPU zones are. These are the values the phone + * runs; stock's trips are higher but come with its own skin-temperature + * policy, which Linux doesn't have. + */ +&big_alert { + temperature = <60000>; +}; + +&big_hot { + temperature = <65000>; +}; + +&big_crit { + temperature = <85000>; +}; + +&mid_alert { + temperature = <60000>; +}; + +&mid_hot { + temperature = <65000>; +}; + +&mid_crit { + temperature = <85000>; +}; + +&little_alert { + temperature = <60000>; +}; + +&little_hot { + temperature = <65000>; +}; + +&little_crit { + temperature = <85000>; +}; + +&gpu_alert { + temperature = <60000>; +}; + +&gpu_crit { + temperature = <85000>; +}; + +&{/thermal-zones/gpu-thermal} { + polling-delay-passive = <250>; + polling-delay = <1000>; +}; diff --git a/arch/arm64/boot/dts/exynos/google/zumapro-comet-haptics-torch.dtsi b/arch/arm64/boot/dts/exynos/google/zumapro-comet-haptics-torch.dtsi new file mode 100644 index 0000000000..4b77a5d6a1 --- /dev/null +++ b/arch/arm64/boot/dts/exynos/google/zumapro-comet-haptics-torch.dtsi @@ -0,0 +1,81 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Google Pixel 9 Pro Fold (comet): the haptics and the torch, both disabled. + * + * A Cirrus Logic CS40L26A (0x43) and a TI LM3644 (0x63) share USI9's I2C bus + * (HSI2C9, gpp19-4/5), as in Google's GPL board files for comet. The Pixel 9a + * has the same haptics wiring and puts its torch on USI4 instead; the nodes + * follow its board file. Both devices stay disabled. + */ + +#include +#include +#include +#include "../exynos-pinctrl.h" + +&hsi2c9 { + /* Stock runs this bus at 950 kHz; start slow. */ + clock-frequency = <100000>; + pinctrl-names = "default"; + pinctrl-0 = <&hsi2c9_bus>; + + /* The haptics: a CS40L26A on comet's LRA, with Google's limits for it. */ + haptics: haptic-driver@43 { + compatible = "cirrus,cs40l26a"; + reg = <0x43>; + interrupt-parent = <&gpa6>; + interrupts = <3 IRQ_TYPE_LEVEL_LOW>; + reset-gpios = <&gph2 3 GPIO_ACTIVE_LOW>; + pinctrl-names = "default"; + pinctrl-0 = <&haptic_reset>; + cirrus,boost-peak-microamp = <2500000>; + cirrus,boost-ctl-microvolt = <11000000>; + cirrus,lra-f0-hz = <160>; + cirrus,lra-redc-micro-ohms = <13000000>; + cirrus,vpbr-threshold-microvolt = <3008000>; + status = "disabled"; + }; + + /* The torch: a TI LM3644, both LED outputs on one white LED. */ + torch: led-controller@63 { + compatible = "ti,lm3644"; + reg = <0x63>; + enable-gpios = <&gpp24 1 GPIO_ACTIVE_HIGH>; + pinctrl-names = "default"; + pinctrl-0 = <&torch_enable>; + status = "disabled"; + + led { + function = LED_FUNCTION_TORCH; + color = ; + led-sources = <1 2>; + /* Our own bring-up cap, not a stock value. */ + led-max-microamp = <50000>; + }; + }; +}; + +&pinctrl_hsi1 { + haptic_reset: haptic-reset-pins { + samsung,pins = "gph2-3"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; + +&pinctrl_peric1 { + hsi2c9_bus: hsi2c9-bus-pins { + samsung,pins = "gpp19-4", "gpp19-5"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; + + torch_enable: torch-enable-pins { + samsung,pins = "gpp24-1"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; diff --git a/arch/arm64/boot/dts/exynos/google/zumapro-comet-nfc.dtsi b/arch/arm64/boot/dts/exynos/google/zumapro-comet-nfc.dtsi new file mode 100644 index 0000000000..c104a2cd4a --- /dev/null +++ b/arch/arm64/boot/dts/exynos/google/zumapro-comet-nfc.dtsi @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Google Pixel 9 Pro Fold (comet): the NFC controller, disabled. + * + * An ST54L at 0x08 on USI9's I2C bus (HSI2C9), next to the haptics and the + * torch, as in Google's GPL board files for comet (zuma-comet-nfc.dtsi and + * zuma-comet-ese.dtsi, whose eSE node names the part). The wiring matches + * the Pixel 9a's: IRQ_N on gpa7-5 (level high), RST_N on gph1-6, and the + * reference clock from the PMU's clock pad. The ST54L speaks plain NCI + * over I2C, so nxp-nci drives it. + */ + +#include +#include +#include + +&hsi2c9 { + comet_nfc: nfc@8 { + compatible = "st,st54l", "nxp,nxp-nci-i2c"; + reg = <0x08>; + clocks = <&pmu_system_controller 0>; + interrupt-parent = <&gpa7>; + interrupts = <5 IRQ_TYPE_LEVEL_HIGH>; + enable-gpios = <&gph1 6 GPIO_ACTIVE_HIGH>; + status = "disabled"; + }; +}; + +/* The NFC controller's bank: wakeup EINTs, one GIC SPI per pin. */ +&gpa7 { + interrupt-controller; + #interrupt-cells = <2>; + interrupts = , + , + , + , + , + , + , + ; +}; diff --git a/arch/arm64/boot/dts/exynos/google/zumapro-comet.dts b/arch/arm64/boot/dts/exynos/google/zumapro-comet.dts new file mode 100644 index 0000000000..c363d4749a --- /dev/null +++ b/arch/arm64/boot/dts/exynos/google/zumapro-comet.dts @@ -0,0 +1,454 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Google Pixel 9 Pro Fold (comet). + * + * Bootloader selector values from Google's GPL zumapro device tree. + * Copyright 2023 Google LLC. + */ + +/dts-v1/; + +#include +#include +#include +#include "../exynos-pinctrl.h" +#include "zumapro.dtsi" +#include "zumapro-reserved-memory.dtsi" +#include "zumapro-comet-haptics-torch.dtsi" +#include "zumapro-comet-nfc.dtsi" +#include "zumapro-comet-battery.dtsi" +#include "zumapro-comet-dvfs.dtsi" + +/ { + model = "Google Pixel 9 Pro Fold"; + compatible = "google,zumapro-comet", "google,zumapro"; + + chosen { + /* + * ABL requires bootargs to exist and appends its own after + * these. It also appends console=null, so a panic is silent: + * panic=10 resets the phone by itself. + * The firmware advertises PSCI SYSTEM_SUSPEND, but Linux has no + * Tensor SoC sleep sequence for "deep": suspend to idle only. + */ + bootargs = "clk_ignore_unused pd_ignore_unused panic=10 mem_sleep_default=s2idle"; + }; + + /* + * ABL picks the base DTB by matching these children against the + * SoC's product id, revision and package. Comet stock images include FOPLP and IPOP parts. + */ + soc_compatible { + A0_FOPLP { + product_id = <0x9875>; + major = <0>; + minor = <0>; + pkg_mode = <0>; + }; + + A1_FOPLP { + product_id = <0x9875>; + major = <0>; + minor = <1>; + pkg_mode = <0>; + }; + + A0_IPOP { + product_id = <0x9875>; + major = <0>; + minor = <0>; + pkg_mode = <1>; + }; + + A1_IPOP { + product_id = <0x9875>; + major = <0>; + minor = <1>; + pkg_mode = <1>; + }; + }; + + gpio-keys { + compatible = "gpio-keys"; + + key-power { + label = "Power"; + linux,code = ; + gpios = <&gpa4 0 GPIO_ACTIVE_LOW>; + wakeup-source; + }; + + key-volume-down { + label = "Volume Down"; + linux,code = ; + gpios = <&gpa4 1 GPIO_ACTIVE_LOW>; + }; + + key-volume-up { + label = "Volume Up"; + linux,code = ; + gpios = <&gpa6 2 GPIO_ACTIVE_LOW>; + }; + }; + + /* + * The fold sensor: a TI DRV5032 Hall-effect switch on gpa2-3 that + * closes as the two halves come together, active low with no pull + * (Google's zuma-comet-hall-sensor.dtsi). It is one GPIO whose state + * is a lid switch, so gpio-keys reports it. Google's node also names + * interrupts = <4 0> on gpa2, but its driver takes the interrupt from + * the GPIO; gpa2-3 is the pin. A device of its own, so the keys above + * are unchanged and a desktop can match it by name. + */ + comet_hall: hall-keys { + compatible = "gpio-keys"; + label = "Comet Hall"; + pinctrl-names = "default"; + pinctrl-0 = <&comet_hall_pin>; + status = "disabled"; + + switch-lid { + label = "Hall Sensor"; + gpios = <&gpa2 3 GPIO_ACTIVE_LOW>; + linux,input-type = ; + linux,code = ; + }; + }; + + /* + * Shader rates from Google's GPL zuma-gpu.dtsi gpu_dvfs_table_v2, + * which comet inherits; ACPM pairs each with its L2 rate and owns the + * voltages. The top level, 940 MHz, is the highest comet runs. + */ + gpu_opp: opp-table-gpu { + compatible = "operating-points-v2"; + + opp-150000000 { + opp-hz = /bits/ 64 <150000000>; + opp-suspend; + }; + + opp-302000000 { + opp-hz = /bits/ 64 <302000000>; + }; + + opp-337000000 { + opp-hz = /bits/ 64 <337000000>; + }; + + opp-376000000 { + opp-hz = /bits/ 64 <376000000>; + }; + + opp-419000000 { + opp-hz = /bits/ 64 <419000000>; + }; + + opp-467000000 { + opp-hz = /bits/ 64 <467000000>; + }; + + opp-521000000 { + opp-hz = /bits/ 64 <521000000>; + }; + + opp-580000000 { + opp-hz = /bits/ 64 <580000000>; + }; + + opp-649000000 { + opp-hz = /bits/ 64 <649000000>; + }; + + opp-723000000 { + opp-hz = /bits/ 64 <723000000>; + }; + + opp-807000000 { + opp-hz = /bits/ 64 <807000000>; + }; + + opp-850000000 { + opp-hz = /bits/ 64 <850000000>; + }; + + opp-890000000 { + opp-hz = /bits/ 64 <890000000>; + }; + + opp-940000000 { + opp-hz = /bits/ 64 <940000000>; + }; + }; + + /* UFS VCC, switched by gpp0-1 as on stock. */ + ufs_vcc: regulator-ufs-vcc { + compatible = "regulator-fixed"; + regulator-name = "ufs-vcc"; + gpio = <&gpp0 1 GPIO_ACTIVE_HIGH>; + enable-active-high; + regulator-boot-on; + regulator-always-on; + }; +}; + +/* + * Further firmware carve-outs, as the bootloader's DT on comet reserves them, + * without the three ABL inserts itself (see zuma.dtsi). + * The GSA's protected region stays at the SoC's size: comet's bootloader DT + * asks for 4 MiB, which would overlap the separate GSA log region. + */ +&{/reserved-memory} { + abl@f8800000 { + reg = <0x0 0xf8800000 0x01000000>; + no-map; + }; + +}; + +&acpm_ipc { + status = "okay"; + + main_pmic: pmic-1 { + compatible = "samsung,s2mpg14-pmic"; + + regulators { + /* The eUSB2 PHY's supplies; it switches them itself. */ + eusb_vdd: ldo8m { + regulator-name = "eusb-vdd"; + }; + + eusb_vdda12: ldo9m { + regulator-name = "eusb-vdda12"; + }; + }; + }; +}; + +&ap2apm_mailbox { + status = "okay"; +}; + +&apm_sram { + status = "okay"; +}; + +&cmu_apm { + status = "okay"; +}; + +&cmu_hsi0 { + status = "okay"; +}; + +&cmu_hsi1 { + status = "okay"; +}; + +&cmu_hsi2 { + status = "okay"; +}; + +&cmu_misc { + status = "okay"; +}; + +&cmu_peric0 { + status = "okay"; +}; + +&cmu_peric1 { + status = "okay"; +}; + +&cmu_top { + status = "okay"; +}; + +/* + * The GPU, disabled: its core clock is ACPM's, which also sets the + * voltage, and the coregroup and stacks clocks are CMU_G3D's gates. + */ +&gpu { + clocks = <&acpm_ipc ZUMAPRO_CLK_ACPM_GPU>, + <&cmu_g3d CLK_GOUT_G3D_COREGROUP>, + <&cmu_g3d CLK_GOUT_G3D_STACKS>; + operating-points-v2 = <&gpu_opp>; +}; + +/* The keys' banks raise their own interrupts. */ +&gpa4 { + interrupt-controller; + #interrupt-cells = <2>; + interrupts = , + ; +}; + +&gpa6 { + interrupt-controller; + #interrupt-cells = <2>; + interrupts = , + , + , + , + , + ; +}; + +/* The fold sensor's bank: wakeup EINTs, one GIC SPI per pin. */ +&gpa2 { + interrupt-controller; + #interrupt-cells = <2>; + interrupts = , + , + , + ; +}; + +&pinctrl_alive { + status = "okay"; + + comet_hall_pin: hall-sensor-pins { + samsung,pins = "gpa2-3"; + samsung,pin-function = ; + samsung,pin-pud = ; + samsung,pin-drv = <0>; + }; +}; + +&pinctrl_custom_alive { + status = "okay"; +}; + +&pinctrl_far_alive { + status = "okay"; +}; + +&pinctrl_hsi1 { + status = "okay"; +}; + +&pinctrl_hsi2 { + status = "okay"; +}; + +&pinctrl_hsi2ufs { + status = "okay"; +}; + +&pinctrl_peric0 { + status = "okay"; +}; + +&pinctrl_peric1 { + status = "okay"; +}; + +&pmu_system_controller { + status = "okay"; +}; + +&reboot_mode { + status = "okay"; +}; + +&sysreg_apm { + status = "okay"; +}; + +&sysreg_hsi0 { + status = "okay"; +}; + +&sysreg_peric0 { + status = "okay"; +}; + +&sysreg_peric1 { + status = "okay"; +}; + +&sysreg_ufs { + status = "okay"; +}; + +/* + * Built-in UFS attaches the disks before init runs. The init's storage + * guard marks partitions read-only as soon as it starts, leaving only + * slot B's boot images and userdata writable. + */ +&ufs { + vcc-supply = <&ufs_vcc>; + status = "okay"; +}; + +&ufs_phy { + status = "okay"; +}; + +/* USB 2.0 peripheral, with the same controller setup as the Pixel 9a. */ +&usb { + clocks = <&cmu_hsi0 CLK_GOUT_HSI0_USB_LINK>, + <&cmu_hsi0 CLK_MOUT_HSI0_USB20_REF>, + <&cmu_hsi0 CLK_GOUT_HSI0_USB_SUSPEND>, + <&cmu_hsi0 CLK_GOUT_HSI0_USB_SUBCTL>; + clock-names = "bus_early", "ref", "suspend", "subctl"; + dr_mode = "peripheral"; + maximum-speed = "high-speed"; + snps,dis-u2-freeclk-exists-quirk; + snps,usb2-gadget-lpm-disable; + status = "okay"; +}; + +&usb_hsphy { + vdd-supply = <&eusb_vdd>; + vdda12-supply = <&eusb_vdda12>; + status = "okay"; +}; + +&usbdrd_phy { + status = "okay"; +}; + +&watchdog_cl0 { + status = "okay"; +}; + +&watchdog_cl1 { + status = "okay"; +}; + +/* Stock's ramoops layout for zumapro: console and pmsg, 2 MiB each. */ +&ramoops_reserved { + compatible = "ramoops"; + console-size = <0x200000>; + pmsg-size = <0x200000>; +}; + +/* + * The I2C buses with board devices: USI6 (the MAX77779), USI9 (haptics, + * torch, NFC) and USI10 (the second gauge). Every client stays disabled. + */ +&usi6 { + status = "okay"; +}; + +&hsi2c6 { + status = "okay"; +}; + +&usi9 { + status = "okay"; +}; + +&hsi2c9 { + status = "okay"; +}; + +&usi10 { + status = "okay"; +}; + +&hsi2c10 { + status = "okay"; +};