/* * Hide the first two arguments to __cpu_suspend - these are an implementation * detail which platform code shouldn't have to know about. */ int cpu_suspend(unsigned long arg, int (*fn)(unsigned long)) { struct mm_struct *mm = current->active_mm; u32 __mpidr = cpu_logical_map(smp_processor_id()); int ret; if (!idmap_pgd) return -EINVAL; /* * Provide a temporary page table with an identity mapping for * the MMU-enable code, required for resuming. On successful * resume (indicated by a zero return code), we need to switch * back to the correct page tables. */ ret = __cpu_suspend(arg, fn, __mpidr); if (ret == 0) { cpu_switch_mm(mm->pgd, mm); local_flush_tlb_all(); } else { local_flush_tlb_all_non_is(); } return ret; }
void arch_context_switch(task_t *oldtask, task_t *newtask) { /* printk("oldtask->sp=0x%x, newtask->sp=0x%x\n", */ /* oldtask->sp, newtask->sp); */ cpu_switch_mm((unsigned long)newtask->mm.pgd); arm_context_switch(&oldtask->sp, newtask->sp); }
/* * Hide the first two arguments to __cpu_suspend - these are an implementation * detail which platform code shouldn't have to know about. */ int cpu_suspend(unsigned long arg, int (*fn)(unsigned long)) { struct mm_struct *mm = current->active_mm; int ret; if (!idmap_pgd) return -EINVAL; /* * Provide a temporary page table with an identity mapping for * the MMU-enable code, required for resuming. On successful * resume (indicated by a zero return code), we need to switch * back to the correct page tables. */ ret = __cpu_suspend(arg, fn); if (ret == 0) { cpu_switch_mm(mm->pgd, mm); #if defined(CONFIG_BCM_KF_ARM_BCM963XX) local_flush_bp_all(); #endif local_flush_tlb_all(); } return ret; }
/** * cpu_suspend * * @arg: argument to pass to the finisher function */ int cpu_suspend(unsigned long arg) { struct mm_struct *mm = current->active_mm; int ret, cpu = smp_processor_id(); unsigned long flags; /* * If cpu_ops have not been registered or suspend * has not been initialized, cpu_suspend call fails early. */ if (!cpu_ops[cpu] || !cpu_ops[cpu]->cpu_suspend) return -EOPNOTSUPP; /* * From this point debug exceptions are disabled to prevent * updates to mdscr register (saved and restored along with * general purpose registers) from kernel debuggers. */ local_dbg_save(flags); /* * mm context saved on the stack, it will be restored when * the cpu comes out of reset through the identity mapped * page tables, so that the thread address space is properly * set-up on function return. */ ret = __cpu_suspend(arg); pclog(); if (ret == 0) { cpu_switch_mm(mm->pgd, mm); flush_tlb_all(); /* * Restore per-cpu offset before any kernel * subsystem relying on it has a chance to run. */ set_my_cpu_offset(per_cpu_offset(cpu)); /* * Restore HW breakpoint registers to sane values * before debug exceptions are possibly reenabled * through local_dbg_restore. */ if (hw_breakpoint_restore) hw_breakpoint_restore(NULL); } /* * Restore pstate flags. OS lock and mdscr have been already * restored, so from this point onwards, debugging is fully * renabled if it was enabled when core started shutdown. */ local_dbg_restore(flags); return ret; }
/* * Restore page contents for physical pages that were in use during loading * hibernation image. Switch to idmap_pgd so the physical page tables * are overwritten with the same contents. */ static void notrace arch_restore_image(void *unused) { struct pbe *pbe; cpu_switch_mm(idmap_pgd, &init_mm); for (pbe = restore_pblist; pbe; pbe = pbe->next) copy_page(pbe->orig_address, pbe->address); soft_restart(virt_to_phys(cpu_resume)); }
/* * In order to soft-boot, we need to switch to a 1:1 mapping for the * cpu_reset functions. This will then ensure that we have predictable * results when turning off the mmu. */ void setup_mm_for_reboot(void) { /* Clean and invalidate L1. */ flush_cache_all(); /* Switch to the identity mapping. */ cpu_switch_mm(idmap_pgd, &init_mm); /* Flush the TLB. */ local_flush_tlb_all(); }
void setup_mm_for_reboot(void) { flush_cache_all(); cpu_switch_mm(idmap_pgd, &init_mm); local_flush_tlb_all(); }
/* * In order to soft-boot, we need to switch to a 1:1 mapping for the * cpu_reset functions. This will then ensure that we have predictable * results when turning off the mmu. */ void setup_mm_for_reboot(void) { /* Switch to the identity mapping. */ cpu_switch_mm(idmap_pgd, &init_mm); #ifdef CONFIG_CPU_HAS_ASID /* * We don't have a clean ASID for the identity mapping, which * may clash with virtual addresses of the previous page tables * and therefore potentially in the TLB. */ local_flush_tlb_all(); #endif }
/* * Restore page contents for physical pages that were in use during loading * hibernation image. Switch to idmap_pgd so the physical page tables * are overwritten with the same contents. */ static void notrace arch_restore_image(void *unused) { #ifdef CONFIG_MTK_HIBERNATION mtk_arch_restore_image(); #else struct pbe *pbe; cpu_switch_mm(idmap_pgd, &init_mm); for (pbe = restore_pblist; pbe; pbe = pbe->next) copy_page(pbe->orig_address, pbe->address); _soft_restart(virt_to_phys(cpu_resume), false); #endif }
/** * cpu_suspend * * @arg: argument to pass to the finisher function * @fn: suspend finisher function, the function that executes last * operations required to suspend a processor */ int cpu_suspend(unsigned long arg, int (*fn)(unsigned long)) { struct mm_struct *mm = current->active_mm; int ret; /* * Save the mm context on the stack, it will be restored when * the cpu comes out of reset through the identity mapped * page tables, so that the thread address space is properly * set-up on function return. */ ret = __cpu_suspend(arg, fn); if (ret == 0) { cpu_switch_mm(mm->pgd, mm); flush_tlb_all(); } return ret; }
void setup_mm_for_kdump(char mode) { unsigned long base_pmdval; pgd_t *pgd; int i; pgd = init_mm.pgd; cpu_switch_mm(pgd, &init_mm); base_pmdval = PMD_SECT_AP_WRITE | PMD_SECT_AP_READ | PMD_TYPE_SECT; for (i = 0; i < FIRST_USER_PGD_NR + USER_PTRS_PER_PGD; i++, pgd++) { unsigned long pmdval = (i << PGDIR_SHIFT) | base_pmdval; pmd_t *pmd; pmd = pmd_offset(pgd, i << PGDIR_SHIFT); pmd[0] = __pmd(pmdval); pmd[1] = __pmd(pmdval + (1 << (PGDIR_SHIFT - 1))); flush_pmd_entry(pmd); } }
/* * __cpu_suspend * * arg: argument to pass to the finisher function * fn: finisher function pointer * */ int __cpu_suspend(unsigned long arg, int (*fn)(unsigned long)) { struct mm_struct *mm = current->active_mm; int ret; unsigned long flags; /* * From this point debug exceptions are disabled to prevent * updates to mdscr register (saved and restored along with * general purpose registers) from kernel debuggers. */ local_dbg_save(flags); /* * Function graph tracer state gets incosistent when the kernel * calls functions that never return (aka suspend finishers) hence * disable graph tracing during their execution. */ pause_graph_tracing(); /* * mm context saved on the stack, it will be restored when * the cpu comes out of reset through the identity mapped * page tables, so that the thread address space is properly * set-up on function return. */ ret = __cpu_suspend_enter(arg, fn); if (ret == 0) { /* * We are resuming from reset with TTBR0_EL1 set to the * idmap to enable the MMU; restore the active_mm mappings in * TTBR0_EL1 unless the active_mm == &init_mm, in which case * the thread entered __cpu_suspend with TTBR0_EL1 set to * reserved TTBR0 page tables and should be restored as such. */ if (mm == &init_mm) cpu_set_reserved_ttbr0(); else cpu_switch_mm(mm->pgd, mm); flush_tlb_all(); /* * Restore per-cpu offset before any kernel * subsystem relying on it has a chance to run. */ set_my_cpu_offset(per_cpu_offset(smp_processor_id())); /* * Restore HW breakpoint registers to sane values * before debug exceptions are possibly reenabled * through local_dbg_restore. */ if (hw_breakpoint_restore) hw_breakpoint_restore(NULL); } unpause_graph_tracing(); /* * Restore pstate flags. OS lock and mdscr have been already * restored, so from this point onwards, debugging is fully * renabled if it was enabled when core started shutdown. */ local_dbg_restore(flags); return ret; }
/* * The framework loads the hibernation image into this linked list, * for swsusp_arch_resume() to copy back to the proper destinations. * * To make this work if resume is triggered from initramfs, the * pagetables need to be switched to allow writes to kernel mem. */ void notrace __swsusp_arch_restore_prepare(void) { cpu_switch_mm(__virt_to_phys(swapper_pg_dir), current->active_mm); }
/* * cpu_suspend * * arg: argument to pass to the finisher function * fn: finisher function pointer * */ int cpu_suspend(unsigned long arg, int (*fn)(unsigned long)) { struct mm_struct *mm = current->active_mm; int ret; unsigned long flags; /* * From this point debug exceptions are disabled to prevent * updates to mdscr register (saved and restored along with * general purpose registers) from kernel debuggers. */ local_dbg_save(flags); /* * mm context saved on the stack, it will be restored when * the cpu comes out of reset through the identity mapped * page tables, so that the thread address space is properly * set-up on function return. */ ret = __cpu_suspend_enter(arg, fn); if (ret == 0) { /* * We are resuming from reset with TTBR0_EL1 set to the * idmap to enable the MMU; set the TTBR0 to the reserved * page tables to prevent speculative TLB allocations, flush * the local tlb and set the default tcr_el1.t0sz so that * the TTBR0 address space set-up is properly restored. * If the current active_mm != &init_mm we entered cpu_suspend * with mappings in TTBR0 that must be restored, so we switch * them back to complete the address space configuration * restoration before returning. */ cpu_set_reserved_ttbr0(); local_flush_tlb_all(); cpu_set_default_tcr_t0sz(); if (mm != &init_mm) cpu_switch_mm(mm->pgd, mm); /* * Restore per-cpu offset before any kernel * subsystem relying on it has a chance to run. */ set_my_cpu_offset(per_cpu_offset(smp_processor_id())); /* * Restore HW breakpoint registers to sane values * before debug exceptions are possibly reenabled * through local_dbg_restore. */ if (hw_breakpoint_restore) hw_breakpoint_restore(NULL); } /* * Restore pstate flags. OS lock and mdscr have been already * restored, so from this point onwards, debugging is fully * renabled if it was enabled when core started shutdown. */ local_dbg_restore(flags); return ret; }