A-Team_Digital_Solutions/android_kernel_motorola_sm6375
Watch
2
0
Fork
You've already forked android_kernel_motorola_sm6375
 0
mirror of https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git synced 2026-10-26 06:33:19 -04:00
Code Issues Projects Releases Packages Wiki Activity

libnvdimm for 4.21

Browse source 
* Add support for the security features of nvdimm devices that
   implement a security model similar to ATA hard drive security. The
   security model supports locking access to the media at
   device-power-loss, to be unlocked with a passphrase, and secure-erase
   (crypto-scramble).
 
   Unlike the ATA security case where the kernel expects device
   security to be managed in a pre-OS environment, the libnvdimm security
   implementation allows key provisioning and key-operations at OS
   runtime. Keys are managed with the kernel's encrypted-keys facility to
   provide data-at-rest security for the libnvdimm key material. The
   usage model mirrors fscrypt key management, but is driven via
   libnvdimm sysfs.
 
 * Miscellaneous updates for api usage and comment fixes.
 -----BEGIN PGP SIGNATURE-----
 
 iQIcBAABAgAGBQJcJalaAAoJEB7SkWpmfYgCmpkP/35Isou2xxbYdICt9HR4WjiE
 E4r66Ck+ivZW4oEAub3RQw/SwcZePjuHArO5MgVGFoM1dBMABE+JvKiZm1xybCil
 iuWT/V7ozlNf5LuvacvjUXe/suUIoqji9yzLEEx9mDaISehrYvvy579DFxkE8Aww
 8Vcx8E1DQkXiWY4d9nmDmAjt8GQPNmsdHfTwMcJg7XSywTkURF64vW7/94aN8QtV
 rH5ZKKOra8Lqn0S05RoH4XegZcE6TZxgE23ZXsobBJrWdbGVFmgbz6AaewJc/+QU
 ZW3dx/1NAe7Op25xewJOjdG/Kl0gzWtqCrHCu8LeaSjwtHsgMQ/FBhL9g/7GRtHt
 hcQy12Iu9YTn3FOl8yfNRKb7lE5/1nJ2MtW8Z55WKHONHzN9cgrZLOwmpTYgrR/r
 SmIzwKNFavLwwz9bj+paHhmTngLDnNbvR6FwAKwSbWinotbLEyfMhU1jJ9RmHxSV
 M+jqS1BJ9IvH+WVN5bVa7oCNpVeq6yMw0Ow2vWXMPbiwh17ShACI59paqZKRiR06
 WH8SgdTPOZuMndtQV+m8zFBiJtmgAtGSiN8c1A/1QZJHDTpXz2MdWhtx5McvFsZ9
 Jot4Vd8mFWI7oVLdb+PF/AGZnKNAnD8PdsAlFws0k7+rM6lf6gf5n/CkjjMuSapG
 Q/kf0cOpPq8wdsrnOzyc
 =7KYd
 -----END PGP SIGNATURE-----

Merge tag 'libnvdimm-for-4.21' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm

Pull libnvdimm updates from Dan Williams:
 "The vast bulk of this update is the new support for the security
  capabilities of some nvdimms.

  The userspace tooling for this capability is still a work in progress,
  but the changes survive the existing libnvdimm unit tests. The changes
  also pass manual checkout on hardware and the new nfit_test emulation
  of the security capability.

  The touches of the security/keys/ files have received the necessary
  acks from Mimi and David. Those changes were necessary to allow for a
  new generic encrypted-key type, and allow the nvdimm sub-system to
  lookup key material referenced by the libnvdimm-sysfs interface.

  Summary:

   - Add support for the security features of nvdimm devices that
     implement a security model similar to ATA hard drive security. The
     security model supports locking access to the media at
     device-power-loss, to be unlocked with a passphrase, and
     secure-erase (crypto-scramble).

     Unlike the ATA security case where the kernel expects device
     security to be managed in a pre-OS environment, the libnvdimm
     security implementation allows key provisioning and key-operations
     at OS runtime. Keys are managed with the kernel's encrypted-keys
     facility to provide data-at-rest security for the libnvdimm key
     material. The usage model mirrors fscrypt key management, but is
     driven via libnvdimm sysfs.

   - Miscellaneous updates for api usage and comment fixes"

* tag 'libnvdimm-for-4.21' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (21 commits)
  libnvdimm/security: Quiet security operations
  libnvdimm/security: Add documentation for nvdimm security support
  tools/testing/nvdimm: add Intel DSM 1.8 support for nfit_test
  tools/testing/nvdimm: Add overwrite support for nfit_test
  tools/testing/nvdimm: Add test support for Intel nvdimm security DSMs
  acpi/nfit, libnvdimm/security: add Intel DSM 1.8 master passphrase support
  acpi/nfit, libnvdimm/security: Add security DSM overwrite support
  acpi/nfit, libnvdimm: Add support for issue secure erase DSM to Intel nvdimm
  acpi/nfit, libnvdimm: Add enable/update passphrase support for Intel nvdimms
  acpi/nfit, libnvdimm: Add disable passphrase support to Intel nvdimm.
  acpi/nfit, libnvdimm: Add unlock of nvdimm support for Intel DIMMs
  acpi/nfit, libnvdimm: Add freeze security support to Intel nvdimm
  acpi/nfit, libnvdimm: Introduce nvdimm_security_ops
  keys-encrypted: add nvdimm key format type to encrypted keys
  keys: Export lookup_user_key to external users
  acpi/nfit, libnvdimm: Store dimm id as a member to struct nvdimm
  libnvdimm, namespace: Replace kmemdup() with kstrndup()
  libnvdimm, label: Switch to bitmap_zalloc()
  ACPI/nfit: Adjust annotation for why return 0 if fail to find NFIT at start
  libnvdimm, bus: Check id immediately following ida_simple_get
  ...
This commit is contained in:
Linus Torvalds 2018-12-28 15:05:13 -08:00
commit 75f95da078
27 changed files with 1971 additions and 54 deletions
Download patch file Download diff file Expand all files Collapse all files

3
tools/testing/nvdimm/Kbuild
View file

@ -37,6 +37,7 @@ obj-$(CONFIG_DEV_DAX) += device_dax.o
obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o
nfit-y := $(ACPI_SRC)/core.o
nfit-y += $(ACPI_SRC)/intel.o
nfit-$(CONFIG_X86_MCE) += $(ACPI_SRC)/mce.o
nfit-y += acpi_nfit_test.o
nfit-y += config_check.o
@ -79,6 +80,8 @@ libnvdimm-$(CONFIG_ND_CLAIM) += $(NVDIMM_SRC)/claim.o
libnvdimm-$(CONFIG_BTT) += $(NVDIMM_SRC)/btt_devs.o
libnvdimm-$(CONFIG_NVDIMM_PFN) += $(NVDIMM_SRC)/pfn_devs.o
libnvdimm-$(CONFIG_NVDIMM_DAX) += $(NVDIMM_SRC)/dax_devs.o
libnvdimm-$(CONFIG_NVDIMM_KEYS) += $(NVDIMM_SRC)/security.o
libnvdimm-y += dimm_devs.o
libnvdimm-y += libnvdimm_test.o
libnvdimm-y += config_check.o

41
tools/testing/nvdimm/dimm_devs.c Normal file
View file

@ -0,0 +1,41 @@
// SPDX-License-Identifier: GPL-2.0
/* Copyright Intel Corp. 2018 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/nd.h>
#include "pmem.h"
#include "pfn.h"
#include "nd.h"
#include "nd-core.h"
ssize_t security_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct nvdimm *nvdimm = to_nvdimm(dev);
/*
* For the test version we need to poll the "hardware" in order
* to get the updated status for unlock testing.
*/
nvdimm->sec.state = nvdimm_security_state(nvdimm, false);
nvdimm->sec.ext_state = nvdimm_security_state(nvdimm, true);
switch (nvdimm->sec.state) {
case NVDIMM_SECURITY_DISABLED:
return sprintf(buf, "disabled\n");
case NVDIMM_SECURITY_UNLOCKED:
return sprintf(buf, "unlocked\n");
case NVDIMM_SECURITY_LOCKED:
return sprintf(buf, "locked\n");
case NVDIMM_SECURITY_FROZEN:
return sprintf(buf, "frozen\n");
case NVDIMM_SECURITY_OVERWRITE:
return sprintf(buf, "overwrite\n");
default:
return -ENOTTY;
}
return -ENOTTY;
}

321
tools/testing/nvdimm/test/nfit.c
View file

@ -143,6 +143,13 @@ static u32 handle[] = {
static unsigned long dimm_fail_cmd_flags[ARRAY_SIZE(handle)];
static int dimm_fail_cmd_code[ARRAY_SIZE(handle)];
struct nfit_test_sec {
u8 state;
u8 ext_state;
u8 passphrase[32];
u8 master_passphrase[32];
u64 overwrite_end_time;
} dimm_sec_info[NUM_DCR];
static const struct nd_intel_smart smart_def = {
.flags = ND_INTEL_SMART_HEALTH_VALID
@ -936,6 +943,242 @@ static int override_return_code(int dimm, unsigned int func, int rc)
return rc;
}
static int nd_intel_test_cmd_security_status(struct nfit_test *t,
struct nd_intel_get_security_state *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
nd_cmd->status = 0;
nd_cmd->state = sec->state;
nd_cmd->extended_state = sec->ext_state;
dev_dbg(dev, "security state (%#x) returned\n", nd_cmd->state);
return 0;
}
static int nd_intel_test_cmd_unlock_unit(struct nfit_test *t,
struct nd_intel_unlock_unit *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->state & ND_INTEL_SEC_STATE_LOCKED) ||
(sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "unlock unit: invalid state: %#x\n",
sec->state);
} else if (memcmp(nd_cmd->passphrase, sec->passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "unlock unit: invalid passphrase\n");
} else {
nd_cmd->status = 0;
sec->state = ND_INTEL_SEC_STATE_ENABLED;
dev_dbg(dev, "Unit unlocked\n");
}
dev_dbg(dev, "unlocking status returned: %#x\n", nd_cmd->status);
return 0;
}
static int nd_intel_test_cmd_set_pass(struct nfit_test *t,
struct nd_intel_set_passphrase *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (sec->state & ND_INTEL_SEC_STATE_FROZEN) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "set passphrase: wrong security state\n");
} else if (memcmp(nd_cmd->old_pass, sec->passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "set passphrase: wrong passphrase\n");
} else {
memcpy(sec->passphrase, nd_cmd->new_pass,
ND_INTEL_PASSPHRASE_SIZE);
sec->state |= ND_INTEL_SEC_STATE_ENABLED;
nd_cmd->status = 0;
dev_dbg(dev, "passphrase updated\n");
}
return 0;
}
static int nd_intel_test_cmd_freeze_lock(struct nfit_test *t,
struct nd_intel_freeze_lock *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED)) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "freeze lock: wrong security state\n");
} else {
sec->state |= ND_INTEL_SEC_STATE_FROZEN;
nd_cmd->status = 0;
dev_dbg(dev, "security frozen\n");
}
return 0;
}
static int nd_intel_test_cmd_disable_pass(struct nfit_test *t,
struct nd_intel_disable_passphrase *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) ||
(sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "disable passphrase: wrong security state\n");
} else if (memcmp(nd_cmd->passphrase, sec->passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "disable passphrase: wrong passphrase\n");
} else {
memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
sec->state = 0;
dev_dbg(dev, "disable passphrase: done\n");
}
return 0;
}
static int nd_intel_test_cmd_secure_erase(struct nfit_test *t,
struct nd_intel_secure_erase *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->state & ND_INTEL_SEC_STATE_ENABLED) ||
(sec->state & ND_INTEL_SEC_STATE_FROZEN)) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "secure erase: wrong security state\n");
} else if (memcmp(nd_cmd->passphrase, sec->passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "secure erase: wrong passphrase\n");
} else {
memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
memset(sec->master_passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
sec->state = 0;
sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED;
dev_dbg(dev, "secure erase: done\n");
}
return 0;
}
static int nd_intel_test_cmd_overwrite(struct nfit_test *t,
struct nd_intel_overwrite *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if ((sec->state & ND_INTEL_SEC_STATE_ENABLED) &&
memcmp(nd_cmd->passphrase, sec->passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "overwrite: wrong passphrase\n");
return 0;
}
memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
sec->state = ND_INTEL_SEC_STATE_OVERWRITE;
dev_dbg(dev, "overwrite progressing.\n");
sec->overwrite_end_time = get_jiffies_64() + 5 * HZ;
return 0;
}
static int nd_intel_test_cmd_query_overwrite(struct nfit_test *t,
struct nd_intel_query_overwrite *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->state & ND_INTEL_SEC_STATE_OVERWRITE)) {
nd_cmd->status = ND_INTEL_STATUS_OQUERY_SEQUENCE_ERR;
return 0;
}
if (time_is_before_jiffies64(sec->overwrite_end_time)) {
sec->overwrite_end_time = 0;
sec->state = 0;
sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED;
dev_dbg(dev, "overwrite is complete\n");
} else
nd_cmd->status = ND_INTEL_STATUS_OQUERY_INPROGRESS;
return 0;
}
static int nd_intel_test_cmd_master_set_pass(struct nfit_test *t,
struct nd_intel_set_master_passphrase *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->ext_state & ND_INTEL_SEC_ESTATE_ENABLED)) {
nd_cmd->status = ND_INTEL_STATUS_NOT_SUPPORTED;
dev_dbg(dev, "master set passphrase: in wrong state\n");
} else if (sec->ext_state & ND_INTEL_SEC_ESTATE_PLIMIT) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "master set passphrase: in wrong security state\n");
} else if (memcmp(nd_cmd->old_pass, sec->master_passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "master set passphrase: wrong passphrase\n");
} else {
memcpy(sec->master_passphrase, nd_cmd->new_pass,
ND_INTEL_PASSPHRASE_SIZE);
sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED;
dev_dbg(dev, "master passphrase: updated\n");
}
return 0;
}
static int nd_intel_test_cmd_master_secure_erase(struct nfit_test *t,
struct nd_intel_master_secure_erase *nd_cmd,
unsigned int buf_len, int dimm)
{
struct device *dev = &t->pdev.dev;
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
if (!(sec->ext_state & ND_INTEL_SEC_ESTATE_ENABLED)) {
nd_cmd->status = ND_INTEL_STATUS_NOT_SUPPORTED;
dev_dbg(dev, "master secure erase: in wrong state\n");
} else if (sec->ext_state & ND_INTEL_SEC_ESTATE_PLIMIT) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_STATE;
dev_dbg(dev, "master secure erase: in wrong security state\n");
} else if (memcmp(nd_cmd->passphrase, sec->master_passphrase,
ND_INTEL_PASSPHRASE_SIZE) != 0) {
nd_cmd->status = ND_INTEL_STATUS_INVALID_PASS;
dev_dbg(dev, "master secure erase: wrong passphrase\n");
} else {
/* we do not erase master state passphrase ever */
sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED;
memset(sec->passphrase, 0, ND_INTEL_PASSPHRASE_SIZE);
sec->state = 0;
dev_dbg(dev, "master secure erase: done\n");
}
return 0;
}
static int get_dimm(struct nfit_mem *nfit_mem, unsigned int func)
{
int i;
@ -983,6 +1226,46 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
return i;
switch (func) {
case NVDIMM_INTEL_GET_SECURITY_STATE:
rc = nd_intel_test_cmd_security_status(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_UNLOCK_UNIT:
rc = nd_intel_test_cmd_unlock_unit(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_SET_PASSPHRASE:
rc = nd_intel_test_cmd_set_pass(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_DISABLE_PASSPHRASE:
rc = nd_intel_test_cmd_disable_pass(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_FREEZE_LOCK:
rc = nd_intel_test_cmd_freeze_lock(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_SECURE_ERASE:
rc = nd_intel_test_cmd_secure_erase(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_OVERWRITE:
rc = nd_intel_test_cmd_overwrite(t,
buf, buf_len, i - t->dcr_idx);
break;
case NVDIMM_INTEL_QUERY_OVERWRITE:
rc = nd_intel_test_cmd_query_overwrite(t,
buf, buf_len, i - t->dcr_idx);
break;
case NVDIMM_INTEL_SET_MASTER_PASSPHRASE:
rc = nd_intel_test_cmd_master_set_pass(t,
buf, buf_len, i);
break;
case NVDIMM_INTEL_MASTER_SECURE_ERASE:
rc = nd_intel_test_cmd_master_secure_erase(t,
buf, buf_len, i);
break;
case ND_INTEL_ENABLE_LSS_STATUS:
rc = nd_intel_test_cmd_set_lss_status(t,
buf, buf_len);
@ -1328,10 +1611,22 @@ static ssize_t fail_cmd_code_store(struct device *dev, struct device_attribute *
}
static DEVICE_ATTR_RW(fail_cmd_code);
static ssize_t lock_dimm_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int dimm = dimm_name_to_id(dev);
struct nfit_test_sec *sec = &dimm_sec_info[dimm];
sec->state = ND_INTEL_SEC_STATE_ENABLED | ND_INTEL_SEC_STATE_LOCKED;
return size;
}
static DEVICE_ATTR_WO(lock_dimm);
static struct attribute *nfit_test_dimm_attributes[] = {
&dev_attr_fail_cmd.attr,
&dev_attr_fail_cmd_code.attr,
&dev_attr_handle.attr,
&dev_attr_lock_dimm.attr,
NULL,
};
@ -1361,6 +1656,17 @@ static int nfit_test_dimm_init(struct nfit_test *t)
return 0;
}
static void security_init(struct nfit_test *t)
{
int i;
for (i = 0; i < t->num_dcr; i++) {
struct nfit_test_sec *sec = &dimm_sec_info[i];
sec->ext_state = ND_INTEL_SEC_ESTATE_ENABLED;
}
}
static void smart_init(struct nfit_test *t)
{
int i;
@ -1439,6 +1745,7 @@ static int nfit_test0_alloc(struct nfit_test *t)
if (nfit_test_dimm_init(t))
return -ENOMEM;
smart_init(t);
security_init(t);
return ars_state_init(&t->pdev.dev, &t->ars_state);
}
@ -2210,6 +2517,20 @@ static void nfit_test0_setup(struct nfit_test *t)
set_bit(ND_INTEL_FW_FINISH_UPDATE, &acpi_desc->dimm_cmd_force_en);
set_bit(ND_INTEL_FW_FINISH_QUERY, &acpi_desc->dimm_cmd_force_en);
set_bit(ND_INTEL_ENABLE_LSS_STATUS, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_GET_SECURITY_STATE,
&acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_SET_PASSPHRASE, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_DISABLE_PASSPHRASE,
&acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_UNLOCK_UNIT, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_FREEZE_LOCK, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_SECURE_ERASE, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_OVERWRITE, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_QUERY_OVERWRITE, &acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_SET_MASTER_PASSPHRASE,
&acpi_desc->dimm_cmd_force_en);
set_bit(NVDIMM_INTEL_MASTER_SECURE_ERASE,
&acpi_desc->dimm_cmd_force_en);
}
static void nfit_test1_setup(struct nfit_test *t)