linux reboot flow

1,  little machine_desc struture

1-1, first eye on arch/arm/include/asm/mach/arch.h

/*
 * Machine type table - also only accessible during boot
 */
extern const struct machine_desc __arch_info_begin[], __arch_info_end[];
#define for_each_machine_desc(p)                        \
        for (p = __arch_info_begin; p < __arch_info_end; p++)

#define DT_MACHINE_START(_name, _namestr)               \
static const struct machine_desc __mach_desc_##_name    \
 __used                                                 \
 __attribute__((__section__(".arch.info.init"))) = {    \
        .nr             = ~0,                           \
        .name           = _namestr,

#endif

1-2, put machine_desc variable in arch.info.init section, whose begining is __arch_info_begin and ending is __arch_info_end. they defined at file arch/arm/kernel/vmlinux.lds.S

.init.arch.info : {
                __arch_info_begin = .;
                *(.arch.info.init)
                __arch_info_end = .;
        }
1-3,  grep "DT_MACHINE_START"  will help you find your board's related machine_desc, which will stored at section: arch.info.init, something like:

static const char *xxx_dt_match[] __initconst = {
        "xxx,yyyy",
        NULL
};

DT_MACHINE_START(xxx_DT, "Generic xxx (Flattened Device Tree)")
        .smp            = smp_ops(xxx_smp_ops),
        .map_io         = xxx_map_io,
        .init_machine   = xxx_init_mach,
        .init_late      = xxx_init_late,
        .dt_compat      = xxx_dt_match,
        .restart = xxxx_xxx_restart,
MACHINE_END

2,  who use the machine_desc variable

arch/arm/kernel/setup.c

start_kernel -> setup_arch -> setup_machine_fdt -> of_flat_dt_match_machine(mdesc_best, arch_get_next_mach) 

static const void * __init arch_get_next_mach(const char *const **match)
{
        static const struct machine_desc *mdesc = __arch_info_begin;
        const struct machine_desc *m = mdesc;

        if (m >= __arch_info_end)
                return NULL;

        mdesc++;
        *match = m->dt_compat;
        return m;
}

at last setup_machine_fdt will return a machine_desc variable at last which is your board used and assign arm_pm_restart at last by the follow statement:

if (mdesc->restart)
                arm_pm_restart = mdesc->restart;

3, what flow reboot will go?

in kernel/reboot.c there is a function:

SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
                void __user *, arg)
there is switch case:
switch (cmd) {
        case LINUX_REBOOT_CMD_RESTART:
                kernel_restart(NULL);
                break;

void kernel_restart(char *cmd)
{
        kernel_restart_prepare(cmd);
        migrate_to_reboot_cpu();
        syscore_shutdown();
        if (!cmd)
                pr_emerg("Restarting system\n");
        else
                pr_emerg("Restarting system with command '%s'\n", cmd);
        kmsg_dump(KMSG_DUMP_RESTART);
        machine_restart(cmd);
}

void kernel_restart_prepare(char *cmd)
{
        blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd); // notify event of SYS_RESTART, others like "systemd" will capture it do some process.
        system_state = SYSTEM_RESTART;
        usermodehelper_disable();
        pr_info("%s will call device shutdown\n", __func__);
        device_shutdown();// device's shut down will be called
}

/**
 * syscore_shutdown - Execute all the registered system core shutdown callbacks.
 */
void syscore_shutdown(void)
{
        struct syscore_ops *ops;

        mutex_lock(&syscore_ops_lock);

        list_for_each_entry_reverse(ops, &syscore_ops_list, node)
                if (ops->shutdown) {
                        if (initcall_debug)
                                pr_info("PM: Calling %pF\n", ops->shutdown);
                        ops->shutdown();// registered by register_syscore_ops
                        pr_info("%s\n", __func__);
                }

        mutex_unlock(&syscore_ops_lock);
}

/*
 * Restart requires that the secondary CPUs stop performing any activity
 * while the primary CPU resets the system. Systems with a single CPU can
 * use soft_restart() as their machine descriptor's .restart hook, since that
 * will cause the only available CPU to reset. Systems with multiple CPUs must
 * provide a HW restart implementation, to ensure that all CPUs reset at once.
 * This is required so that any code running after reset on the primary CPU
 * doesn't have to co-ordinate with other CPUs to ensure they aren't still
 * executing pre-reset code, and using RAM that the primary CPU's code wishes
 * to use. Implementing such co-ordination would be essentially impossible.
 */
void machine_restart(char *cmd)
{
        local_irq_disable();
        smp_send_stop();


        /* Flush the console to make sure all the relevant messages make it
         * out to the console drivers */
        arm_machine_flush_console();

        if (arm_pm_restart) {
                pr_info("%s arm_pm_restart\n", __func__);
                arm_pm_restart(reboot_mode, cmd);
        } else {
                pr_info("%s do_kernel_restart\n", __func__);
                do_kernel_restart(cmd);
        }
        /* Give a grace period for failure to restart of 1s */
        mdelay(1000);

        /* Whoops - the platform was unable to reboot. Tell the user! */
        printk("Reboot failed -- System halted\n");
        local_irq_disable();
        while (1);
}


4, test result flow

[  148.550000] systemd-shutdown[1]: All DM devices detached.
[  148.560000] systemd-shutdown[1]: Rebooting.
[  148.560000] reboot: SYSC_reboot LINUX_REBOOT_CMD_RESTART //SYSCALL_DEFINE4(reboot
[  148.570000] reboot: kernel_restart_prepare will call device shutdown //kernel_restart_prepare
[  148.580000] mmc mmc3:0001: shutdown //device_shutdown
[  148.580000] mmcblk mmc1:1234: shutdown
[  148.580000] xxx_tsc 10d80000.adc:tsc: shutdown
[  148.710000] i2c i2c-2: shutdown
[  148.710000] i2c i2c-1: shutdown
[  148.710000] xxx_vdss sirfsoc_vdss.0: shutdown
[  148.710000] pca954x 0-0070: shutdown
[  148.720000] i2c 0-0045: shutdown
[  148.720000] i2c 0-0049: shutdown
[  148.720000] i2c 0-004b: shutdown
[  148.730000] i2c 0-0038: shutdown
[  148.730000] sx150x 0-0020: shutdown
[  148.730000] i2c i2c-0: shutdown
[  148.740000] pwm-backlight sirf-backlight: shutdown
[  148.740000] pvrsrvkm 12000000.graphics: shutdown
[  148.750000] xxx-wdt 10dc0000.timer: shutdown //device_shutdown
[  148.750000] syscore_shutdown //syscore_shutdown
[  148.750000] reboot: Restarting system
[  148.760000] machine_restart arm_pm_restart // machine_restart