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

What:		/sys/bus/nd/devices/nmemX/papr/flags

Date:		Apr, 2020

KernelVersion:	v5.8

Contact:	linuxppc-dev <linuxppc-dev@lists.ozlabs.org>, linux-nvdimm@lists.01.org,

Description:

		(RO) Report flags indicating various states of a

		papr-pmem NVDIMM device. Each flag maps to a one or

		more bits set in the dimm-health-bitmap retrieved in

		response to H_SCM_HEALTH hcall. The details of the bit

		flags returned in response to this hcall is available

		at 'Documentation/powerpc/papr_hcalls.rst' . Below are

		the flags reported in this sysfs file:

		* "not_armed"	: Indicates that NVDIMM contents will not

				  survive a power cycle.

		* "flush_fail"	: Indicates that NVDIMM contents

				  couldn't be flushed during last

				  shut-down event.

		* "restore_fail": Indicates that NVDIMM contents

				  couldn't be restored during NVDIMM

				  initialization.

		* "encrypted"	: NVDIMM contents are encrypted.

		* "smart_notify": There is health event for the NVDIMM.

		* "scrubbed"	: Indicating that contents of the

				  NVDIMM have been scrubbed.

		* "locked"	: Indicating that NVDIMM contents cant

				  be modified until next power cycle.

**H_SCM_HEALTH**

| Input: drcIndex

| Out: *health-bitmap, health-bit-valid-bitmap*

| Out: *health-bitmap (r4), health-bit-valid-bitmap (r5)*

| Return Value: *H_Success, H_Parameter, H_Hardware*

Given a DRC Index return the info on predictive failure and overall health of

the NVDIMM. The asserted bits in the health-bitmap indicate a single predictive

failure and health-bit-valid-bitmap indicate which bits in health-bitmap are

valid.

the PMEM device. The asserted bits in the health-bitmap indicate one or more states

(described in table below) of the PMEM device and health-bit-valid-bitmap indicate

which bits in health-bitmap are valid. The bits are reported in

reverse bit ordering for example a value of 0xC400000000000000

indicates bits 0, 1, and 5 are valid.

Health Bitmap Flags:

+------+-----------------------------------------------------------------------+

|  Bit |               Definition                                              |

+======+=======================================================================+

|  00  | PMEM device is unable to persist memory contents.                     |

|      | If the system is powered down, nothing will be saved.                 |

+------+-----------------------------------------------------------------------+

|  01  | PMEM device failed to persist memory contents. Either contents were   |

|      | not saved successfully on power down or were not restored properly on |

|      | power up.                                                             |

+------+-----------------------------------------------------------------------+

|  02  | PMEM device contents are persisted from previous IPL. The data from   |

|      | the last boot were successfully restored.                             |

+------+-----------------------------------------------------------------------+

|  03  | PMEM device contents are not persisted from previous IPL. There was no|

|      | data to restore from the last boot.                                   |

+------+-----------------------------------------------------------------------+

|  04  | PMEM device memory life remaining is critically low                   |

+------+-----------------------------------------------------------------------+

|  05  | PMEM device will be garded off next IPL due to failure                |

+------+-----------------------------------------------------------------------+

|  06  | PMEM device contents cannot persist due to current platform health    |

|      | status. A hardware failure may prevent data from being saved or       |

|      | restored.                                                             |

+------+-----------------------------------------------------------------------+

|  07  | PMEM device is unable to persist memory contents in certain conditions|

+------+-----------------------------------------------------------------------+

|  08  | PMEM device is encrypted                                              |

+------+-----------------------------------------------------------------------+

|  09  | PMEM device has successfully completed a requested erase or secure    |

|      | erase procedure.                                                      |

+------+-----------------------------------------------------------------------+

|10:63 | Reserved / Unused                                                     |

+------+-----------------------------------------------------------------------+

**H_SCM_PERFORMANCE_STATS**

/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */

/*

 * PAPR nvDimm Specific Methods (PDSM) and structs for libndctl

 *

 * (C) Copyright IBM 2020

 *

 * Author: Vaibhav Jain <vaibhav at linux.ibm.com>

 */

#ifndef _UAPI_ASM_POWERPC_PAPR_PDSM_H_

#define _UAPI_ASM_POWERPC_PAPR_PDSM_H_

#include <linux/types.h>

#include <linux/ndctl.h>

/*

 * PDSM Envelope:

 *

 * The ioctl ND_CMD_CALL exchange data between user-space and kernel via

 * envelope which consists of 2 headers sections and payload sections as

 * illustrated below:

 *  +-----------------+---------------+---------------------------+

 *  |   64-Bytes      |   8-Bytes     |       Max 184-Bytes       |

 *  +-----------------+---------------+---------------------------+

 *  | ND-HEADER       |  PDSM-HEADER  |      PDSM-PAYLOAD         |

 *  +-----------------+---------------+---------------------------+

 *  | nd_family       |               |                           |

 *  | nd_size_out     | cmd_status    |                           |

 *  | nd_size_in      | reserved      |     nd_pdsm_payload       |

 *  | nd_command      | payload   --> |                           |

 *  | nd_fw_size      |               |                           |

 *  | nd_payload ---> |               |                           |

 *  +---------------+-----------------+---------------------------+

 *

 * ND Header:

 * This is the generic libnvdimm header described as 'struct nd_cmd_pkg'

 * which is interpreted by libnvdimm before passed on to papr_scm. Important

 * member fields used are:

 * 'nd_family'		: (In) NVDIMM_FAMILY_PAPR_SCM

 * 'nd_size_in'		: (In) PDSM-HEADER + PDSM-IN-PAYLOAD (usually 0)

 * 'nd_size_out'        : (In) PDSM-HEADER + PDSM-RETURN-PAYLOAD

 * 'nd_command'         : (In) One of PAPR_PDSM_XXX

 * 'nd_fw_size'         : (Out) PDSM-HEADER + size of actual payload returned

 *

 * PDSM Header:

 * This is papr-scm specific header that precedes the payload. This is defined

 * as nd_cmd_pdsm_pkg.  Following fields aare available in this header:

 *

 * 'cmd_status'		: (Out) Errors if any encountered while servicing PDSM.

 * 'reserved'		: Not used, reserved for future and should be set to 0.

 * 'payload'            : A union of all the possible payload structs

 *

 * PDSM Payload:

 *

 * The layout of the PDSM Payload is defined by various structs shared between

 * papr_scm and libndctl so that contents of payload can be interpreted. As such

 * its defined as a union of all possible payload structs as

 * 'union nd_pdsm_payload'. Based on the value of 'nd_cmd_pkg.nd_command'

 * appropriate member of the union is accessed.

 */

/* Max payload size that we can handle */

#define ND_PDSM_PAYLOAD_MAX_SIZE 184

/* Max payload size that we can handle */

#define ND_PDSM_HDR_SIZE \

	(sizeof(struct nd_pkg_pdsm) - ND_PDSM_PAYLOAD_MAX_SIZE)

/* Various nvdimm health indicators */

#define PAPR_PDSM_DIMM_HEALTHY       0

#define PAPR_PDSM_DIMM_UNHEALTHY     1

#define PAPR_PDSM_DIMM_CRITICAL      2

#define PAPR_PDSM_DIMM_FATAL         3

/*

 * Struct exchanged between kernel & ndctl in for PAPR_PDSM_HEALTH

 * Various flags indicate the health status of the dimm.

 *

 * extension_flags	: Any extension fields present in the struct.

 * dimm_unarmed		: Dimm not armed. So contents wont persist.

 * dimm_bad_shutdown	: Previous shutdown did not persist contents.

 * dimm_bad_restore	: Contents from previous shutdown werent restored.

 * dimm_scrubbed	: Contents of the dimm have been scrubbed.

 * dimm_locked		: Contents of the dimm cant be modified until CEC reboot

 * dimm_encrypted	: Contents of dimm are encrypted.

 * dimm_health		: Dimm health indicator. One of PAPR_PDSM_DIMM_XXXX

 */

struct nd_papr_pdsm_health {

	union {

		struct {

			__u32 extension_flags;

			__u8 dimm_unarmed;

			__u8 dimm_bad_shutdown;

			__u8 dimm_bad_restore;

			__u8 dimm_scrubbed;

			__u8 dimm_locked;

			__u8 dimm_encrypted;

			__u16 dimm_health;

		};

		__u8 buf[ND_PDSM_PAYLOAD_MAX_SIZE];

	};

};

/*

 * Methods to be embedded in ND_CMD_CALL request. These are sent to the kernel

 * via 'nd_cmd_pkg.nd_command' member of the ioctl struct

 */

enum papr_pdsm {

	PAPR_PDSM_MIN = 0x0,

	PAPR_PDSM_HEALTH,

	PAPR_PDSM_MAX,

};

/* Maximal union that can hold all possible payload types */

union nd_pdsm_payload {

	struct nd_papr_pdsm_health health;

	__u8 buf[ND_PDSM_PAYLOAD_MAX_SIZE];

} __packed;

/*

 * PDSM-header + payload expected with ND_CMD_CALL ioctl from libnvdimm

 * Valid member of union 'payload' is identified via 'nd_cmd_pkg.nd_command'

 * that should always precede this struct when sent to papr_scm via CMD_CALL

 * interface.

 */

struct nd_pkg_pdsm {

	__s32 cmd_status;	/* Out: Sub-cmd status returned back */

	__u16 reserved[2];	/* Ignored and to be set as '0' */

	union nd_pdsm_payload payload;

} __packed;

#endif /* _UAPI_ASM_POWERPC_PAPR_PDSM_H_ */

#include <linux/libnvdimm.h>

#include <linux/platform_device.h>

#include <linux/delay.h>

#include <linux/seq_buf.h>

#include <asm/plpar_wrappers.h>

#include <asm/papr_pdsm.h>

#define BIND_ANY_ADDR (~0ul)

#define PAPR_SCM_DIMM_CMD_MASK \

	((1ul << ND_CMD_GET_CONFIG_SIZE) | \

	 (1ul << ND_CMD_GET_CONFIG_DATA) | \

	 (1ul << ND_CMD_SET_CONFIG_DATA))

	 (1ul << ND_CMD_SET_CONFIG_DATA) | \

	 (1ul << ND_CMD_CALL))

/* DIMM health bitmap bitmap indicators */

/* SCM device is unable to persist memory contents */

#define PAPR_PMEM_UNARMED                   (1ULL << (63 - 0))

/* SCM device failed to persist memory contents */

#define PAPR_PMEM_SHUTDOWN_DIRTY            (1ULL << (63 - 1))

/* SCM device contents are persisted from previous IPL */

#define PAPR_PMEM_SHUTDOWN_CLEAN            (1ULL << (63 - 2))

/* SCM device contents are not persisted from previous IPL */

#define PAPR_PMEM_EMPTY                     (1ULL << (63 - 3))

/* SCM device memory life remaining is critically low */

#define PAPR_PMEM_HEALTH_CRITICAL           (1ULL << (63 - 4))

/* SCM device will be garded off next IPL due to failure */

#define PAPR_PMEM_HEALTH_FATAL              (1ULL << (63 - 5))

/* SCM contents cannot persist due to current platform health status */

#define PAPR_PMEM_HEALTH_UNHEALTHY          (1ULL << (63 - 6))

/* SCM device is unable to persist memory contents in certain conditions */

#define PAPR_PMEM_HEALTH_NON_CRITICAL       (1ULL << (63 - 7))

/* SCM device is encrypted */

#define PAPR_PMEM_ENCRYPTED                 (1ULL << (63 - 8))

/* SCM device has been scrubbed and locked */

#define PAPR_PMEM_SCRUBBED_AND_LOCKED       (1ULL << (63 - 9))

/* Bits status indicators for health bitmap indicating unarmed dimm */

#define PAPR_PMEM_UNARMED_MASK (PAPR_PMEM_UNARMED |		\

				PAPR_PMEM_HEALTH_UNHEALTHY)

/* Bits status indicators for health bitmap indicating unflushed dimm */

#define PAPR_PMEM_BAD_SHUTDOWN_MASK (PAPR_PMEM_SHUTDOWN_DIRTY)

/* Bits status indicators for health bitmap indicating unrestored dimm */

#define PAPR_PMEM_BAD_RESTORE_MASK  (PAPR_PMEM_EMPTY)

/* Bit status indicators for smart event notification */

#define PAPR_PMEM_SMART_EVENT_MASK (PAPR_PMEM_HEALTH_CRITICAL | \

				    PAPR_PMEM_HEALTH_FATAL |	\

				    PAPR_PMEM_HEALTH_UNHEALTHY)

/* private struct associated with each region */

struct papr_scm_priv {

	struct platform_device *pdev;

	struct device_node *dn;

	struct resource res;

	struct nd_region *region;

	struct nd_interleave_set nd_set;

	/* Protect dimm health data from concurrent read/writes */

	struct mutex health_mutex;

	/* Last time the health information of the dimm was updated */

	unsigned long lasthealth_jiffies;

	/* Health information for the dimm */

	u64 health_bitmap;

};

static int drc_pmem_bind(struct papr_scm_priv *p)

	return drc_pmem_bind(p);

}

/*

 * Issue hcall to retrieve dimm health info and populate papr_scm_priv with the

 * health information.

 */

static int __drc_pmem_query_health(struct papr_scm_priv *p)

{

	unsigned long ret[PLPAR_HCALL_BUFSIZE];

	long rc;

	/* issue the hcall */

	rc = plpar_hcall(H_SCM_HEALTH, ret, p->drc_index);

	if (rc != H_SUCCESS) {

		dev_err(&p->pdev->dev,

			"Failed to query health information, Err:%ld\n", rc);

		return -ENXIO;

	}

	p->lasthealth_jiffies = jiffies;

	p->health_bitmap = ret[0] & ret[1];

	dev_dbg(&p->pdev->dev,

		"Queried dimm health info. Bitmap:0x%016lx Mask:0x%016lx\n",

		ret[0], ret[1]);

	return 0;

}

/* Min interval in seconds for assuming stable dimm health */

#define MIN_HEALTH_QUERY_INTERVAL 60

/* Query cached health info and if needed call drc_pmem_query_health */

static int drc_pmem_query_health(struct papr_scm_priv *p)

{

	unsigned long cache_timeout;

	int rc;

	/* Protect concurrent modifications to papr_scm_priv */

	rc = mutex_lock_interruptible(&p->health_mutex);

	if (rc)

		return rc;

	/* Jiffies offset for which the health data is assumed to be same */

	cache_timeout = p->lasthealth_jiffies +

		msecs_to_jiffies(MIN_HEALTH_QUERY_INTERVAL * 1000);

	/* Fetch new health info is its older than MIN_HEALTH_QUERY_INTERVAL */

	if (time_after(jiffies, cache_timeout))

		rc = __drc_pmem_query_health(p);

	else

		/* Assume cached health data is valid */

		rc = 0;

	mutex_unlock(&p->health_mutex);

	return rc;

}

static int papr_scm_meta_get(struct papr_scm_priv *p,

			     struct nd_cmd_get_config_data_hdr *hdr)

	return 0;

}

/*

 * Do a sanity checks on the inputs args to dimm-control function and return

 * '0' if valid. Validation of PDSM payloads happens later in

 * papr_scm_service_pdsm.

 */

static int is_cmd_valid(struct nvdimm *nvdimm, unsigned int cmd, void *buf,

			unsigned int buf_len)

{

	unsigned long cmd_mask = PAPR_SCM_DIMM_CMD_MASK;

	struct nd_cmd_pkg *nd_cmd;

	struct papr_scm_priv *p;

	enum papr_pdsm pdsm;

	/* Only dimm-specific calls are supported atm */

	if (!nvdimm)

		return -EINVAL;

	/* get the provider data from struct nvdimm */

	p = nvdimm_provider_data(nvdimm);

	if (!test_bit(cmd, &cmd_mask)) {

		dev_dbg(&p->pdev->dev, "Unsupported cmd=%u\n", cmd);

		return -EINVAL;

	}

	/* For CMD_CALL verify pdsm request */

	if (cmd == ND_CMD_CALL) {

		/* Verify the envelope and envelop size */

		if (!buf ||

		    buf_len < (sizeof(struct nd_cmd_pkg) + ND_PDSM_HDR_SIZE)) {

			dev_dbg(&p->pdev->dev, "Invalid pkg size=%u\n",

				buf_len);

			return -EINVAL;

		}

		/* Verify that the nd_cmd_pkg.nd_family is correct */

		nd_cmd = (struct nd_cmd_pkg *)buf;

		if (nd_cmd->nd_family != NVDIMM_FAMILY_PAPR) {

			dev_dbg(&p->pdev->dev, "Invalid pkg family=0x%llx\n",

				nd_cmd->nd_family);

			return -EINVAL;

		}

		pdsm = (enum papr_pdsm)nd_cmd->nd_command;

		/* Verify if the pdsm command is valid */

		if (pdsm <= PAPR_PDSM_MIN || pdsm >= PAPR_PDSM_MAX) {

			dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid PDSM\n",

				pdsm);

			return -EINVAL;

		}

		/* Have enough space to hold returned 'nd_pkg_pdsm' header */

		if (nd_cmd->nd_size_out < ND_PDSM_HDR_SIZE) {

			dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid payload\n",

				pdsm);

			return -EINVAL;

		}

	}

	/* Let the command be further processed */

	return 0;

}

/* Fetch the DIMM health info and populate it in provided package. */

static int papr_pdsm_health(struct papr_scm_priv *p,

			    union nd_pdsm_payload *payload)

{

	int rc;

	/* Ensure dimm health mutex is taken preventing concurrent access */

	rc = mutex_lock_interruptible(&p->health_mutex);

	if (rc)

		goto out;

	/* Always fetch upto date dimm health data ignoring cached values */

	rc = __drc_pmem_query_health(p);

	if (rc) {

		mutex_unlock(&p->health_mutex);

		goto out;

	}

	/* update health struct with various flags derived from health bitmap */

	payload->health = (struct nd_papr_pdsm_health) {

		.extension_flags = 0,

		.dimm_unarmed = !!(p->health_bitmap & PAPR_PMEM_UNARMED_MASK),

		.dimm_bad_shutdown = !!(p->health_bitmap & PAPR_PMEM_BAD_SHUTDOWN_MASK),

		.dimm_bad_restore = !!(p->health_bitmap & PAPR_PMEM_BAD_RESTORE_MASK),

		.dimm_scrubbed = !!(p->health_bitmap & PAPR_PMEM_SCRUBBED_AND_LOCKED),

		.dimm_locked = !!(p->health_bitmap & PAPR_PMEM_SCRUBBED_AND_LOCKED),

		.dimm_encrypted = !!(p->health_bitmap & PAPR_PMEM_ENCRYPTED),

		.dimm_health = PAPR_PDSM_DIMM_HEALTHY,

	};

	/* Update field dimm_health based on health_bitmap flags */

	if (p->health_bitmap & PAPR_PMEM_HEALTH_FATAL)

		payload->health.dimm_health = PAPR_PDSM_DIMM_FATAL;

	else if (p->health_bitmap & PAPR_PMEM_HEALTH_CRITICAL)

		payload->health.dimm_health = PAPR_PDSM_DIMM_CRITICAL;

	else if (p->health_bitmap & PAPR_PMEM_HEALTH_UNHEALTHY)

		payload->health.dimm_health = PAPR_PDSM_DIMM_UNHEALTHY;

	/* struct populated hence can release the mutex now */

	mutex_unlock(&p->health_mutex);

	rc = sizeof(struct nd_papr_pdsm_health);

out:

	return rc;

}

/*

 * 'struct pdsm_cmd_desc'

 * Identifies supported PDSMs' expected length of in/out payloads

 * and pdsm service function.

 *

 * size_in	: Size of input payload if any in the PDSM request.

 * size_out	: Size of output payload if any in the PDSM request.

 * service	: Service function for the PDSM request. Return semantics:

 *		  rc < 0 : Error servicing PDSM and rc indicates the error.

 *		  rc >=0 : Serviced successfully and 'rc' indicate number of

 *			bytes written to payload.

 */

struct pdsm_cmd_desc {

	u32 size_in;

	u32 size_out;

	int (*service)(struct papr_scm_priv *dimm,

		       union nd_pdsm_payload *payload);

};

/* Holds all supported PDSMs' command descriptors */

static const struct pdsm_cmd_desc __pdsm_cmd_descriptors[] = {

	[PAPR_PDSM_MIN] = {

		.size_in = 0,

		.size_out = 0,

		.service = NULL,

	},

	/* New PDSM command descriptors to be added below */

	[PAPR_PDSM_HEALTH] = {

		.size_in = 0,

		.size_out = sizeof(struct nd_papr_pdsm_health),

		.service = papr_pdsm_health,

	},

	/* Empty */

	[PAPR_PDSM_MAX] = {

		.size_in = 0,

		.size_out = 0,

		.service = NULL,

	},

};

/* Given a valid pdsm cmd return its command descriptor else return NULL */

static inline const struct pdsm_cmd_desc *pdsm_cmd_desc(enum papr_pdsm cmd)

{

	if (cmd >= 0 || cmd < ARRAY_SIZE(__pdsm_cmd_descriptors))

		return &__pdsm_cmd_descriptors[cmd];

	return NULL;

}

/*

 * For a given pdsm request call an appropriate service function.

 * Returns errors if any while handling the pdsm command package.

 */

static int papr_scm_service_pdsm(struct papr_scm_priv *p,

				 struct nd_cmd_pkg *pkg)

{

	/* Get the PDSM header and PDSM command */

	struct nd_pkg_pdsm *pdsm_pkg = (struct nd_pkg_pdsm *)pkg->nd_payload;

	enum papr_pdsm pdsm = (enum papr_pdsm)pkg->nd_command;

	const struct pdsm_cmd_desc *pdsc;

	int rc;

	/* Fetch corresponding pdsm descriptor for validation and servicing */

	pdsc = pdsm_cmd_desc(pdsm);

	/* Validate pdsm descriptor */

	/* Ensure that reserved fields are 0 */

	if (pdsm_pkg->reserved[0] || pdsm_pkg->reserved[1]) {

		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Invalid reserved field\n",

			pdsm);

		return -EINVAL;

	}

	/* If pdsm expects some input, then ensure that the size_in matches */

	if (pdsc->size_in &&

	    pkg->nd_size_in != (pdsc->size_in + ND_PDSM_HDR_SIZE)) {

		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Mismatched size_in=%d\n",

			pdsm, pkg->nd_size_in);

		return -EINVAL;

	}

	/* If pdsm wants to return data, then ensure that  size_out matches */

	if (pdsc->size_out &&

	    pkg->nd_size_out != (pdsc->size_out + ND_PDSM_HDR_SIZE)) {

		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Mismatched size_out=%d\n",

			pdsm, pkg->nd_size_out);

		return -EINVAL;

	}

	/* Service the pdsm */

	if (pdsc->service) {

		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Servicing..\n", pdsm);

		rc = pdsc->service(p, &pdsm_pkg->payload);

		if (rc < 0) {

			/* error encountered while servicing pdsm */

			pdsm_pkg->cmd_status = rc;

			pkg->nd_fw_size = ND_PDSM_HDR_SIZE;

		} else {

			/* pdsm serviced and 'rc' bytes written to payload */

			pdsm_pkg->cmd_status = 0;

			pkg->nd_fw_size = ND_PDSM_HDR_SIZE + rc;

		}

	} else {

		dev_dbg(&p->pdev->dev, "PDSM[0x%x]: Unsupported PDSM request\n",

			pdsm);

		pdsm_pkg->cmd_status = -ENOENT;

		pkg->nd_fw_size = ND_PDSM_HDR_SIZE;

	}

	return pdsm_pkg->cmd_status;

}

static int papr_scm_ndctl(struct nvdimm_bus_descriptor *nd_desc,

			  struct nvdimm *nvdimm, unsigned int cmd, void *buf,

			  unsigned int buf_len, int *cmd_rc)

{

	struct nd_cmd_get_config_size *get_size_hdr;

	struct nd_cmd_pkg *call_pkg = NULL;

	struct papr_scm_priv *p;

	int rc;

	/* Only dimm-specific calls are supported atm */

	if (!nvdimm)

		return -EINVAL;

	rc = is_cmd_valid(nvdimm, cmd, buf, buf_len);

	if (rc) {

		pr_debug("Invalid cmd=0x%x. Err=%d\n", cmd, rc);

		return rc;

	}

	/* Use a local variable in case cmd_rc pointer is NULL */

	if (!cmd_rc)

		cmd_rc = &rc;

	p = nvdimm_provider_data(nvdimm);

		*cmd_rc = papr_scm_meta_set(p, buf);

		break;

	case ND_CMD_CALL:

		call_pkg = (struct nd_cmd_pkg *)buf;

		*cmd_rc = papr_scm_service_pdsm(p, call_pkg);

		break;

	default:

		dev_dbg(&p->pdev->dev, "Unknown command = %d\n", cmd);

		return -EINVAL;

	}

	return 0;

}

static ssize_t flags_show(struct device *dev,

			  struct device_attribute *attr, char *buf)

{

	struct nvdimm *dimm = to_nvdimm(dev);

	struct papr_scm_priv *p = nvdimm_provider_data(dimm);

	struct seq_buf s;

	u64 health;

	int rc;

	rc = drc_pmem_query_health(p);

	if (rc)

		return rc;

	/* Copy health_bitmap locally, check masks & update out buffer */

	health = READ_ONCE(p->health_bitmap);

	seq_buf_init(&s, buf, PAGE_SIZE);

	if (health & PAPR_PMEM_UNARMED_MASK)

		seq_buf_printf(&s, "not_armed ");

	if (health & PAPR_PMEM_BAD_SHUTDOWN_MASK)

		seq_buf_printf(&s, "flush_fail ");

	if (health & PAPR_PMEM_BAD_RESTORE_MASK)

		seq_buf_printf(&s, "restore_fail ");

	if (health & PAPR_PMEM_ENCRYPTED)

		seq_buf_printf(&s, "encrypted ");

	if (health & PAPR_PMEM_SMART_EVENT_MASK)

		seq_buf_printf(&s, "smart_notify ");

	if (health & PAPR_PMEM_SCRUBBED_AND_LOCKED)

		seq_buf_printf(&s, "scrubbed locked ");

	if (seq_buf_used(&s))

		seq_buf_printf(&s, "\n");

	return seq_buf_used(&s);

}

DEVICE_ATTR_RO(flags);

/* papr_scm specific dimm attributes */

static struct attribute *papr_nd_attributes[] = {

	&dev_attr_flags.attr,

	NULL,

};

static struct attribute_group papr_nd_attribute_group = {

	.name = "papr",

	.attrs = papr_nd_attributes,

};

static const struct attribute_group *papr_nd_attr_groups[] = {

	&papr_nd_attribute_group,

	NULL,

};

static int papr_scm_nvdimm_init(struct papr_scm_priv *p)

{

	struct device *dev = &p->pdev->dev;

	dimm_flags = 0;

	set_bit(NDD_LABELING, &dimm_flags);

	p->nvdimm = nvdimm_create(p->bus, p, NULL, dimm_flags,

				  PAPR_SCM_DIMM_CMD_MASK, 0, NULL);

	p->nvdimm = nvdimm_create(p->bus, p, papr_nd_attr_groups,

				  dimm_flags, PAPR_SCM_DIMM_CMD_MASK, 0, NULL);

	if (!p->nvdimm) {

		dev_err(dev, "Error creating DIMM object for %pOF\n", p->dn);

		goto err;

	if (!p)

		return -ENOMEM;

	/* Initialize the dimm mutex */

	mutex_init(&p->health_mutex);

	/* optional DT properties */

	of_property_read_u32(dn, "ibm,metadata-size", &metadata_size);

		return a->mode;

	}

	if (a == &dev_attr_align.attr) {

		int i;

		for (i = 0; i < nd_region->ndr_mappings; i++) {

			struct nd_mapping *nd_mapping = &nd_region->mapping[i];

			struct nvdimm *nvdimm = nd_mapping->nvdimm;

			if (test_bit(NDD_LABELING, &nvdimm->flags))

	if (a == &dev_attr_align.attr)

		return a->mode;

		}

		return 0;

	}

	if (a != &dev_attr_set_cookie.attr

			&& a != &dev_attr_available_size.attr)