reboot
zynq_slcr_read(&reboot, SLCR_REBOOT_STATUS_OFFSET);
zynq_slcr_write(reboot & 0xF0FFFFFF, SLCR_REBOOT_STATUS_OFFSET);
u32 reboot;
LONG reboot; /* Reboot the machine. */
void (*reboot) (struct clk *clk);
clk->reboot = sysctl_reboot;
SYSVEC(REBOOT_VECTOR, reboot),
amdgpu_ras_get_context(adev)->reboot) {
debugfs_create_bool("auto_reboot", S_IWUGO | S_IRUGO, dir, &con->reboot);
bool reboot;
static struct notifier_block reboot = {
unregister_reboot_notifier(&reboot);
register_reboot_notifier(&reboot);
unregister_reboot_notifier(&reboot);
u32 reboot;
pci_read_config_dword(pdev, vs + 0x14, &reboot);
return reboot;
u32 reboot, rx_pause_cnt;
reboot = myri10ge_read_reboot(mgp);
reboot, myri10ge_reset_recover ? "" : " not");
static DEVICE_ATTR_RW(reboot);
dev_info(reboot->dev, "Issuing power off (off1)\n");
if (apple_smc_write_u32_atomic(reboot->smc, SMC_KEY(MBSE), SMC_KEY(off1)) < 0) {
dev_err(reboot->dev, "Failed to issue MBSE = off1 (power_off)\n");
struct macsmc_reboot *reboot = data->cb_data;
dev_info(reboot->dev, "Issuing restart (phra)\n");
if (apple_smc_write_u32_atomic(reboot->smc, SMC_KEY(MBSE), SMC_KEY(phra)) < 0) {
dev_err(reboot->dev, "Failed to issue MBSE = phra (restart)\n");
struct macsmc_reboot *reboot = container_of(this, struct macsmc_reboot, reboot_notify);
dev_info(reboot->dev, "Preparing for reboot (%p4ch)\n", &val);
if (apple_smc_write_u32(reboot->smc, SMC_KEY(MBSE), val) < 0)
dev_err(reboot->dev, "Failed to issue MBSE = %p4ch (reboot_prepare)\n", &val);
if (reboot->nvm.boot_stage &&
nvmem_cell_set_u8(reboot->nvm.boot_stage, BOOT_STAGE_SHUTDOWN) < 0)
dev_err(reboot->dev, "Failed to write boot_stage\n");
if (reboot->nvm.shutdown_flag &&
nvmem_cell_set_u8(reboot->nvm.shutdown_flag, shutdown_flag) < 0)
dev_err(reboot->dev, "Failed to write shutdown_flag\n");
static void macsmc_power_init_error_counts(struct macsmc_reboot *reboot)
if (!reboot->nvm.boot_error_count || !reboot->nvm.panic_count)
boot_error_count = nvmem_cell_get_u8(reboot->nvm.boot_error_count);
dev_err(reboot->dev, "Failed to read boot_error_count (%d)\n", boot_error_count);
panic_count = nvmem_cell_get_u8(reboot->nvm.panic_count);
dev_err(reboot->dev, "Failed to read panic_count (%d)\n", panic_count);
dev_warn(reboot->dev, "PMU logged %d boot error(s) and %d panic(s)\n",
if (nvmem_cell_set_u8(reboot->nvm.panic_count, 0) < 0)
dev_err(reboot->dev, "Failed to reset panic_count\n");
if (nvmem_cell_set_u8(reboot->nvm.boot_error_count, 0) < 0)
dev_err(reboot->dev, "Failed to reset boot_error_count\n");
struct macsmc_reboot *reboot;
reboot = devm_kzalloc(&pdev->dev, sizeof(*reboot), GFP_KERNEL);
if (!reboot)
reboot->dev = &pdev->dev;
reboot->smc = smc;
platform_set_drvdata(pdev, reboot);
reboot->nvm_cells[i] = cell;
if (reboot->nvm.boot_stage &&
nvmem_cell_set_u8(reboot->nvm.boot_stage, BOOT_STAGE_KERNEL_STARTED) < 0)
dev_err(reboot->dev, "Failed to write boot_stage\n");
macsmc_power_init_error_counts(reboot);
reboot->reboot_notify.notifier_call = macsmc_reboot_notify;
SYS_OFF_PRIO_HIGH, macsmc_prepare_atomic, reboot);
macsmc_power_off, reboot);
SYS_OFF_PRIO_HIGH, macsmc_prepare_atomic, reboot);
macsmc_restart, reboot);
ret = devm_register_reboot_notifier(&pdev->dev, &reboot->reboot_notify);
struct macsmc_reboot *reboot = data->cb_data;
dev_info(reboot->dev, "Preparing SMC for atomic mode\n");
apple_smc_enter_atomic(reboot->smc);
struct macsmc_reboot *reboot = data->cb_data;
struct reboot_mode_driver reboot;
static int nvmem_reboot_mode_write(struct reboot_mode_driver *reboot,
nvmem_rbm = container_of(reboot, struct nvmem_reboot_mode, reboot);
dev_err(reboot->dev, "update reboot mode bits failed\n");
nvmem_rbm->reboot.dev = &pdev->dev;
nvmem_rbm->reboot.write = nvmem_reboot_mode_write;
ret = devm_reboot_mode_register(&pdev->dev, &nvmem_rbm->reboot);
static int qcom_pon_reboot_mode_write(struct reboot_mode_driver *reboot,
(reboot, struct qcom_pon, reboot_mode);
struct reboot_mode_driver *reboot;
reboot = container_of(this, struct reboot_mode_driver, reboot_notifier);
magic = get_reboot_mode_magic(reboot, cmd);
reboot->write(reboot, magic);
static int reboot_mode_create_device(struct reboot_mode_driver *reboot)
list_for_each_entry(info, &reboot->head, list) {
reboot->dev->driver->name);
int reboot_mode_register(struct reboot_mode_driver *reboot)
struct device_node *np = reboot->dev->of_node;
INIT_LIST_HEAD(&reboot->head);
info = devm_kzalloc(reboot->dev, sizeof(*info), GFP_KERNEL);
dev_err(reboot->dev, "reboot mode %s without magic number\n",
devm_kfree(reboot->dev, info);
dev_err(reboot->dev, "invalid mode name(%s): too short!\n",
list_add_tail(&info->list, &reboot->head);
reboot->reboot_notifier.notifier_call = reboot_mode_notify;
register_reboot_notifier(&reboot->reboot_notifier);
ret = reboot_mode_create_device(reboot);
reboot_mode_unregister(reboot);
static inline void reboot_mode_unregister_device(struct reboot_mode_driver *reboot)
reboot_mode_device = class_find_device(&reboot_mode_class, NULL, reboot->dev->driver->name,
int reboot_mode_unregister(struct reboot_mode_driver *reboot)
unregister_reboot_notifier(&reboot->reboot_notifier);
reboot_mode_unregister_device(reboot);
list_for_each_entry(info, &reboot->head, list)
struct reboot_mode_driver *reboot)
rc = reboot_mode_register(reboot);
*dr = reboot;
struct reboot_mode_driver *reboot)
devm_reboot_mode_match, reboot));
static unsigned int get_reboot_mode_magic(struct reboot_mode_driver *reboot,
list_for_each_entry(info, &reboot->head, list)
list_for_each_entry(info, &reboot->head, list)
struct reboot_mode_driver reboot;
static int syscon_reboot_mode_write(struct reboot_mode_driver *reboot,
syscon_rbm = container_of(reboot, struct syscon_reboot_mode, reboot);
dev_err(reboot->dev, "update reboot mode bits failed\n");
syscon_rbm->reboot.dev = &pdev->dev;
syscon_rbm->reboot.write = syscon_reboot_mode_write;
ret = devm_reboot_mode_register(&pdev->dev, &syscon_rbm->reboot);
p->reboot = (prop_val ? true : false);
bool reboot;
struct lockd_reboot reboot;
struct lockd_reboot *reboot = &argp->reboot;
reboot->len = argp->xdrgen.notify.name.len;
reboot->mon = (char *)argp->xdrgen.notify.name.data;
reboot->state = argp->xdrgen.notify.state;
memcpy(&reboot->priv.data, argp->xdrgen.private,
sizeof(reboot->priv.data));
nlm_host_rebooted(SVC_NET(rqstp), reboot);
struct lockd_reboot reboot;
struct lockd_reboot *reboot = &argp->reboot;
reboot->len = argp->xdrgen.notify.name.len;
reboot->mon = (char *)argp->xdrgen.notify.name.data;
reboot->state = argp->xdrgen.notify.state;
memcpy(&reboot->priv.data, argp->xdrgen.private,
sizeof(reboot->priv.data));
nlm_host_rebooted(SVC_NET(rqstp), reboot);
int reboot; /* group exit code if this pidns was rebooted */
int reboot_mode_register(struct reboot_mode_driver *reboot);
int reboot_mode_unregister(struct reboot_mode_driver *reboot);
struct reboot_mode_driver *reboot);
struct reboot_mode_driver *reboot);
int (*write)(struct reboot_mode_driver *reboot, unsigned int magic);
if (pid_ns->reboot)
current->signal->group_exit_code = pid_ns->reboot;
pid_ns->reboot = SIGHUP;
pid_ns->reboot = SIGINT;
SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
if (reboot(RB_KEXEC))
reboot(RB_AUTOBOOT);
reboot(RB_POWER_OFF);
reboot(RB_AUTOBOOT);