From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757124AbdKGPqb (ORCPT ); Tue, 7 Nov 2017 10:46:31 -0500 Received: from mail-bn3nam01on0089.outbound.protection.outlook.com ([104.47.33.89]:24569 "EHLO NAM01-BN3-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1752052AbdKGPq2 (ORCPT ); Tue, 7 Nov 2017 10:46:28 -0500 Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Gary.Hook@amd.com; Subject: Re: [Part2 PATCH v8 13/38] crypto: ccp: Add Secure Encrypted Virtualization (SEV) command support To: Brijesh Singh , kvm@vger.kernel.org, linux-kernel@vger.kernel.org Cc: bp@alien8.de, Paolo Bonzini , =?UTF-8?B?UmFkaW0gS3LEjW3DocWZ?= , Borislav Petkov , Herbert Xu , Tom Lendacky , linux-crypto@vger.kernel.org References: <20171106181130.68491-1-brijesh.singh@amd.com> <20171106181130.68491-14-brijesh.singh@amd.com> From: Gary R Hook Message-ID: <4eed41cb-20fd-4368-00ce-95d7a24b78c0@amd.com> Date: Tue, 7 Nov 2017 09:47:24 -0600 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.4.0 MIME-Version: 1.0 In-Reply-To: <20171106181130.68491-14-brijesh.singh@amd.com> Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: en-US Content-Transfer-Encoding: 8bit X-Originating-IP: [165.204.77.1] X-ClientProxiedBy: BN6PR14CA0038.namprd14.prod.outlook.com (10.171.172.152) To MWHPR12MB1213.namprd12.prod.outlook.com (10.169.204.141) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 4c8db574-a3af-4b2a-1e95-08d525f6b3b3 X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:(22001)(48565401081)(4534020)(4602075)(4627115)(201703031133081)(201702281549075)(2017052603199);SRVR:MWHPR12MB1213; X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1213;3:Q4D+ORybSJMK2KiVidvdx/luONcL6o4rllAY0DbD0bT8Un4ZDlWyY4hIyfXAqTnNQBvjkSSQATN9tmU/b7N9K/MXNyGD2gkl3m4l1bZkZWRy1JAXv7OF4kHsYvhgfn+46dfyEXE/05FwoOhdq21R9PBV5Zpa6/M6qpnmJP4c0B+lWdv/oNFP9KtYzRq4kASS6kaJlK/V3kAAwdpEaKwGXC/OiFFp6KToRAWbeyMM6OHTLEnNgGzs/mrubDFADt7G;25:NEbYWw+Pyj1TSen/WgN34XG/AkG/VcahGeCqf4YB/+NmevPrQ1u9Yi7GFWrvzzob8ZLC+Hcmkbgsi0hL6fgV8FWYoPymES1r2g6RToVBdK8Jdzkz96m63vmsN7HlmEmHLEap8T/v7a4GnwnORIgTHnMTXsvaxysXq1AHAaO8A3dkpJxuXEJnFeqQKxF3JNp37pf554OiirTG+r16LtQQPeVFPyZ5JMScthQHaPQAD4cjhfPCeZeV2Gu+VHBwcvGBUh5gKMDJ8QmQhWglb8qoFgVfK3anF/5SzxeF+5xfAx4FAOnYCTs8vt1dkkslLMfdWCvDns+9rZQF9XU3Zw4MMA==;31:MhYbJDMSfaOH0qHL9NsUFhIpGkbimnjxLu1zalVanj4zPYugdW6rpemD3zNJFe1RzwmVX3FncIDrw1dUveeF0nm2QpwnvmsBOJZlOMYnsjx7Wfbo3Zp52Rlb+G88KQ9YmgPVTolC114OV502MrFKJhnzt11GhAqq7WyLjrdLNp98MZ+eAHV0RmiPHzuN2iiNIhHi2BBDrZnoMdBTD2NntQaEKKO3Wp8vKv8rE/IzdF0= X-MS-TrafficTypeDiagnostic: MWHPR12MB1213: X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1213;20:HPRua1PuWCuFjKndX2Rxh10YgM1kYivR3syw2VZwQjMjDsWzKIacnJqH4bVPFAcf9HpGVnccXZuLGLsZqHc2uNCg86rfk6LqS53TGPp4Klj0BlqPSH5QWcTDX+09E/TXtdZGwNt7OlA/hZexfpV8JJL4c+S641DL5ap4clxnTRWKCdMbS8wdyqjuD1MwStTcSA3ugQushhwD9azQKDPBTK7DP24LJw5eDrTEOgStVhHB1Kzk4DjUEjKJLWNk36axPFs48jQg95I0FqYdpwZucxbaYjyybNSDKeCtix/0F3MiKGVNh9j/QlNNZjF3rEeEhdXz0rki1fUjaHwWNUbqZKgL+J+VjUbWPqIw8GmSSdMOqfFV7haDQXS9LQQVWXhLym394pBT2N73Xe/wXN5Bc8LPh8UhKkdWaf9VRQszu7OYb7nuB3Ufbs6uWv2pxEKBUKXO6A04GupBFxa4Hvfu1IO8/iOUDwYhJbf5sGQxbBLnrUdbWsA4JbL7k+Hrvf7M;4:fbnKvxknRo4BM7MD3HlX523vP8L5E8ptwMJv+WmTT9hsOMAy5VDHyzbozm2W6D4u4cmtec18Ukn3TKrv6RWCmZvq+z1DezF3YJhOlztijVqF1rRgFeMICaDfC7Ino8vAWJoxZqYjTl2lymPcnN2pHL5c8uI5ebipLknSWLZe01W95LC5BHZ0uetKNtxvn+JvzPzWTtVtHfq4iYyGF00rALRXzUE2ZThphvXoCwQZv3mRvGm2fZprRVWvRJmVJgwdi9s6CTnLnO2iIszmABbgcPFCX47rVvAo8Pum7pkx6IdZJMTYpRQ+fTKzzOCs6/2Ff6Thx+yevXWm/O3LuHSJpg== X-Exchange-Antispam-Report-Test: UriScan:(9452136761055)(767451399110); X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-CFA-Test: BCL:0;PCL:0;RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(2401047)(5005006)(8121501046)(3231021)(93006095)(93001095)(100000703101)(100105400095)(3002001)(10201501046)(6055026)(6041248)(20161123562025)(20161123564025)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123558100)(20161123555025)(20161123560025)(6072148)(201708071742011)(100000704101)(100105200095)(100000705101)(100105500095);SRVR:MWHPR12MB1213;BCL:0;PCL:0;RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095);SRVR:MWHPR12MB1213; X-Forefront-PRVS: 0484063412 X-Forefront-Antispam-Report: SFV:NSPM;SFS:(10009020)(6009001)(6049001)(376002)(39860400002)(346002)(189002)(24454002)(199003)(67846002)(47776003)(53546010)(54906003)(58126008)(16576012)(6116002)(316002)(97736004)(23676003)(31686004)(3846002)(83506002)(6246003)(305945005)(7736002)(68736007)(16526018)(189998001)(4326008)(8676002)(575784001)(86362001)(31696002)(2870700001)(25786009)(229853002)(64126003)(106356001)(90366009)(105586002)(6486002)(77096006)(66066001)(65956001)(81156014)(81166006)(2906002)(65806001)(53936002)(966005)(8936002)(36756003)(33646002)(101416001)(2950100002)(72206003)(5660300001)(6306002)(478600001)(65826007)(50466002)(50986999)(76176999)(54356999)(134885004);DIR:OUT;SFP:1101;SCL:1;SRVR:MWHPR12MB1213;H:[10.236.19.127];FPR:;SPF:None;PTR:InfoNoRecords;MX:1;A:1;LANG:en; X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtNV0hQUjEyTUIxMjEzOzIzOnVENm14ZFc3cHYxUm5xMDlZOGpqSEFyTm51?= =?utf-8?B?MnNmYVBZVk55UXRpUDliSE9xS09BR3ZqK1RrdlowcTdLbnUrVDgxTVo3RWJE?= =?utf-8?B?NThUUXpqcHlUeEdBQS9nc1RjRGVQOTV3MGdqR1NueFkzcXVBWjRScmdUNC8r?= =?utf-8?B?SjBMUDBsRkFHNDJJWGRHUGxwbG1wYm5oOGpiQlJuSDFsK011c01QQzJ2cXh4?= =?utf-8?B?ckRhZW9YYS81Yk9PejRBeEF5RW5wZ0pYekg5SzFrSjVxeStSVkZZT093ZG9I?= =?utf-8?B?Y0Y5TXZvTS9nc1E4ZEh0ejhzOTl3bEpGMEQ3T0FCd2t5bnJpSEhkbzRBZ3k5?= =?utf-8?B?TGdPcWNnUllIOEVNNHU2aGFtMlphODFVYVJFQlRWblNlTUdzUnkxV0JucFlF?= =?utf-8?B?OHhqS2xwc2Uxdm1VOWRjZlBucko2MXNBamcrRDFGYUpKbllYOGFOTk81d1FU?= =?utf-8?B?RVhmMW52Q05ubXE1bWE1M3BPSjFmTWVFU21jMjlKV0pqcTJETitXT2J5cWVw?= =?utf-8?B?bFhlQlVXbjRkeUVIajU2dURvWHUvVXM0L0dTUEgwTEFxWEZOQ1N4SVNxYnJ3?= =?utf-8?B?aTFLcW4xVGxaZkJJaWFoWEkyU1ZMNUpMZ0h0S0UxL01BR2NIeWdadXc5a1Ez?= =?utf-8?B?RHowbkh3dlhYbkpLUDhQdlVoVDloVlBMLzdvd2J3UTg1V09rSGd5QW1TRElz?= =?utf-8?B?SHJYYVpTYkVPVUJJSFgwVDQ2K1gwZTEzWWJ3czJxWFBVeWVldTcvOGRDeFhY?= =?utf-8?B?WmlkTDdGYTRQcG1VOHJ5Yys4VjUweWtpMnpscytnc3hFVkNqLzE4aEl3NjNG?= =?utf-8?B?VTFrRTdLV0loK3RERXQ3Rm9IYmVab0RpMGtETkZvTE0vWjZ6RktFdG1STEpn?= =?utf-8?B?SUxTRlJyVE53UGo4MHRvZ0FvVk1oQlNVdzRvOWV2ME0wUll1S0JjWDIvZUZq?= =?utf-8?B?UERZSkhyTitleHBDYXdPWnAvSjkwZFpYUWVMbnFiVmlRS1ltOHF0QmdoQWJP?= =?utf-8?B?c0ltdStnL1R4RkFNMXFhK2lEb0k4V255ekxScU9xUFFOY2NvRWVYOUhCS1NR?= =?utf-8?B?TWdBU2VHakxUdnphRDhnMlpCNGpTWlBhYk5vWm1wOUFCa2ZGUXBTRDFEYTFx?= =?utf-8?B?QjhPUmNhclBZZlpZUmFxS2tUcWczSG5mTnJkaEx6dm5ZSzlBQy9OTk5oaGVK?= =?utf-8?B?NWM3ZW1aUlk4RENWdFRyckhBQlpqOHRFWGVjMVc5RE1aODFmbnlFdlpkYVdC?= =?utf-8?B?VytIL0JoN1kyRVk1V0J3cUN6bWpxNkpHNUVrTkdvaFhGU0lRN1RNazFFcFV5?= =?utf-8?B?dkIrZU5XOHBCVllRVXVodjZOWjIwVzJxV0oxUnFQUk1YTnpWRjV2OUNoZlll?= =?utf-8?B?RWM4bVJFNktmS09sVVVtSEZ2SGlhejNLbEFkU2wxbjhwT09HaEVzQ1o5dG9r?= =?utf-8?B?UmZTZkhtTHN0NDNwVFZOcU1FcXJIQjFpZ0UwNEdOTU52bzl0VW5LZC9yajZE?= =?utf-8?B?cjBBODNQS3h3NmVLMS9DVTlzNmNGR0ZDenYzTTJJdXg5TGtXeFVSLy9QSjlB?= =?utf-8?B?T1o1QWQyVGRUMEdSaHhvN2ZHOFdCamZKNkhNZE9OK1V5MmVxWWFaZ1ZCOGN6?= =?utf-8?B?bzVaelZJaXFMSXROZ09QRkM1RmtoeFdFd2c1VzI1T1FtWGh6ZFJSQXlBeWg2?= =?utf-8?B?Y2lmQUtLNWVGZHkrVi81aG16cGlSK0N3bWlidmpvOWpDREhmRW1DNlVSaXRW?= =?utf-8?B?ZlQxdmJDVkhCdmYzNnpOV0E2bXZlOHA2L29jSnRUWGRwL2puS3VnQUMrL2FR?= =?utf-8?B?Nkpka2pmN3J0eHZvRjRaZzdwdGdQY2xEY09KWjF5elJOY3V4NE1uaThHRGgr?= =?utf-8?B?V1A2WG95MTBRYUdnblBIWVNFZVdubVdqT2YyNDROWU1PYkxyZDI2VjVPN0RQ?= =?utf-8?B?QWk2OEhnTFpIaTVPTGE4dDFuOWFTWXNsdFdWK0o2OFMwczRlNVJEMDA5eUgy?= =?utf-8?Q?/XG91g?= X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1213;6:C48BrbtZjZ7snj7O6Q8Y0x/XckyhRAk2dolAnokKti1LCe8ilI1us1l63RHXtCWCiHHyC4m8nBa1RacWjaBLq2IosKDkF1Wd9UbXawqM2Nt8cuZJ9mo/1GAW8rE0EwuspSwBlp6I8W88xp9BeJvJui8xXA+YRORfJiphkVNWM1++Kf3er8y3RAffNnKv/7Rq9Saf3tMXacPID7r58eRkK0zbopNjFAqQzBg0JFmhN78FrgpndvZBO+VoHayboyJibt392Qj9MMgFjvEvKS1SDR736fcV9jk5pPI6qJCc4OeZBegHTnPaz0N137lCVLZi35tVnamGGZU9XGPcWeQnwowHjCX2VpCPB2DXnnGksRs=;5:0Db6oLhEcDdh3g/W8kbTmm34YgiTys6Yt807EpiHIqMpqYt91W7DIYGCug9ufkKWwRlVENd7po/LT+zKlFSvwS8JaSCEyeu67Caw8+KrIQhZUliLMLDcnzepgpq4WCGke5p82+/DWLi0DdY/4rSs+XbWkJLVCty8304QvraZV5Q=;24:yYxYopz3ZzCKiTsNe16lW/bWGEDuIozP4Bi/7MmvnWahrP6i0/axAFK8ZW65jHxOUxCpvBcQnpSJ9xv7u7CI/xkg2F+XPSg/vGoIzmLKmXc=;7:HsIyw37iu9mifYoeSSqUbmYfpBEre19ndJ+NhR3hX5tHTg3JDkM+lQmATxEEh/TuszFVv2otug4cuTDggz5UfiVzVw+grR2pr2v2HJIHtGw/ayNWa2gmJNs5A7jotfotAoxLrFDc9EUr5TyWNkGJNzsXW8ogjOFaaht+mEaV0DnI4wkl1R8jk+KDQhMpTV/qctbI2DOA7bYA9kK2HvlaKTGI+hOUviUSuFjx6MlkLVpZCfSHfyWDlAYJ4CGaN8vj SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1;MWHPR12MB1213;20:zwRMEuaOo3Gj34GkAXxxrcfhwJcohcSxQbg4PNx5QZIp+xj373LFthbhRO64ewDAw+KJH3ZkttIHVTrFmIeOuVEf7E79o32E1OWDNcxF25/dcuNdjrnYrEtJZiQMmFAug8HA9JeyxJsTgeTmN42Yr6ioVmX7A4n5bhkm7GRR3pmjCRi4ttMnbdudb/03esRU7ZBDgvJB5JKzSbcDfJFD/KXJuPLt6rmuxTZWNUSUlupaOXLuI0cYV1WLb3Ez46VE X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 07 Nov 2017 15:46:23.4992 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 4c8db574-a3af-4b2a-1e95-08d525f6b3b3 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-Transport-CrossTenantHeadersStamped: MWHPR12MB1213 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 11/06/2017 12:11 PM, Brijesh Singh wrote: > AMD's new Secure Encrypted Virtualization (SEV) feature allows the > memory contents of virtual machines to be transparently encrypted with a > key unique to the VM. The programming and management of the encryption > keys are handled by the AMD Secure Processor (AMD-SP) which exposes the > commands for these tasks. The complete spec is available at: > > http://support.amd.com/TechDocs/55766_SEV-KM%20API_Specification.pdf > > Extend the AMD-SP driver to provide the following support: > > - an in-kernel API to communicate with the SEV firmware. The API can be > used by the hypervisor to create encryption context for a SEV guest. > > - a userspace IOCTL to manage the platform certificates. > > Cc: Paolo Bonzini > Cc: "Radim Krčmář" > Cc: Borislav Petkov > Cc: Herbert Xu > Cc: Gary Hook > Cc: Tom Lendacky > Cc: linux-crypto@vger.kernel.org > Cc: kvm@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > Improvements-by: Borislav Petkov > Signed-off-by: Brijesh Singh Acked-by: Gary R Hook > --- > drivers/crypto/ccp/psp-dev.c | 344 +++++++++++++++++++++++++++++++++++++++++++ > drivers/crypto/ccp/psp-dev.h | 24 +++ > drivers/crypto/ccp/sp-dev.c | 9 ++ > drivers/crypto/ccp/sp-dev.h | 4 + > include/linux/psp-sev.h | 137 +++++++++++++++++ > 5 files changed, 518 insertions(+) > > diff --git a/drivers/crypto/ccp/psp-dev.c b/drivers/crypto/ccp/psp-dev.c > index b5789f878560..9915a6c604a3 100644 > --- a/drivers/crypto/ccp/psp-dev.c > +++ b/drivers/crypto/ccp/psp-dev.c > @@ -26,6 +26,12 @@ > #include "sp-dev.h" > #include "psp-dev.h" > > +#define DEVICE_NAME "sev" > + > +static DEFINE_MUTEX(sev_cmd_mutex); > +static struct sev_misc_dev *misc_dev; > +static struct psp_device *psp_master; > + > static struct psp_device *psp_alloc_struct(struct sp_device *sp) > { > struct device *dev = sp->dev; > @@ -45,9 +51,285 @@ static struct psp_device *psp_alloc_struct(struct sp_device *sp) > > static irqreturn_t psp_irq_handler(int irq, void *data) > { > + struct psp_device *psp = data; > + unsigned int status; > + int reg; > + > + /* Read the interrupt status: */ > + status = ioread32(psp->io_regs + PSP_P2CMSG_INTSTS); > + > + /* Check if it is command completion: */ > + if (!(status & BIT(PSP_CMD_COMPLETE_REG))) > + goto done; > + > + /* Check if it is SEV command completion: */ > + reg = ioread32(psp->io_regs + PSP_CMDRESP); > + if (reg & PSP_CMDRESP_RESP) { > + psp->sev_int_rcvd = 1; > + wake_up(&psp->sev_int_queue); > + } > + > +done: > + /* Clear the interrupt status by writing the same value we read. */ > + iowrite32(status, psp->io_regs + PSP_P2CMSG_INTSTS); > + > return IRQ_HANDLED; > } > > +static void sev_wait_cmd_ioc(struct psp_device *psp, unsigned int *reg) > +{ > + psp->sev_int_rcvd = 0; > + > + wait_event(psp->sev_int_queue, psp->sev_int_rcvd); > + *reg = ioread32(psp->io_regs + PSP_CMDRESP); > +} > + > +static int sev_cmd_buffer_len(int cmd) > +{ > + switch (cmd) { > + case SEV_CMD_INIT: return sizeof(struct sev_data_init); > + case SEV_CMD_PLATFORM_STATUS: return sizeof(struct sev_user_data_status); > + case SEV_CMD_PEK_CSR: return sizeof(struct sev_data_pek_csr); > + case SEV_CMD_PEK_CERT_IMPORT: return sizeof(struct sev_data_pek_cert_import); > + case SEV_CMD_PDH_CERT_EXPORT: return sizeof(struct sev_data_pdh_cert_export); > + case SEV_CMD_LAUNCH_START: return sizeof(struct sev_data_launch_start); > + case SEV_CMD_LAUNCH_UPDATE_DATA: return sizeof(struct sev_data_launch_update_data); > + case SEV_CMD_LAUNCH_UPDATE_VMSA: return sizeof(struct sev_data_launch_update_vmsa); > + case SEV_CMD_LAUNCH_FINISH: return sizeof(struct sev_data_launch_finish); > + case SEV_CMD_LAUNCH_MEASURE: return sizeof(struct sev_data_launch_measure); > + case SEV_CMD_ACTIVATE: return sizeof(struct sev_data_activate); > + case SEV_CMD_DEACTIVATE: return sizeof(struct sev_data_deactivate); > + case SEV_CMD_DECOMMISSION: return sizeof(struct sev_data_decommission); > + case SEV_CMD_GUEST_STATUS: return sizeof(struct sev_data_guest_status); > + case SEV_CMD_DBG_DECRYPT: return sizeof(struct sev_data_dbg); > + case SEV_CMD_DBG_ENCRYPT: return sizeof(struct sev_data_dbg); > + case SEV_CMD_SEND_START: return sizeof(struct sev_data_send_start); > + case SEV_CMD_SEND_UPDATE_DATA: return sizeof(struct sev_data_send_update_data); > + case SEV_CMD_SEND_UPDATE_VMSA: return sizeof(struct sev_data_send_update_vmsa); > + case SEV_CMD_SEND_FINISH: return sizeof(struct sev_data_send_finish); > + case SEV_CMD_RECEIVE_START: return sizeof(struct sev_data_receive_start); > + case SEV_CMD_RECEIVE_FINISH: return sizeof(struct sev_data_receive_finish); > + case SEV_CMD_RECEIVE_UPDATE_DATA: return sizeof(struct sev_data_receive_update_data); > + case SEV_CMD_RECEIVE_UPDATE_VMSA: return sizeof(struct sev_data_receive_update_vmsa); > + case SEV_CMD_LAUNCH_UPDATE_SECRET: return sizeof(struct sev_data_launch_secret); > + default: return 0; > + } > + > + return 0; > +} > + > +static int __sev_do_cmd_locked(int cmd, void *data, int *psp_ret) > +{ > + struct psp_device *psp = psp_master; > + unsigned int phys_lsb, phys_msb; > + unsigned int reg, ret = 0; > + > + if (!psp) > + return -ENODEV; > + > + /* Get the physical address of the command buffer */ > + phys_lsb = data ? lower_32_bits(__psp_pa(data)) : 0; > + phys_msb = data ? upper_32_bits(__psp_pa(data)) : 0; > + > + dev_dbg(psp->dev, "sev command id %#x buffer 0x%08x%08x\n", > + cmd, phys_msb, phys_lsb); > + > + print_hex_dump_debug("(in): ", DUMP_PREFIX_OFFSET, 16, 2, data, > + sev_cmd_buffer_len(cmd), false); > + > + iowrite32(phys_lsb, psp->io_regs + PSP_CMDBUFF_ADDR_LO); > + iowrite32(phys_msb, psp->io_regs + PSP_CMDBUFF_ADDR_HI); > + > + reg = cmd; > + reg <<= PSP_CMDRESP_CMD_SHIFT; > + reg |= PSP_CMDRESP_IOC; > + iowrite32(reg, psp->io_regs + PSP_CMDRESP); > + > + /* wait for command completion */ > + sev_wait_cmd_ioc(psp, ®); > + > + if (psp_ret) > + *psp_ret = reg & PSP_CMDRESP_ERR_MASK; > + > + if (reg & PSP_CMDRESP_ERR_MASK) { > + dev_dbg(psp->dev, "sev command %#x failed (%#010x)\n", > + cmd, reg & PSP_CMDRESP_ERR_MASK); > + ret = -EIO; > + } > + > + print_hex_dump_debug("(out): ", DUMP_PREFIX_OFFSET, 16, 2, data, > + sev_cmd_buffer_len(cmd), false); > + > + return ret; > +} > + > +static int sev_do_cmd(int cmd, void *data, int *psp_ret) > +{ > + int rc; > + > + mutex_lock(&sev_cmd_mutex); > + rc = __sev_do_cmd_locked(cmd, data, psp_ret); > + mutex_unlock(&sev_cmd_mutex); > + > + return rc; > +} > + > +static int __sev_platform_init_locked(int *error) > +{ > + struct psp_device *psp = psp_master; > + int rc = 0; > + > + if (!psp) > + return -ENODEV; > + > + if (psp->sev_state == SEV_STATE_INIT) > + return 0; > + > + rc = __sev_do_cmd_locked(SEV_CMD_INIT, &psp->init_cmd_buf, error); > + if (rc) > + return rc; > + > + psp->sev_state = SEV_STATE_INIT; > + dev_dbg(psp->dev, "SEV firmware initialized\n"); > + > + return rc; > +} > + > +int sev_platform_init(int *error) > +{ > + int rc; > + > + mutex_lock(&sev_cmd_mutex); > + rc = __sev_platform_init_locked(error); > + mutex_unlock(&sev_cmd_mutex); > + > + return rc; > +} > +EXPORT_SYMBOL_GPL(sev_platform_init); > + > +static int __sev_platform_shutdown_locked(int *error) > +{ > + int ret; > + > + ret = __sev_do_cmd_locked(SEV_CMD_SHUTDOWN, 0, error); > + if (ret) > + return ret; > + > + psp_master->sev_state = SEV_STATE_UNINIT; > + dev_dbg(psp_master->dev, "SEV firmware shutdown\n"); > + > + return ret; > +} > + > +static int sev_platform_shutdown(int *error) > +{ > + int rc; > + > + mutex_lock(&sev_cmd_mutex); > + rc = __sev_platform_shutdown_locked(NULL); > + mutex_unlock(&sev_cmd_mutex); > + > + return rc; > +} > + > +static long sev_ioctl(struct file *file, unsigned int ioctl, unsigned long arg) > +{ > + return -ENOTTY; > +} > + > +static const struct file_operations sev_fops = { > + .owner = THIS_MODULE, > + .unlocked_ioctl = sev_ioctl, > +}; > + > +int sev_platform_status(struct sev_user_data_status *data, int *error) > +{ > + return sev_do_cmd(SEV_CMD_PLATFORM_STATUS, data, error); > +} > +EXPORT_SYMBOL_GPL(sev_platform_status); > + > +int sev_guest_deactivate(struct sev_data_deactivate *data, int *error) > +{ > + return sev_do_cmd(SEV_CMD_DEACTIVATE, data, error); > +} > +EXPORT_SYMBOL_GPL(sev_guest_deactivate); > + > +int sev_guest_activate(struct sev_data_activate *data, int *error) > +{ > + return sev_do_cmd(SEV_CMD_ACTIVATE, data, error); > +} > +EXPORT_SYMBOL_GPL(sev_guest_activate); > + > +int sev_guest_decommission(struct sev_data_decommission *data, int *error) > +{ > + return sev_do_cmd(SEV_CMD_DECOMMISSION, data, error); > +} > +EXPORT_SYMBOL_GPL(sev_guest_decommission); > + > +int sev_guest_df_flush(int *error) > +{ > + return sev_do_cmd(SEV_CMD_DF_FLUSH, 0, error); > +} > +EXPORT_SYMBOL_GPL(sev_guest_df_flush); > + > +static void sev_exit(struct kref *ref) > +{ > + struct sev_misc_dev *misc_dev = container_of(ref, struct sev_misc_dev, refcount); > + > + misc_deregister(&misc_dev->misc); > +} > + > +static int sev_misc_init(struct psp_device *psp) > +{ > + struct device *dev = psp->dev; > + int ret; > + > + /* > + * SEV feature support can be detected on multiple devices but the SEV > + * FW commands must be issued on the master. During probe, we do not > + * know the master hence we create /dev/sev on the first device probe. > + * sev_do_cmd() finds the right master device to which to issue the > + * command to the firmware. > + */ > + if (!misc_dev) { > + struct miscdevice *misc; > + > + misc_dev = devm_kzalloc(dev, sizeof(*misc_dev), GFP_KERNEL); > + if (!misc_dev) > + return -ENOMEM; > + > + misc = &misc_dev->misc; > + misc->minor = MISC_DYNAMIC_MINOR; > + misc->name = DEVICE_NAME; > + misc->fops = &sev_fops; > + > + ret = misc_register(misc); > + if (ret) > + return ret; > + > + kref_init(&misc_dev->refcount); > + } else { > + kref_get(&misc_dev->refcount); > + } > + > + init_waitqueue_head(&psp->sev_int_queue); > + psp->sev_misc = misc_dev; > + dev_dbg(dev, "registered SEV device\n"); > + > + return 0; > +} > + > +static int sev_init(struct psp_device *psp) > +{ > + /* Check if device supports SEV feature */ > + if (!(ioread32(psp->io_regs + PSP_FEATURE_REG) & 1)) { > + dev_dbg(psp->dev, "device does not support SEV\n"); > + return 1; > + } > + > + return sev_misc_init(psp); > +} > + > int psp_dev_init(struct sp_device *sp) > { > struct device *dev = sp->dev; > @@ -81,6 +363,10 @@ int psp_dev_init(struct sp_device *sp) > goto e_err; > } > > + ret = sev_init(psp); > + if (ret) > + goto e_irq; > + > if (sp->set_psp_master_device) > sp->set_psp_master_device(sp); > > @@ -89,6 +375,8 @@ int psp_dev_init(struct sp_device *sp) > > return 0; > > +e_irq: > + sp_free_psp_irq(psp->sp, psp); > e_err: > sp->psp_data = NULL; > > @@ -101,5 +389,61 @@ void psp_dev_destroy(struct sp_device *sp) > { > struct psp_device *psp = sp->psp_data; > > + if (psp->sev_misc) > + kref_put(&misc_dev->refcount, sev_exit); > + > sp_free_psp_irq(sp, psp); > } > + > +int sev_issue_cmd_external_user(struct file *filep, unsigned int cmd, > + void *data, int *error) > +{ > + if (!filep || filep->f_op != &sev_fops) > + return -EBADF; > + > + return sev_do_cmd(cmd, data, error); > +} > +EXPORT_SYMBOL_GPL(sev_issue_cmd_external_user); > + > +void psp_pci_init(void) > +{ > + struct sev_user_data_status *status; > + struct sp_device *sp; > + int error, rc; > + > + sp = sp_get_psp_master_device(); > + if (!sp) > + return; > + > + psp_master = sp->psp_data; > + > + /* Initialize the platform */ > + rc = sev_platform_init(&error); > + if (rc) { > + dev_err(sp->dev, "SEV: failed to INIT error %#x\n", error); > + goto err; > + } > + > + /* Display SEV firmware version */ > + status = &psp_master->status_cmd_buf; > + rc = sev_platform_status(status, &error); > + if (rc) { > + dev_err(sp->dev, "SEV: failed to get status error %#x\n", error); > + goto err; > + } > + > + dev_info(sp->dev, "SEV API:%d.%d build:%d\n", status->api_major, > + status->api_minor, status->build); > + return; > + > +err: > + psp_master = NULL; > +} > + > +void psp_pci_exit(void) > +{ > + if (!psp_master) > + return; > + > + sev_platform_shutdown(NULL); > +} > diff --git a/drivers/crypto/ccp/psp-dev.h b/drivers/crypto/ccp/psp-dev.h > index 55b7808367c3..c81f0b11287a 100644 > --- a/drivers/crypto/ccp/psp-dev.h > +++ b/drivers/crypto/ccp/psp-dev.h > @@ -25,9 +25,21 @@ > #include > #include > #include > +#include > +#include > > #include "sp-dev.h" > > +#define PSP_C2PMSG(_num) ((_num) << 2) > +#define PSP_CMDRESP PSP_C2PMSG(32) > +#define PSP_CMDBUFF_ADDR_LO PSP_C2PMSG(56) > +#define PSP_CMDBUFF_ADDR_HI PSP_C2PMSG(57) > +#define PSP_FEATURE_REG PSP_C2PMSG(63) > + > +#define PSP_P2CMSG(_num) ((_num) << 2) > +#define PSP_CMD_COMPLETE_REG 1 > +#define PSP_CMD_COMPLETE PSP_P2CMSG(PSP_CMD_COMPLETE_REG) > + > #define PSP_P2CMSG_INTEN 0x0110 > #define PSP_P2CMSG_INTSTS 0x0114 > > @@ -44,6 +56,11 @@ > > #define MAX_PSP_NAME_LEN 16 > > +struct sev_misc_dev { > + struct kref refcount; > + struct miscdevice misc; > +}; > + > struct psp_device { > struct list_head entry; > > @@ -54,6 +71,13 @@ struct psp_device { > struct sp_device *sp; > > void __iomem *io_regs; > + > + int sev_state; > + unsigned int sev_int_rcvd; > + wait_queue_head_t sev_int_queue; > + struct sev_misc_dev *sev_misc; > + struct sev_user_data_status status_cmd_buf; > + struct sev_data_init init_cmd_buf; > }; > > #endif /* __PSP_DEV_H */ > diff --git a/drivers/crypto/ccp/sp-dev.c b/drivers/crypto/ccp/sp-dev.c > index cf101c039c8f..eb0da6572720 100644 > --- a/drivers/crypto/ccp/sp-dev.c > +++ b/drivers/crypto/ccp/sp-dev.c > @@ -272,6 +272,10 @@ static int __init sp_mod_init(void) > if (ret) > return ret; > > +#ifdef CONFIG_CRYPTO_DEV_SP_PSP > + psp_pci_init(); > +#endif > + > return 0; > #endif > > @@ -291,6 +295,11 @@ static int __init sp_mod_init(void) > static void __exit sp_mod_exit(void) > { > #ifdef CONFIG_X86 > + > +#ifdef CONFIG_CRYPTO_DEV_SP_PSP > + psp_pci_exit(); > +#endif > + > sp_pci_exit(); > #endif > > diff --git a/drivers/crypto/ccp/sp-dev.h b/drivers/crypto/ccp/sp-dev.h > index 909cf3e436b4..acb197b66ced 100644 > --- a/drivers/crypto/ccp/sp-dev.h > +++ b/drivers/crypto/ccp/sp-dev.h > @@ -143,12 +143,16 @@ static inline int ccp_dev_resume(struct sp_device *sp) > #ifdef CONFIG_CRYPTO_DEV_SP_PSP > > int psp_dev_init(struct sp_device *sp); > +void psp_pci_init(void); > void psp_dev_destroy(struct sp_device *sp); > +void psp_pci_exit(void); > > #else /* !CONFIG_CRYPTO_DEV_SP_PSP */ > > static inline int psp_dev_init(struct sp_device *sp) { return 0; } > +static inline void psp_pci_init(void) { } > static inline void psp_dev_destroy(struct sp_device *sp) { } > +static inline void psp_pci_exit(void) { } > > #endif /* CONFIG_CRYPTO_DEV_SP_PSP */ > > diff --git a/include/linux/psp-sev.h b/include/linux/psp-sev.h > index 4a150d17d537..0b6dd306d88b 100644 > --- a/include/linux/psp-sev.h > +++ b/include/linux/psp-sev.h > @@ -462,4 +462,141 @@ struct sev_data_dbg { > u32 len; /* In */ > } __packed; > > +#ifdef CONFIG_CRYPTO_DEV_SP_PSP > + > +/** > + * sev_platform_init - perform SEV INIT command > + * > + * @error: SEV command return code > + * > + * Returns: > + * 0 if the SEV successfully processed the command > + * -%ENODEV if the SEV device is not available > + * -%ENOTSUPP if the SEV does not support SEV > + * -%ETIMEDOUT if the SEV command timed out > + * -%EIO if the SEV returned a non-zero return code > + */ > +int sev_platform_init(int *error); > + > +/** > + * sev_platform_status - perform SEV PLATFORM_STATUS command > + * > + * @status: sev_user_data_status structure to be processed > + * @error: SEV command return code > + * > + * Returns: > + * 0 if the SEV successfully processed the command > + * -%ENODEV if the SEV device is not available > + * -%ENOTSUPP if the SEV does not support SEV > + * -%ETIMEDOUT if the SEV command timed out > + * -%EIO if the SEV returned a non-zero return code > + */ > +int sev_platform_status(struct sev_user_data_status *status, int *error); > + > +/** > + * sev_issue_cmd_external_user - issue SEV command by other driver with a file > + * handle. > + * > + * This function can be used by other drivers to issue a SEV command on > + * behalf of userspace. The caller must pass a valid SEV file descriptor > + * so that we know that it has access to SEV device. > + * > + * @filep - SEV device file pointer > + * @cmd - command to issue > + * @data - command buffer > + * @error: SEV command return code > + * > + * Returns: > + * 0 if the SEV successfully processed the command > + * -%ENODEV if the SEV device is not available > + * -%ENOTSUPP if the SEV does not support SEV > + * -%ETIMEDOUT if the SEV command timed out > + * -%EIO if the SEV returned a non-zero return code > + * -%EINVAL if the SEV file descriptor is not valid > + */ > +int sev_issue_cmd_external_user(struct file *filep, unsigned int id, > + void *data, int *error); > + > +/** > + * sev_guest_deactivate - perform SEV DEACTIVATE command > + * > + * @deactivate: sev_data_deactivate structure to be processed > + * @sev_ret: sev command return code > + * > + * Returns: > + * 0 if the sev successfully processed the command > + * -%ENODEV if the sev device is not available > + * -%ENOTSUPP if the sev does not support SEV > + * -%ETIMEDOUT if the sev command timed out > + * -%EIO if the sev returned a non-zero return code > + */ > +int sev_guest_deactivate(struct sev_data_deactivate *data, int *error); > + > +/** > + * sev_guest_activate - perform SEV ACTIVATE command > + * > + * @activate: sev_data_activate structure to be processed > + * @sev_ret: sev command return code > + * > + * Returns: > + * 0 if the sev successfully processed the command > + * -%ENODEV if the sev device is not available > + * -%ENOTSUPP if the sev does not support SEV > + * -%ETIMEDOUT if the sev command timed out > + * -%EIO if the sev returned a non-zero return code > + */ > +int sev_guest_activate(struct sev_data_activate *data, int *error); > + > +/** > + * sev_guest_df_flush - perform SEV DF_FLUSH command > + * > + * @sev_ret: sev command return code > + * > + * Returns: > + * 0 if the sev successfully processed the command > + * -%ENODEV if the sev device is not available > + * -%ENOTSUPP if the sev does not support SEV > + * -%ETIMEDOUT if the sev command timed out > + * -%EIO if the sev returned a non-zero return code > + */ > +int sev_guest_df_flush(int *error); > + > +/** > + * sev_guest_decommission - perform SEV DECOMMISSION command > + * > + * @decommission: sev_data_decommission structure to be processed > + * @sev_ret: sev command return code > + * > + * Returns: > + * 0 if the sev successfully processed the command > + * -%ENODEV if the sev device is not available > + * -%ENOTSUPP if the sev does not support SEV > + * -%ETIMEDOUT if the sev command timed out > + * -%EIO if the sev returned a non-zero return code > + */ > +int sev_guest_decommission(struct sev_data_decommission *data, int *error); > + > +#else /* !CONFIG_CRYPTO_DEV_SP_PSP */ > + > +static inline int > +sev_platform_status(struct sev_user_data_status *status, int *error) { return -ENODEV; } > + > +static inline int sev_platform_init(int *error) { return -ENODEV; } > + > +static inline int > +sev_guest_deactivate(struct sev_data_deactivate *data, int *error) { return -ENODEV; } > + > +static inline int > +sev_guest_decommission(struct sev_data_decommission *data, int *error) { return -ENODEV; } > + > +static inline int > +sev_guest_activate(struct sev_data_activate *data, int *error) { return -ENODEV; } > + > +static inline int sev_guest_df_flush(int *error) { return -ENODEV; } > + > +static inline int > +sev_issue_cmd_external_user(struct file *filep, unsigned int id, void *data, int *error) { return -ENODEV; } > + > +#endif /* CONFIG_CRYPTO_DEV_SP_PSP */ > + > #endif /* __PSP_SEV_H__ */ >