static int sha256_ce_update(struct shash_desc *desc, const u8 *data,
			    unsigned int len)
{
	struct sha256_ce_state *sctx = shash_desc_ctx(desc);

	sctx->finalize = 0;
	kernel_neon_begin_partial(28);
	sha256_base_do_update(desc, data, len,
			      (sha256_block_fn *)sha2_ce_transform);
	kernel_neon_end();

	return 0;
}

void kernel_neon_begin_partial(u32 num_regs)
{
	if (in_interrupt()) {
		struct fpsimd_partial_state *s = this_cpu_ptr(
			in_irq() ? &hardirq_fpsimdstate : &softirq_fpsimdstate);

		BUG_ON(num_regs > 32);
		fpsimd_save_partial_state(s, roundup(num_regs, 2));
	} else {
		/*
		 * Save the userland FPSIMD state if we have one and if we
		 * haven't done so already. Clear fpsimd_last_state to indicate
		 * that there is no longer userland FPSIMD state in the
		 * registers.
		 */
		preempt_disable();
		if (current->mm &&
		    !test_and_set_thread_flag(TIF_FOREIGN_FPSTATE))
			fpsimd_save_state(&current->thread.fpsimd_state);
		this_cpu_write(fpsimd_last_state, NULL);
	}
}

void fpsimd_thread_switch(struct task_struct *next)
{
 /*
  * Save the current FPSIMD state to memory, but only if whatever is in
  * the registers is in fact the most recent userland FPSIMD state of
  * 'current'.
  */
//    进程切换的时候，如果当前进程没有设置TIF_FOREIGN_FPSTATE，则保存fpsimd state
 if (current->mm && !test_thread_flag(TIF_FOREIGN_FPSTATE))
  fpsimd_save_state(&current->thread.fpsimd_state);

 if (next->mm) {
  /*
   * If we are switching to a task whose most recent userland
   * FPSIMD state is already in the registers of *this* cpu,
   * we can skip loading the state from memory. Otherwise, set
   * the TIF_FOREIGN_FPSTATE flag so the state will be loaded
   * upon the next return to userland.
   */
  struct fpsimd_state *st = &next->thread.fpsimd_state;
// next进程保存的cpu-id等于当前cpu-id 并且当前cpu的per-cpu fpsimd_last_state记录的也属于next
那么无需进行浮点寄存器的现场恢复工作，并把next的ti->flags清掉TIF_FOREIGN_FPSTATE
  if (__this_cpu_read(fpsimd_last_state) == st
      && st->cpu == smp_processor_id())
   clear_ti_thread_flag(task_thread_info(next),
          TIF_FOREIGN_FPSTATE);
  else  // 否则的话，就要设置标志为，便于后续恢复现场
   set_ti_thread_flag(task_thread_info(next),
        TIF_FOREIGN_FPSTATE);
 }
}

asmlinkage void do_notify_resume(struct pt_regs *regs,
     unsigned int thread_flags)
{
// 进程有信号需要处理
 if (thread_flags & _TIF_SIGPENDING)
  do_signal(regs);

 if (thread_flags & _TIF_NOTIFY_RESUME) {
  clear_thread_flag(TIF_NOTIFY_RESUME);
  tracehook_notify_resume(regs);
 }

// 进程有使用浮点运算
 if (thread_flags & _TIF_FOREIGN_FPSTATE)
  fpsimd_restore_current_state(); // 恢复浮点寄存器现场，并清零TIF_FOREIGN_FPSTATE

}

work_pending:
 tbnz	x1, #TIF_NEED_RESCHED, work_resched
 /* TIF_SIGPENDING, TIF_NOTIFY_RESUME or TIF_FOREIGN_FPSTATE case */
 ldr	x2, [sp, #S_PSTATE]
 mov	x0, sp	// 'regs'
 tst	x2, #PSR_MODE_MASK	// user mode regs?
 b.ne	no_work_pending	// returning to kernel
 enable_irq	// enable interrupts for do_notify_resume()
 bl	do_notify_resume　执行准备工作 恢复浮点寄存器现场
 b	ret_to_user
work_resched:
 bl	schedule

ret_to_user:
 disable_irq	// disable interrupts
 ldr	x1, [tsk, #TI_FLAGS]
 and	x2, x1, #_TIF_WORK_MASK
 cbnz	x2, work_pending
 enable_step_tsk x1, x2
no_work_pending:
 kernel_exit 0
ENDPROC(ret_to_user)

ENTRY(fpsimd_save_state)
    fpsimd_save x0, 8
    ret
ENDPROC(fpsimd_save_state)

.macro fpsimd_save state, tmpnr
	stp	q0, q1, [\state, #16 * 0]
	stp	q2, q3, [\state, #16 * 2]
	stp	q4, q5, [\state, #16 * 4]
	stp	q6, q7, [\state, #16 * 6]
	stp	q8, q9, [\state, #16 * 8]
	stp	q10, q11, [\state, #16 * 10]
	stp	q12, q13, [\state, #16 * 12]
	stp	q14, q15, [\state, #16 * 14]
	stp	q16, q17, [\state, #16 * 16]
	stp	q18, q19, [\state, #16 * 18]
	stp	q20, q21, [\state, #16 * 20]
	stp	q22, q23, [\state, #16 * 22]
	stp	q24, q25, [\state, #16 * 24]
	stp	q26, q27, [\state, #16 * 26]
	stp	q28, q29, [\state, #16 * 28]
	stp	q30, q31, [\state, #16 * 30]!
	mrs	x\tmpnr, fpsr
	str	w\tmpnr, [\state, #16 * 2]
	mrs	x\tmpnr, fpcr
	str	w\tmpnr, [\state, #16 * 2 + 4]
.endm