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 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"; +};