Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0-only */
       2             : /*
       3             :  * AMD Memory Encryption Support
       4             :  *
       5             :  * Copyright (C) 2016 Advanced Micro Devices, Inc.
       6             :  *
       7             :  * Author: Tom Lendacky <thomas.lendacky@amd.com>
       8             :  */
       9             : 
      10             : #ifndef __X86_MEM_ENCRYPT_H__
      11             : #define __X86_MEM_ENCRYPT_H__
      12             : 
      13             : #ifndef __ASSEMBLY__
      14             : 
      15             : #include <linux/init.h>
      16             : 
      17             : #include <asm/bootparam.h>
      18             : 
      19             : #ifdef CONFIG_AMD_MEM_ENCRYPT
      20             : 
      21             : extern u64 sme_me_mask;
      22             : extern u64 sev_status;
      23             : extern bool sev_enabled;
      24             : 
      25             : void sme_encrypt_execute(unsigned long encrypted_kernel_vaddr,
      26             :                          unsigned long decrypted_kernel_vaddr,
      27             :                          unsigned long kernel_len,
      28             :                          unsigned long encryption_wa,
      29             :                          unsigned long encryption_pgd);
      30             : 
      31             : void __init sme_early_encrypt(resource_size_t paddr,
      32             :                               unsigned long size);
      33             : void __init sme_early_decrypt(resource_size_t paddr,
      34             :                               unsigned long size);
      35             : 
      36             : void __init sme_map_bootdata(char *real_mode_data);
      37             : void __init sme_unmap_bootdata(char *real_mode_data);
      38             : 
      39             : void __init sme_early_init(void);
      40             : void __init sev_setup_arch(void);
      41             : 
      42             : void __init sme_encrypt_kernel(struct boot_params *bp);
      43             : void __init sme_enable(struct boot_params *bp);
      44             : 
      45             : int __init early_set_memory_decrypted(unsigned long vaddr, unsigned long size);
      46             : int __init early_set_memory_encrypted(unsigned long vaddr, unsigned long size);
      47             : 
      48             : void __init mem_encrypt_free_decrypted_mem(void);
      49             : 
      50             : /* Architecture __weak replacement functions */
      51             : void __init mem_encrypt_init(void);
      52             : 
      53             : void __init sev_es_init_vc_handling(void);
      54             : bool sme_active(void);
      55             : bool sev_active(void);
      56             : bool sev_es_active(void);
      57             : 
      58             : #define __bss_decrypted __section(".bss..decrypted")
      59             : 
      60             : #else   /* !CONFIG_AMD_MEM_ENCRYPT */
      61             : 
      62             : #define sme_me_mask     0ULL
      63             : 
      64             : static inline void __init sme_early_encrypt(resource_size_t paddr,
      65             :                                             unsigned long size) { }
      66             : static inline void __init sme_early_decrypt(resource_size_t paddr,
      67             :                                             unsigned long size) { }
      68             : 
      69           1 : static inline void __init sme_map_bootdata(char *real_mode_data) { }
      70           1 : static inline void __init sme_unmap_bootdata(char *real_mode_data) { }
      71             : 
      72           1 : static inline void __init sme_early_init(void) { }
      73           1 : static inline void __init sev_setup_arch(void) { }
      74             : 
      75           0 : static inline void __init sme_encrypt_kernel(struct boot_params *bp) { }
      76           0 : static inline void __init sme_enable(struct boot_params *bp) { }
      77             : 
      78           1 : static inline void sev_es_init_vc_handling(void) { }
      79           2 : static inline bool sme_active(void) { return false; }
      80           3 : static inline bool sev_active(void) { return false; }
      81             : static inline bool sev_es_active(void) { return false; }
      82             : 
      83             : static inline int __init
      84             : early_set_memory_decrypted(unsigned long vaddr, unsigned long size) { return 0; }
      85             : static inline int __init
      86             : early_set_memory_encrypted(unsigned long vaddr, unsigned long size) { return 0; }
      87             : 
      88           1 : static inline void mem_encrypt_free_decrypted_mem(void) { }
      89             : 
      90             : #define __bss_decrypted
      91             : 
      92             : #endif  /* CONFIG_AMD_MEM_ENCRYPT */
      93             : 
      94             : /*
      95             :  * The __sme_pa() and __sme_pa_nodebug() macros are meant for use when
      96             :  * writing to or comparing values from the cr3 register.  Having the
      97             :  * encryption mask set in cr3 enables the PGD entry to be encrypted and
      98             :  * avoid special case handling of PGD allocations.
      99             :  */
     100             : #define __sme_pa(x)             (__pa(x) | sme_me_mask)
     101             : #define __sme_pa_nodebug(x)     (__pa_nodebug(x) | sme_me_mask)
     102             : 
     103             : extern char __start_bss_decrypted[], __end_bss_decrypted[], __start_bss_decrypted_unused[];
     104             : 
     105          69 : static inline bool mem_encrypt_active(void)
     106             : {
     107          69 :         return sme_me_mask;
     108             : }
     109             : 
     110           3 : static inline u64 sme_get_me_mask(void)
     111             : {
     112           0 :         return sme_me_mask;
     113             : }
     114             : 
     115             : #endif  /* __ASSEMBLY__ */
     116             : 
     117             : #endif  /* __X86_MEM_ENCRYPT_H__ */