Loading drivers/power/reset/Kconfig +1 −1 Original line number Diff line number Diff line Loading @@ -100,7 +100,7 @@ config POWER_RESET_HISI Reboot support for Hisilicon boards. config POWER_RESET_MSM bool "Qualcomm MSM power-off driver" tristate "Qualcomm MSM power-off driver" depends on ARCH_QCOM help Power off and restart support for Qualcomm boards. Loading drivers/power/reset/msm-poweroff.c +557 −13 Original line number Diff line number Diff line // SPDX-License-Identifier: GPL-2.0-only /* Copyright (c) 2013, The Linux Foundation. All rights reserved. /* * Copyright (c) 2013-2020, The Linux Foundation. All rights reserved. */ #include <linux/delay.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/io.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/module.h> #include <linux/reboot.h> #include <linux/pm.h> #include <linux/delay.h> #include <linux/input/qpnp-power-on.h> #include <linux/of_address.h> #include <linux/qcom_scm.h> #include <asm/cacheflush.h> #include <asm/system_misc.h> #include <asm/memory.h> #include <soc/qcom/restart.h> #include <soc/qcom/watchdog.h> #include <soc/qcom/minidump.h> #define EMERGENCY_DLOAD_MAGIC1 0x322A4F99 #define EMERGENCY_DLOAD_MAGIC2 0xC67E4350 #define EMERGENCY_DLOAD_MAGIC3 0x77777777 #define EMMC_DLOAD_TYPE 0x2 #define SCM_DLOAD_FULLDUMP QCOM_DOWNLOAD_FULLDUMP #define SCM_EDLOAD_MODE QCOM_DOWNLOAD_EDL #define SCM_DLOAD_MINIDUMP QCOM_DOWNLOAD_MINIDUMP #define SCM_DLOAD_BOTHDUMPS QCOM_DOWNLOAD_BOTHDUMP #define DL_MODE_PROP "qcom,msm-imem-download_mode" #define EDL_MODE_PROP "qcom,msm-imem-emergency_download_mode" #define IMEM_DL_TYPE_PROP "qcom,msm-imem-dload-type" #define KASLR_OFFSET_PROP "qcom,msm-imem-kaslr_offset" #define KASLR_OFFSET_BIT_MASK 0x00000000FFFFFFFF static int restart_mode; static void *restart_reason, *dload_type_addr; /* Download mode master kill-switch */ static void __iomem *msm_ps_hold; static int deassert_pshold(struct notifier_block *nb, unsigned long action, void *data) { writel(0, msm_ps_hold); mdelay(10000); static phys_addr_t tcsr_boot_misc_detect; /* * Runtime could be only changed value once. * There is no API from TZ to re-enable the registers. * So the SDI cannot be re-enabled when it already by-passed. */ static int download_mode = 1; static struct kobject dload_kobj; static int in_panic; static int dload_type = SCM_DLOAD_FULLDUMP; static void *dload_mode_addr; static bool dload_mode_enabled; static void *emergency_dload_mode_addr; static bool force_warm_reboot; static struct notifier_block restart_nb; /* interface for exporting attributes */ struct reset_attribute { struct attribute attr; ssize_t (*show)(struct kobject *kobj, struct attribute *attr, char *buf); size_t (*store)(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); }; #define to_reset_attr(_attr) \ container_of(_attr, struct reset_attribute, attr) #define RESET_ATTR(_name, _mode, _show, _store) \ static struct reset_attribute reset_attr_##_name = \ __ATTR(_name, _mode, _show, _store) /* sysfs related globals */ static ssize_t show_emmc_dload(struct kobject *kobj, struct attribute *attr, char *buf); static size_t store_emmc_dload(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); RESET_ATTR(emmc_dload, 0644, show_emmc_dload, store_emmc_dload); #ifdef CONFIG_QCOM_MINIDUMP static ssize_t show_dload_mode(struct kobject *kobj, struct attribute *attr, char *buf); static size_t store_dload_mode(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); RESET_ATTR(dload_mode, 0644, show_dload_mode, store_dload_mode); #endif /* CONFIG_QCOM_MINIDUMP */ static struct attribute *reset_attrs[] = { &reset_attr_emmc_dload.attr, #ifdef CONFIG_QCOM_MINIDUMP &reset_attr_dload_mode.attr, #endif NULL }; static struct attribute_group reset_attr_group = { .attrs = reset_attrs, }; static int dload_set(const char *val, const struct kernel_param *kp); module_param_call(download_mode, dload_set, param_get_int, &download_mode, 0644); static ssize_t attr_show(struct kobject *kobj, struct attribute *attr, char *buf); static ssize_t attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); static const struct sysfs_ops reset_sysfs_ops = { .show = attr_show, .store = attr_store, }; static struct kobj_type reset_ktype = { .sysfs_ops = &reset_sysfs_ops, }; static int panic_prep_restart(struct notifier_block *this, unsigned long event, void *ptr) { in_panic = 1; return NOTIFY_DONE; } static struct notifier_block restart_nb = { .notifier_call = deassert_pshold, .priority = 128, static struct notifier_block panic_blk = { .notifier_call = panic_prep_restart, }; static void set_dload_mode(int on) { if (dload_mode_addr) { __raw_writel(on ? 0xE47B337D : 0, dload_mode_addr); __raw_writel(on ? 0xCE14091A : 0, dload_mode_addr + sizeof(unsigned int)); /* Make sure the download cookie is updated */ mb(); } qcom_scm_set_download_mode(on ? dload_type : 0, tcsr_boot_misc_detect ? : 0); dload_mode_enabled = on; } static bool get_dload_mode(void) { return dload_mode_enabled; } static void enable_emergency_dload_mode(void) { if (emergency_dload_mode_addr) { __raw_writel(EMERGENCY_DLOAD_MAGIC1, emergency_dload_mode_addr); __raw_writel(EMERGENCY_DLOAD_MAGIC2, emergency_dload_mode_addr + sizeof(unsigned int)); __raw_writel(EMERGENCY_DLOAD_MAGIC3, emergency_dload_mode_addr + (2 * sizeof(unsigned int))); /* Need disable the pmic wdt, then the emergency dload mode * will not auto reset. */ qpnp_pon_wd_config(0); /* Make sure all the cookied are flushed to memory */ mb(); } qcom_scm_set_download_mode(SCM_EDLOAD_MODE, tcsr_boot_misc_detect ?: 0); } static int dload_set(const char *val, const struct kernel_param *kp) { int ret; int old_val = download_mode; ret = param_set_int(val, kp); if (ret) return ret; /* If download_mode is not zero or one, ignore. */ if (download_mode >> 1) { download_mode = old_val; return -EINVAL; } set_dload_mode(download_mode); return 0; } static void free_dload_mode_mem(void) { iounmap(emergency_dload_mode_addr); iounmap(dload_mode_addr); } static void *map_prop_mem(const char *propname) { struct device_node *np = of_find_compatible_node(NULL, NULL, propname); void *addr; if (!np) { pr_err("Unable to find DT property: %s\n", propname); return NULL; } addr = of_iomap(np, 0); if (!addr) pr_err("Unable to map memory for DT property: %s\n", propname); return addr; } #ifdef CONFIG_RANDOMIZE_BASE static void *kaslr_imem_addr; static void store_kaslr_offset(void) { kaslr_imem_addr = map_prop_mem(KASLR_OFFSET_PROP); if (kaslr_imem_addr) { __raw_writel(0xdead4ead, kaslr_imem_addr); __raw_writel(KASLR_OFFSET_BIT_MASK & (kimage_vaddr - KIMAGE_VADDR), kaslr_imem_addr + 4); __raw_writel(KASLR_OFFSET_BIT_MASK & ((kimage_vaddr - KIMAGE_VADDR) >> 32), kaslr_imem_addr + 8); iounmap(kaslr_imem_addr); } } #else static void store_kaslr_offset(void) { } #endif /* CONFIG_RANDOMIZE_BASE */ static void setup_dload_mode_support(void) { int ret; atomic_notifier_chain_register(&panic_notifier_list, &panic_blk); dload_mode_addr = map_prop_mem(DL_MODE_PROP); emergency_dload_mode_addr = map_prop_mem(EDL_MODE_PROP); store_kaslr_offset(); dload_type_addr = map_prop_mem(IMEM_DL_TYPE_PROP); if (!dload_type_addr) return; ret = kobject_init_and_add(&dload_kobj, &reset_ktype, kernel_kobj, "%s", "dload"); if (ret) { pr_err("%s:Error in creation kobject_add\n", __func__); kobject_put(&dload_kobj); return; } ret = sysfs_create_group(&dload_kobj, &reset_attr_group); if (ret) { pr_err("%s:Error in creation sysfs_create_group\n", __func__); kobject_del(&dload_kobj); } } static ssize_t attr_show(struct kobject *kobj, struct attribute *attr, char *buf) { struct reset_attribute *reset_attr = to_reset_attr(attr); ssize_t ret = -EIO; if (reset_attr->show) ret = reset_attr->show(kobj, attr, buf); return ret; } static ssize_t attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { struct reset_attribute *reset_attr = to_reset_attr(attr); ssize_t ret = -EIO; if (reset_attr->store) ret = reset_attr->store(kobj, attr, buf, count); return ret; } static ssize_t show_emmc_dload(struct kobject *kobj, struct attribute *attr, char *buf) { uint32_t read_val, show_val; if (!dload_type_addr) return -ENODEV; read_val = __raw_readl(dload_type_addr); if (read_val == EMMC_DLOAD_TYPE) show_val = 1; else show_val = 0; return snprintf(buf, sizeof(show_val), "%u\n", show_val); } static size_t store_emmc_dload(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { uint32_t enabled; int ret; if (!dload_type_addr) return -ENODEV; ret = kstrtouint(buf, 0, &enabled); if (ret < 0) return ret; if (!((enabled == 0) || (enabled == 1))) return -EINVAL; if (enabled == 1) __raw_writel(EMMC_DLOAD_TYPE, dload_type_addr); else __raw_writel(0, dload_type_addr); return count; } #ifdef CONFIG_QCOM_MINIDUMP static DEFINE_MUTEX(tcsr_lock); static ssize_t show_dload_mode(struct kobject *kobj, struct attribute *attr, char *buf) { return scnprintf(buf, PAGE_SIZE, "DLOAD dump type: %s\n", (dload_type == SCM_DLOAD_BOTHDUMPS) ? "both" : ((dload_type == SCM_DLOAD_MINIDUMP) ? "mini" : "full")); } static size_t store_dload_mode(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { if (sysfs_streq(buf, "full")) { dload_type = SCM_DLOAD_FULLDUMP; } else if (sysfs_streq(buf, "mini")) { if (!msm_minidump_enabled()) { pr_err("Minidump is not enabled\n"); return -ENODEV; } dload_type = SCM_DLOAD_MINIDUMP; } else if (sysfs_streq(buf, "both")) { if (!msm_minidump_enabled()) { pr_err("Minidump not enabled, setting fulldump only\n"); dload_type = SCM_DLOAD_FULLDUMP; return count; } dload_type = SCM_DLOAD_BOTHDUMPS; } else { pr_err("Invalid Dump setup request..\n"); pr_err("Supported dumps:'full', 'mini', or 'both'\n"); return -EINVAL; } mutex_lock(&tcsr_lock); /*Overwrite TCSR reg*/ set_dload_mode(dload_type); mutex_unlock(&tcsr_lock); return count; } #endif /* CONFIG_QCOM_MINIDUMP */ void msm_set_restart_mode(int mode) { restart_mode = mode; } EXPORT_SYMBOL(msm_set_restart_mode); static void msm_restart_prepare(const char *cmd) { bool need_warm_reset = false; /* Write download mode flags if we're panic'ing * Write download mode flags if restart_mode says so * Kill download mode if master-kill switch is set */ set_dload_mode(download_mode && (in_panic || restart_mode == RESTART_DLOAD)); if (qpnp_pon_check_hard_reset_stored()) { /* Set warm reset as true when device is in dload mode */ if (get_dload_mode() || ((cmd != NULL && cmd[0] != '\0') && !strcmp(cmd, "edl"))) need_warm_reset = true; } else { need_warm_reset = (get_dload_mode() || (cmd != NULL && cmd[0] != '\0')); } if (force_warm_reboot) pr_info("Forcing a warm reset of the system\n"); /* Hard reset the PMIC unless memory contents must be maintained. */ if (force_warm_reboot || need_warm_reset) qpnp_pon_system_pwr_off(PON_POWER_OFF_WARM_RESET); else qpnp_pon_system_pwr_off(PON_POWER_OFF_HARD_RESET); if (cmd != NULL) { if (!strncmp(cmd, "bootloader", 10)) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_BOOTLOADER); __raw_writel(0x77665500, restart_reason); } else if (!strncmp(cmd, "recovery", 8)) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_RECOVERY); __raw_writel(0x77665502, restart_reason); } else if (!strcmp(cmd, "rtc")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_RTC); __raw_writel(0x77665503, restart_reason); } else if (!strcmp(cmd, "dm-verity device corrupted")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_DMVERITY_CORRUPTED); __raw_writel(0x77665508, restart_reason); } else if (!strcmp(cmd, "dm-verity enforcing")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_DMVERITY_ENFORCE); __raw_writel(0x77665509, restart_reason); } else if (!strcmp(cmd, "keys clear")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_KEYS_CLEAR); __raw_writel(0x7766550a, restart_reason); } else if (!strncmp(cmd, "oem-", 4)) { unsigned long code; int ret; ret = kstrtoul(cmd + 4, 16, &code); if (!ret) __raw_writel(0x6f656d00 | (code & 0xff), restart_reason); } else if (!strncmp(cmd, "edl", 3)) { enable_emergency_dload_mode(); } else { __raw_writel(0x77665501, restart_reason); } } flush_cache_all(); /*outer_flush_all is not supported by 64bit kernel*/ #ifndef CONFIG_ARM64 outer_flush_all(); #endif } /* * Deassert PS_HOLD to signal the PMIC that we are ready to power down or reset. * Do this by calling into the secure environment, if available, or by directly * writing to a hardware register. * * This function should never return. */ static void deassert_ps_hold(void) { qcom_scm_deassert_ps_hold(); /* Fall-through to the direct write in case the scm_call "returns" */ __raw_writel(0, msm_ps_hold); } static int do_msm_restart(struct notifier_block *unused, unsigned long action, void *arg) { const char *cmd = arg; pr_notice("Going down for restart now\n"); msm_restart_prepare(cmd); /* * Trigger a watchdog bite here and if this fails, * device will take the usual restart path. */ if (WDOG_BITE_ON_PANIC && in_panic) msm_trigger_wdog_bite(); qcom_scm_disable_sdi(); qcom_scm_halt_spmi_pmic_arbiter(); deassert_ps_hold(); msleep(10000); return NOTIFY_DONE; } static void do_msm_poweroff(void) { deassert_pshold(&restart_nb, 0, NULL); pr_notice("Powering off the SoC\n"); set_dload_mode(0); qcom_scm_disable_sdi(); qpnp_pon_system_pwr_off(PON_POWER_OFF_SHUTDOWN); qcom_scm_halt_spmi_pmic_arbiter(); deassert_ps_hold(); msleep(10000); pr_err("Powering off has failed\n"); } static int msm_restart_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *mem; struct device_node *np; int ret = 0; setup_dload_mode_support(); np = of_find_compatible_node(NULL, NULL, "qcom,msm-imem-restart_reason"); if (!np) { pr_err("unable to find DT imem restart reason node\n"); } else { restart_reason = of_iomap(np, 0); if (!restart_reason) { pr_err("unable to map imem restart reason offset\n"); ret = -ENOMEM; goto err_restart_reason; } } mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pshold-base"); msm_ps_hold = devm_ioremap_resource(dev, mem); if (IS_ERR(msm_ps_hold)) return PTR_ERR(msm_ps_hold); register_restart_handler(&restart_nb); mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tcsr-boot-misc-detect"); if (mem) tcsr_boot_misc_detect = mem->start; pm_power_off = do_msm_poweroff; restart_nb.notifier_call = do_msm_restart; restart_nb.priority = 200; register_restart_handler(&restart_nb); set_dload_mode(download_mode); if (!download_mode) qcom_scm_disable_sdi(); force_warm_reboot = of_property_read_bool(dev->of_node, "qcom,force-warm-reboot"); return 0; err_restart_reason: free_dload_mode_mem(); return ret; } static const struct of_device_id of_msm_restart_match[] = { Loading @@ -68,4 +598,18 @@ static int __init msm_restart_init(void) { return platform_driver_register(&msm_restart_driver); } device_initcall(msm_restart_init); #if IS_MODULE(CONFIG_POWER_RESET_MSM) module_init(msm_restart_init); #else pure_initcall(msm_restart_init); #endif static __exit void msm_restart_exit(void) { platform_driver_unregister(&msm_restart_driver); } module_exit(msm_restart_exit); MODULE_DESCRIPTION("MSM Poweroff Driver"); MODULE_LICENSE("GPL v2"); drivers/soc/qcom/Kconfig +9 −0 Original line number Diff line number Diff line Loading @@ -667,6 +667,15 @@ config QCOM_WATCHDOG deadlocks. It does not run during the bootup process, so it will not catch any early lockups. config QCOM_FORCE_WDOG_BITE_ON_PANIC bool "QCOM force watchdog bite" depends on QCOM_WATCHDOG help This forces a watchdog bite when the device restarts due to a kernel panic. On certain MSM SoCs, this provides additional debugging information. config MSM_SPCOM depends on QCOM_GLINK bool "Secure Processor Communication over RPMSG" Loading include/soc/qcom/restart.h 0 → 100644 +16 −0 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0-only */ /* * Copyright (c) 2011-2014, 2016, 2018, 2020 The Linux Foundation. All rights reserved. */ #ifndef _ASM_ARCH_MSM_RESTART_H_ #define _ASM_ARCH_MSM_RESTART_H_ #define RESTART_NORMAL 0x0 #define RESTART_DLOAD 0x1 void msm_set_restart_mode(int mode); extern int pmic_reset_irq; #endif include/soc/qcom/watchdog.h +7 −1 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0-only */ /* * Copyright (c) 2019, The Linux Foundation. All rights reserved. * Copyright (c) 2019-2020 The Linux Foundation. All rights reserved. */ #ifndef _SOC_QCOM_WATCHDOG_H_ #define _SOC_QCOM_WATCHDOG_H_ #ifdef CONFIG_QCOM_FORCE_WDOG_BITE_ON_PANIC #define WDOG_BITE_ON_PANIC 1 #else #define WDOG_BITE_ON_PANIC 0 #endif #if IS_ENABLED(CONFIG_QCOM_WATCHDOG) void msm_trigger_wdog_bite(void); #else Loading Loading
drivers/power/reset/Kconfig +1 −1 Original line number Diff line number Diff line Loading @@ -100,7 +100,7 @@ config POWER_RESET_HISI Reboot support for Hisilicon boards. config POWER_RESET_MSM bool "Qualcomm MSM power-off driver" tristate "Qualcomm MSM power-off driver" depends on ARCH_QCOM help Power off and restart support for Qualcomm boards. Loading
drivers/power/reset/msm-poweroff.c +557 −13 Original line number Diff line number Diff line // SPDX-License-Identifier: GPL-2.0-only /* Copyright (c) 2013, The Linux Foundation. All rights reserved. /* * Copyright (c) 2013-2020, The Linux Foundation. All rights reserved. */ #include <linux/delay.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/io.h> #include <linux/of.h> #include <linux/platform_device.h> #include <linux/module.h> #include <linux/reboot.h> #include <linux/pm.h> #include <linux/delay.h> #include <linux/input/qpnp-power-on.h> #include <linux/of_address.h> #include <linux/qcom_scm.h> #include <asm/cacheflush.h> #include <asm/system_misc.h> #include <asm/memory.h> #include <soc/qcom/restart.h> #include <soc/qcom/watchdog.h> #include <soc/qcom/minidump.h> #define EMERGENCY_DLOAD_MAGIC1 0x322A4F99 #define EMERGENCY_DLOAD_MAGIC2 0xC67E4350 #define EMERGENCY_DLOAD_MAGIC3 0x77777777 #define EMMC_DLOAD_TYPE 0x2 #define SCM_DLOAD_FULLDUMP QCOM_DOWNLOAD_FULLDUMP #define SCM_EDLOAD_MODE QCOM_DOWNLOAD_EDL #define SCM_DLOAD_MINIDUMP QCOM_DOWNLOAD_MINIDUMP #define SCM_DLOAD_BOTHDUMPS QCOM_DOWNLOAD_BOTHDUMP #define DL_MODE_PROP "qcom,msm-imem-download_mode" #define EDL_MODE_PROP "qcom,msm-imem-emergency_download_mode" #define IMEM_DL_TYPE_PROP "qcom,msm-imem-dload-type" #define KASLR_OFFSET_PROP "qcom,msm-imem-kaslr_offset" #define KASLR_OFFSET_BIT_MASK 0x00000000FFFFFFFF static int restart_mode; static void *restart_reason, *dload_type_addr; /* Download mode master kill-switch */ static void __iomem *msm_ps_hold; static int deassert_pshold(struct notifier_block *nb, unsigned long action, void *data) { writel(0, msm_ps_hold); mdelay(10000); static phys_addr_t tcsr_boot_misc_detect; /* * Runtime could be only changed value once. * There is no API from TZ to re-enable the registers. * So the SDI cannot be re-enabled when it already by-passed. */ static int download_mode = 1; static struct kobject dload_kobj; static int in_panic; static int dload_type = SCM_DLOAD_FULLDUMP; static void *dload_mode_addr; static bool dload_mode_enabled; static void *emergency_dload_mode_addr; static bool force_warm_reboot; static struct notifier_block restart_nb; /* interface for exporting attributes */ struct reset_attribute { struct attribute attr; ssize_t (*show)(struct kobject *kobj, struct attribute *attr, char *buf); size_t (*store)(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); }; #define to_reset_attr(_attr) \ container_of(_attr, struct reset_attribute, attr) #define RESET_ATTR(_name, _mode, _show, _store) \ static struct reset_attribute reset_attr_##_name = \ __ATTR(_name, _mode, _show, _store) /* sysfs related globals */ static ssize_t show_emmc_dload(struct kobject *kobj, struct attribute *attr, char *buf); static size_t store_emmc_dload(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); RESET_ATTR(emmc_dload, 0644, show_emmc_dload, store_emmc_dload); #ifdef CONFIG_QCOM_MINIDUMP static ssize_t show_dload_mode(struct kobject *kobj, struct attribute *attr, char *buf); static size_t store_dload_mode(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); RESET_ATTR(dload_mode, 0644, show_dload_mode, store_dload_mode); #endif /* CONFIG_QCOM_MINIDUMP */ static struct attribute *reset_attrs[] = { &reset_attr_emmc_dload.attr, #ifdef CONFIG_QCOM_MINIDUMP &reset_attr_dload_mode.attr, #endif NULL }; static struct attribute_group reset_attr_group = { .attrs = reset_attrs, }; static int dload_set(const char *val, const struct kernel_param *kp); module_param_call(download_mode, dload_set, param_get_int, &download_mode, 0644); static ssize_t attr_show(struct kobject *kobj, struct attribute *attr, char *buf); static ssize_t attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count); static const struct sysfs_ops reset_sysfs_ops = { .show = attr_show, .store = attr_store, }; static struct kobj_type reset_ktype = { .sysfs_ops = &reset_sysfs_ops, }; static int panic_prep_restart(struct notifier_block *this, unsigned long event, void *ptr) { in_panic = 1; return NOTIFY_DONE; } static struct notifier_block restart_nb = { .notifier_call = deassert_pshold, .priority = 128, static struct notifier_block panic_blk = { .notifier_call = panic_prep_restart, }; static void set_dload_mode(int on) { if (dload_mode_addr) { __raw_writel(on ? 0xE47B337D : 0, dload_mode_addr); __raw_writel(on ? 0xCE14091A : 0, dload_mode_addr + sizeof(unsigned int)); /* Make sure the download cookie is updated */ mb(); } qcom_scm_set_download_mode(on ? dload_type : 0, tcsr_boot_misc_detect ? : 0); dload_mode_enabled = on; } static bool get_dload_mode(void) { return dload_mode_enabled; } static void enable_emergency_dload_mode(void) { if (emergency_dload_mode_addr) { __raw_writel(EMERGENCY_DLOAD_MAGIC1, emergency_dload_mode_addr); __raw_writel(EMERGENCY_DLOAD_MAGIC2, emergency_dload_mode_addr + sizeof(unsigned int)); __raw_writel(EMERGENCY_DLOAD_MAGIC3, emergency_dload_mode_addr + (2 * sizeof(unsigned int))); /* Need disable the pmic wdt, then the emergency dload mode * will not auto reset. */ qpnp_pon_wd_config(0); /* Make sure all the cookied are flushed to memory */ mb(); } qcom_scm_set_download_mode(SCM_EDLOAD_MODE, tcsr_boot_misc_detect ?: 0); } static int dload_set(const char *val, const struct kernel_param *kp) { int ret; int old_val = download_mode; ret = param_set_int(val, kp); if (ret) return ret; /* If download_mode is not zero or one, ignore. */ if (download_mode >> 1) { download_mode = old_val; return -EINVAL; } set_dload_mode(download_mode); return 0; } static void free_dload_mode_mem(void) { iounmap(emergency_dload_mode_addr); iounmap(dload_mode_addr); } static void *map_prop_mem(const char *propname) { struct device_node *np = of_find_compatible_node(NULL, NULL, propname); void *addr; if (!np) { pr_err("Unable to find DT property: %s\n", propname); return NULL; } addr = of_iomap(np, 0); if (!addr) pr_err("Unable to map memory for DT property: %s\n", propname); return addr; } #ifdef CONFIG_RANDOMIZE_BASE static void *kaslr_imem_addr; static void store_kaslr_offset(void) { kaslr_imem_addr = map_prop_mem(KASLR_OFFSET_PROP); if (kaslr_imem_addr) { __raw_writel(0xdead4ead, kaslr_imem_addr); __raw_writel(KASLR_OFFSET_BIT_MASK & (kimage_vaddr - KIMAGE_VADDR), kaslr_imem_addr + 4); __raw_writel(KASLR_OFFSET_BIT_MASK & ((kimage_vaddr - KIMAGE_VADDR) >> 32), kaslr_imem_addr + 8); iounmap(kaslr_imem_addr); } } #else static void store_kaslr_offset(void) { } #endif /* CONFIG_RANDOMIZE_BASE */ static void setup_dload_mode_support(void) { int ret; atomic_notifier_chain_register(&panic_notifier_list, &panic_blk); dload_mode_addr = map_prop_mem(DL_MODE_PROP); emergency_dload_mode_addr = map_prop_mem(EDL_MODE_PROP); store_kaslr_offset(); dload_type_addr = map_prop_mem(IMEM_DL_TYPE_PROP); if (!dload_type_addr) return; ret = kobject_init_and_add(&dload_kobj, &reset_ktype, kernel_kobj, "%s", "dload"); if (ret) { pr_err("%s:Error in creation kobject_add\n", __func__); kobject_put(&dload_kobj); return; } ret = sysfs_create_group(&dload_kobj, &reset_attr_group); if (ret) { pr_err("%s:Error in creation sysfs_create_group\n", __func__); kobject_del(&dload_kobj); } } static ssize_t attr_show(struct kobject *kobj, struct attribute *attr, char *buf) { struct reset_attribute *reset_attr = to_reset_attr(attr); ssize_t ret = -EIO; if (reset_attr->show) ret = reset_attr->show(kobj, attr, buf); return ret; } static ssize_t attr_store(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { struct reset_attribute *reset_attr = to_reset_attr(attr); ssize_t ret = -EIO; if (reset_attr->store) ret = reset_attr->store(kobj, attr, buf, count); return ret; } static ssize_t show_emmc_dload(struct kobject *kobj, struct attribute *attr, char *buf) { uint32_t read_val, show_val; if (!dload_type_addr) return -ENODEV; read_val = __raw_readl(dload_type_addr); if (read_val == EMMC_DLOAD_TYPE) show_val = 1; else show_val = 0; return snprintf(buf, sizeof(show_val), "%u\n", show_val); } static size_t store_emmc_dload(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { uint32_t enabled; int ret; if (!dload_type_addr) return -ENODEV; ret = kstrtouint(buf, 0, &enabled); if (ret < 0) return ret; if (!((enabled == 0) || (enabled == 1))) return -EINVAL; if (enabled == 1) __raw_writel(EMMC_DLOAD_TYPE, dload_type_addr); else __raw_writel(0, dload_type_addr); return count; } #ifdef CONFIG_QCOM_MINIDUMP static DEFINE_MUTEX(tcsr_lock); static ssize_t show_dload_mode(struct kobject *kobj, struct attribute *attr, char *buf) { return scnprintf(buf, PAGE_SIZE, "DLOAD dump type: %s\n", (dload_type == SCM_DLOAD_BOTHDUMPS) ? "both" : ((dload_type == SCM_DLOAD_MINIDUMP) ? "mini" : "full")); } static size_t store_dload_mode(struct kobject *kobj, struct attribute *attr, const char *buf, size_t count) { if (sysfs_streq(buf, "full")) { dload_type = SCM_DLOAD_FULLDUMP; } else if (sysfs_streq(buf, "mini")) { if (!msm_minidump_enabled()) { pr_err("Minidump is not enabled\n"); return -ENODEV; } dload_type = SCM_DLOAD_MINIDUMP; } else if (sysfs_streq(buf, "both")) { if (!msm_minidump_enabled()) { pr_err("Minidump not enabled, setting fulldump only\n"); dload_type = SCM_DLOAD_FULLDUMP; return count; } dload_type = SCM_DLOAD_BOTHDUMPS; } else { pr_err("Invalid Dump setup request..\n"); pr_err("Supported dumps:'full', 'mini', or 'both'\n"); return -EINVAL; } mutex_lock(&tcsr_lock); /*Overwrite TCSR reg*/ set_dload_mode(dload_type); mutex_unlock(&tcsr_lock); return count; } #endif /* CONFIG_QCOM_MINIDUMP */ void msm_set_restart_mode(int mode) { restart_mode = mode; } EXPORT_SYMBOL(msm_set_restart_mode); static void msm_restart_prepare(const char *cmd) { bool need_warm_reset = false; /* Write download mode flags if we're panic'ing * Write download mode flags if restart_mode says so * Kill download mode if master-kill switch is set */ set_dload_mode(download_mode && (in_panic || restart_mode == RESTART_DLOAD)); if (qpnp_pon_check_hard_reset_stored()) { /* Set warm reset as true when device is in dload mode */ if (get_dload_mode() || ((cmd != NULL && cmd[0] != '\0') && !strcmp(cmd, "edl"))) need_warm_reset = true; } else { need_warm_reset = (get_dload_mode() || (cmd != NULL && cmd[0] != '\0')); } if (force_warm_reboot) pr_info("Forcing a warm reset of the system\n"); /* Hard reset the PMIC unless memory contents must be maintained. */ if (force_warm_reboot || need_warm_reset) qpnp_pon_system_pwr_off(PON_POWER_OFF_WARM_RESET); else qpnp_pon_system_pwr_off(PON_POWER_OFF_HARD_RESET); if (cmd != NULL) { if (!strncmp(cmd, "bootloader", 10)) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_BOOTLOADER); __raw_writel(0x77665500, restart_reason); } else if (!strncmp(cmd, "recovery", 8)) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_RECOVERY); __raw_writel(0x77665502, restart_reason); } else if (!strcmp(cmd, "rtc")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_RTC); __raw_writel(0x77665503, restart_reason); } else if (!strcmp(cmd, "dm-verity device corrupted")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_DMVERITY_CORRUPTED); __raw_writel(0x77665508, restart_reason); } else if (!strcmp(cmd, "dm-verity enforcing")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_DMVERITY_ENFORCE); __raw_writel(0x77665509, restart_reason); } else if (!strcmp(cmd, "keys clear")) { qpnp_pon_set_restart_reason( PON_RESTART_REASON_KEYS_CLEAR); __raw_writel(0x7766550a, restart_reason); } else if (!strncmp(cmd, "oem-", 4)) { unsigned long code; int ret; ret = kstrtoul(cmd + 4, 16, &code); if (!ret) __raw_writel(0x6f656d00 | (code & 0xff), restart_reason); } else if (!strncmp(cmd, "edl", 3)) { enable_emergency_dload_mode(); } else { __raw_writel(0x77665501, restart_reason); } } flush_cache_all(); /*outer_flush_all is not supported by 64bit kernel*/ #ifndef CONFIG_ARM64 outer_flush_all(); #endif } /* * Deassert PS_HOLD to signal the PMIC that we are ready to power down or reset. * Do this by calling into the secure environment, if available, or by directly * writing to a hardware register. * * This function should never return. */ static void deassert_ps_hold(void) { qcom_scm_deassert_ps_hold(); /* Fall-through to the direct write in case the scm_call "returns" */ __raw_writel(0, msm_ps_hold); } static int do_msm_restart(struct notifier_block *unused, unsigned long action, void *arg) { const char *cmd = arg; pr_notice("Going down for restart now\n"); msm_restart_prepare(cmd); /* * Trigger a watchdog bite here and if this fails, * device will take the usual restart path. */ if (WDOG_BITE_ON_PANIC && in_panic) msm_trigger_wdog_bite(); qcom_scm_disable_sdi(); qcom_scm_halt_spmi_pmic_arbiter(); deassert_ps_hold(); msleep(10000); return NOTIFY_DONE; } static void do_msm_poweroff(void) { deassert_pshold(&restart_nb, 0, NULL); pr_notice("Powering off the SoC\n"); set_dload_mode(0); qcom_scm_disable_sdi(); qpnp_pon_system_pwr_off(PON_POWER_OFF_SHUTDOWN); qcom_scm_halt_spmi_pmic_arbiter(); deassert_ps_hold(); msleep(10000); pr_err("Powering off has failed\n"); } static int msm_restart_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *mem; struct device_node *np; int ret = 0; setup_dload_mode_support(); np = of_find_compatible_node(NULL, NULL, "qcom,msm-imem-restart_reason"); if (!np) { pr_err("unable to find DT imem restart reason node\n"); } else { restart_reason = of_iomap(np, 0); if (!restart_reason) { pr_err("unable to map imem restart reason offset\n"); ret = -ENOMEM; goto err_restart_reason; } } mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pshold-base"); msm_ps_hold = devm_ioremap_resource(dev, mem); if (IS_ERR(msm_ps_hold)) return PTR_ERR(msm_ps_hold); register_restart_handler(&restart_nb); mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "tcsr-boot-misc-detect"); if (mem) tcsr_boot_misc_detect = mem->start; pm_power_off = do_msm_poweroff; restart_nb.notifier_call = do_msm_restart; restart_nb.priority = 200; register_restart_handler(&restart_nb); set_dload_mode(download_mode); if (!download_mode) qcom_scm_disable_sdi(); force_warm_reboot = of_property_read_bool(dev->of_node, "qcom,force-warm-reboot"); return 0; err_restart_reason: free_dload_mode_mem(); return ret; } static const struct of_device_id of_msm_restart_match[] = { Loading @@ -68,4 +598,18 @@ static int __init msm_restart_init(void) { return platform_driver_register(&msm_restart_driver); } device_initcall(msm_restart_init); #if IS_MODULE(CONFIG_POWER_RESET_MSM) module_init(msm_restart_init); #else pure_initcall(msm_restart_init); #endif static __exit void msm_restart_exit(void) { platform_driver_unregister(&msm_restart_driver); } module_exit(msm_restart_exit); MODULE_DESCRIPTION("MSM Poweroff Driver"); MODULE_LICENSE("GPL v2");
drivers/soc/qcom/Kconfig +9 −0 Original line number Diff line number Diff line Loading @@ -667,6 +667,15 @@ config QCOM_WATCHDOG deadlocks. It does not run during the bootup process, so it will not catch any early lockups. config QCOM_FORCE_WDOG_BITE_ON_PANIC bool "QCOM force watchdog bite" depends on QCOM_WATCHDOG help This forces a watchdog bite when the device restarts due to a kernel panic. On certain MSM SoCs, this provides additional debugging information. config MSM_SPCOM depends on QCOM_GLINK bool "Secure Processor Communication over RPMSG" Loading
include/soc/qcom/restart.h 0 → 100644 +16 −0 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0-only */ /* * Copyright (c) 2011-2014, 2016, 2018, 2020 The Linux Foundation. All rights reserved. */ #ifndef _ASM_ARCH_MSM_RESTART_H_ #define _ASM_ARCH_MSM_RESTART_H_ #define RESTART_NORMAL 0x0 #define RESTART_DLOAD 0x1 void msm_set_restart_mode(int mode); extern int pmic_reset_irq; #endif
include/soc/qcom/watchdog.h +7 −1 Original line number Diff line number Diff line /* SPDX-License-Identifier: GPL-2.0-only */ /* * Copyright (c) 2019, The Linux Foundation. All rights reserved. * Copyright (c) 2019-2020 The Linux Foundation. All rights reserved. */ #ifndef _SOC_QCOM_WATCHDOG_H_ #define _SOC_QCOM_WATCHDOG_H_ #ifdef CONFIG_QCOM_FORCE_WDOG_BITE_ON_PANIC #define WDOG_BITE_ON_PANIC 1 #else #define WDOG_BITE_ON_PANIC 0 #endif #if IS_ENABLED(CONFIG_QCOM_WATCHDOG) void msm_trigger_wdog_bite(void); #else Loading
