[linux-2.6-block.git] / arch / powerpc / platforms / powernv / opal-flash.c

/*
 * PowerNV OPAL Firmware Update Interface
 *
 * Copyright 2013 IBM Corp.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#define DEBUG

#include <linux/kernel.h>
#include <linux/reboot.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/vmalloc.h>
#include <linux/pagemap.h>
#include <linux/delay.h>

#include <asm/opal.h>

/* FLASH status codes */
#define FLASH_NO_OP		-1099	/* No operation initiated by user */
#define FLASH_NO_AUTH		-9002	/* Not a service authority partition */

/* Validate image status values */
#define VALIDATE_IMG_READY	-1001	/* Image ready for validation */
#define VALIDATE_IMG_INCOMPLETE	-1002	/* User copied < VALIDATE_BUF_SIZE */

/* Manage image status values */
#define MANAGE_ACTIVE_ERR	-9001	/* Cannot overwrite active img */

/* Flash image status values */
#define FLASH_IMG_READY		0	/* Img ready for flash on reboot */
#define FLASH_INVALID_IMG	-1003	/* Flash image shorter than expected */
#define FLASH_IMG_NULL_DATA	-1004	/* Bad data in sg list entry */
#define FLASH_IMG_BAD_LEN	-1005	/* Bad length in sg list entry */

/* Manage operation tokens */
#define FLASH_REJECT_TMP_SIDE	0	/* Reject temporary fw image */
#define FLASH_COMMIT_TMP_SIDE	1	/* Commit temporary fw image */

/* Update tokens */
#define FLASH_UPDATE_CANCEL	0	/* Cancel update request */
#define FLASH_UPDATE_INIT	1	/* Initiate update */

/* Validate image update result tokens */
#define VALIDATE_TMP_UPDATE	0     /* T side will be updated */
#define VALIDATE_FLASH_AUTH	1     /* Partition does not have authority */
#define VALIDATE_INVALID_IMG	2     /* Candidate image is not valid */
#define VALIDATE_CUR_UNKNOWN	3     /* Current fixpack level is unknown */
/*
 * Current T side will be committed to P side before being replace with new
 * image, and the new image is downlevel from current image
 */
#define VALIDATE_TMP_COMMIT_DL	4
/*
 * Current T side will be committed to P side before being replaced with new
 * image
 */
#define VALIDATE_TMP_COMMIT	5
/*
 * T side will be updated with a downlevel image
 */
#define VALIDATE_TMP_UPDATE_DL	6
/*
 * The candidate image's release date is later than the system's firmware
 * service entitlement date - service warranty period has expired
 */
#define VALIDATE_OUT_OF_WRNTY	7

/* Validate buffer size */
#define VALIDATE_BUF_SIZE	4096

/* XXX: Assume candidate image size is <= 1GB */
#define MAX_IMAGE_SIZE	0x40000000

/* Image status */
enum {
	IMAGE_INVALID,
	IMAGE_LOADING,
	IMAGE_READY,
};

/* Candidate image data */
struct image_data_t {
	int		status;
	void		*data;
	uint32_t	size;
};

/* Candidate image header */
struct image_header_t {
	uint16_t	magic;
	uint16_t	version;
	uint32_t	size;
};

struct validate_flash_t {
	int		status;		/* Return status */
	void		*buf;		/* Candidate image buffer */
	uint32_t	buf_size;	/* Image size */
	uint32_t	result;		/* Update results token */
};

struct manage_flash_t {
	int status;		/* Return status */
};

struct update_flash_t {
	int status;		/* Return status */
};

static struct image_header_t	image_header;
static struct image_data_t	image_data;
static struct validate_flash_t	validate_flash_data;
static struct manage_flash_t	manage_flash_data;

/* Initialize update_flash_data status to No Operation */
static struct update_flash_t	update_flash_data = {
	.status = FLASH_NO_OP,
};

static DEFINE_MUTEX(image_data_mutex);

/*
 * Validate candidate image
 */
static inline void opal_flash_validate(void)
{
	long ret;
	void *buf = validate_flash_data.buf;
	__be32 size = cpu_to_be32(validate_flash_data.buf_size);
	__be32 result;

	ret = opal_validate_flash(__pa(buf), &size, &result);

	validate_flash_data.status = ret;
	validate_flash_data.buf_size = be32_to_cpu(size);
	validate_flash_data.result = be32_to_cpu(result);
}

/*
 * Validate output format:
 *     validate result token
 *     current image version details
 *     new image version details
 */
static ssize_t validate_show(struct kobject *kobj,
			     struct kobj_attribute *attr, char *buf)
{
	struct validate_flash_t *args_buf = &validate_flash_data;
	int len;

	/* Candidate image is not validated */
	if (args_buf->status < VALIDATE_TMP_UPDATE) {
		len = sprintf(buf, "%d\n", args_buf->status);
		goto out;
	}

	/* Result token */
	len = sprintf(buf, "%d\n", args_buf->result);

	/* Current and candidate image version details */
	if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
	    (args_buf->result < VALIDATE_CUR_UNKNOWN))
		goto out;

	if (args_buf->buf_size > (VALIDATE_BUF_SIZE - len)) {
		memcpy(buf + len, args_buf->buf, VALIDATE_BUF_SIZE - len);
		len = VALIDATE_BUF_SIZE;
	} else {
		memcpy(buf + len, args_buf->buf, args_buf->buf_size);
		len += args_buf->buf_size;
	}
out:
	/* Set status to default */
	args_buf->status = FLASH_NO_OP;
	return len;
}

/*
 * Validate candidate firmware image
 *
 * Note:
 *   We are only interested in first 4K bytes of the
 *   candidate image.
 */
static ssize_t validate_store(struct kobject *kobj,
			      struct kobj_attribute *attr,
			      const char *buf, size_t count)
{
	struct validate_flash_t *args_buf = &validate_flash_data;

	if (buf[0] != '1')
		return -EINVAL;

	mutex_lock(&image_data_mutex);

	if (image_data.status != IMAGE_READY ||
	    image_data.size < VALIDATE_BUF_SIZE) {
		args_buf->result = VALIDATE_INVALID_IMG;
		args_buf->status = VALIDATE_IMG_INCOMPLETE;
		goto out;
	}

	/* Copy first 4k bytes of candidate image */
	memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);

	args_buf->status = VALIDATE_IMG_READY;
	args_buf->buf_size = VALIDATE_BUF_SIZE;

	/* Validate candidate image */
	opal_flash_validate();

out:
	mutex_unlock(&image_data_mutex);
	return count;
}

/*
 * Manage flash routine
 */
static inline void opal_flash_manage(uint8_t op)
{
	struct manage_flash_t *const args_buf = &manage_flash_data;

	args_buf->status = opal_manage_flash(op);
}

/*
 * Show manage flash status
 */
static ssize_t manage_show(struct kobject *kobj,
			   struct kobj_attribute *attr, char *buf)
{
	struct manage_flash_t *const args_buf = &manage_flash_data;
	int rc;

	rc = sprintf(buf, "%d\n", args_buf->status);
	/* Set status to default*/
	args_buf->status = FLASH_NO_OP;
	return rc;
}

/*
 * Manage operations:
 *   0 - Reject
 *   1 - Commit
 */
static ssize_t manage_store(struct kobject *kobj,
			    struct kobj_attribute *attr,
			    const char *buf, size_t count)
{
	uint8_t op;
	switch (buf[0]) {
	case '0':
		op = FLASH_REJECT_TMP_SIDE;
		break;
	case '1':
		op = FLASH_COMMIT_TMP_SIDE;
		break;
	default:
		return -EINVAL;
	}

	/* commit/reject temporary image */
	opal_flash_manage(op);
	return count;
}

/*
 * OPAL update flash
 */
static int opal_flash_update(int op)
{
	struct opal_sg_list *list;
	unsigned long addr;
	int64_t rc = OPAL_PARAMETER;

	if (op == FLASH_UPDATE_CANCEL) {
		pr_alert("FLASH: Image update cancelled\n");
		addr = '\0';
		goto flash;
	}

	list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
	if (!list)
		goto invalid_img;

	/* First entry address */
	addr = __pa(list);

flash:
	rc = opal_update_flash(addr);

invalid_img:
	return rc;
}

/* Return CPUs to OPAL before starting FW update */
static void flash_return_cpu(void *info)
{
	int cpu = smp_processor_id();

	if (!cpu_online(cpu))
		return;

	/* Disable IRQ */
	hard_irq_disable();

	/* Return the CPU to OPAL */
	opal_return_cpu();
}

/* This gets called just before system reboots */
void opal_flash_term_callback(void)
{
	struct cpumask mask;

	if (update_flash_data.status != FLASH_IMG_READY)
		return;

	pr_alert("FLASH: Flashing new firmware\n");
	pr_alert("FLASH: Image is %u bytes\n", image_data.size);
	pr_alert("FLASH: Performing flash and reboot/shutdown\n");
	pr_alert("FLASH: This will take several minutes. Do not power off!\n");

	/* Small delay to help getting the above message out */
	msleep(500);

	/* Return secondary CPUs to firmware */
	cpumask_copy(&mask, cpu_online_mask);
	cpumask_clear_cpu(smp_processor_id(), &mask);
	if (!cpumask_empty(&mask))
		smp_call_function_many(&mask,
				       flash_return_cpu, NULL, false);
	/* Hard disable interrupts */
	hard_irq_disable();
}

/*
 * Show candidate image status
 */
static ssize_t update_show(struct kobject *kobj,
			   struct kobj_attribute *attr, char *buf)
{
	struct update_flash_t *const args_buf = &update_flash_data;
	return sprintf(buf, "%d\n", args_buf->status);
}

/*
 * Set update image flag
 *  1 - Flash new image
 *  0 - Cancel flash request
 */
static ssize_t update_store(struct kobject *kobj,
			    struct kobj_attribute *attr,
			    const char *buf, size_t count)
{
	struct update_flash_t *const args_buf = &update_flash_data;
	int rc = count;

	mutex_lock(&image_data_mutex);

	switch (buf[0]) {
	case '0':
		if (args_buf->status == FLASH_IMG_READY)
			opal_flash_update(FLASH_UPDATE_CANCEL);
		args_buf->status = FLASH_NO_OP;
		break;
	case '1':
		/* Image is loaded? */
		if (image_data.status == IMAGE_READY)
			args_buf->status =
				opal_flash_update(FLASH_UPDATE_INIT);
		else
			args_buf->status = FLASH_INVALID_IMG;
		break;
	default:
		rc = -EINVAL;
	}

	mutex_unlock(&image_data_mutex);
	return rc;
}

/*
 * Free image buffer
 */
static void free_image_buf(void)
{
	void *addr;
	int size;

	addr = image_data.data;
	size = PAGE_ALIGN(image_data.size);
	while (size > 0) {
		ClearPageReserved(vmalloc_to_page(addr));
		addr += PAGE_SIZE;
		size -= PAGE_SIZE;
	}
	vfree(image_data.data);
	image_data.data = NULL;
	image_data.status = IMAGE_INVALID;
}

/*
 * Allocate image buffer.
 */
static int alloc_image_buf(char *buffer, size_t count)
{
	void *addr;
	int size;

	if (count < sizeof(struct image_header_t)) {
		pr_warn("FLASH: Invalid candidate image\n");
		return -EINVAL;
	}

	memcpy(&image_header, (void *)buffer, sizeof(struct image_header_t));
	image_data.size = be32_to_cpu(image_header.size);
	pr_debug("FLASH: Candidate image size = %u\n", image_data.size);

	if (image_data.size > MAX_IMAGE_SIZE) {
		pr_warn("FLASH: Too large image\n");
		return -EINVAL;
	}
	if (image_data.size < VALIDATE_BUF_SIZE) {
		pr_warn("FLASH: Image is shorter than expected\n");
		return -EINVAL;
	}

	image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
	if (!image_data.data) {
		pr_err("%s : Failed to allocate memory\n", __func__);
		return -ENOMEM;
	}

	/* Pin memory */
	addr = image_data.data;
	size = PAGE_ALIGN(image_data.size);
	while (size > 0) {
		SetPageReserved(vmalloc_to_page(addr));
		addr += PAGE_SIZE;
		size -= PAGE_SIZE;
	}

	image_data.status = IMAGE_LOADING;
	return 0;
}

/*
 * Copy candidate image
 *
 * Parse candidate image header to get total image size
 * and pre-allocate required memory.
 */
static ssize_t image_data_write(struct file *filp, struct kobject *kobj,
				struct bin_attribute *bin_attr,
				char *buffer, loff_t pos, size_t count)
{
	int rc;

	mutex_lock(&image_data_mutex);

	/* New image ? */
	if (pos == 0) {
		/* Free memory, if already allocated */
		if (image_data.data)
			free_image_buf();

		/* Cancel outstanding image update request */
		if (update_flash_data.status == FLASH_IMG_READY)
			opal_flash_update(FLASH_UPDATE_CANCEL);

		/* Allocate memory */
		rc = alloc_image_buf(buffer, count);
		if (rc)
			goto out;
	}

	if (image_data.status != IMAGE_LOADING) {
		rc = -ENOMEM;
		goto out;
	}

	if ((pos + count) > image_data.size) {
		rc = -EINVAL;
		goto out;
	}

	memcpy(image_data.data + pos, (void *)buffer, count);
	rc = count;

	/* Set image status */
	if ((pos + count) == image_data.size) {
		pr_debug("FLASH: Candidate image loaded....\n");
		image_data.status = IMAGE_READY;
	}

out:
	mutex_unlock(&image_data_mutex);
	return rc;
}

/*
 * sysfs interface :
 *  OPAL uses below sysfs files for code update.
 *  We create these files under /sys/firmware/opal.
 *
 *   image		: Interface to load candidate firmware image
 *   validate_flash	: Validate firmware image
 *   manage_flash	: Commit/Reject firmware image
 *   update_flash	: Flash new firmware image
 *
 */
static struct bin_attribute image_data_attr = {
	.attr = {.name = "image", .mode = 0200},
	.size = MAX_IMAGE_SIZE,	/* Limit image size */
	.write = image_data_write,
};

static struct kobj_attribute validate_attribute =
	__ATTR(validate_flash, 0600, validate_show, validate_store);

static struct kobj_attribute manage_attribute =
	__ATTR(manage_flash, 0600, manage_show, manage_store);

static struct kobj_attribute update_attribute =
	__ATTR(update_flash, 0600, update_show, update_store);

static struct attribute *image_op_attrs[] = {
	&validate_attribute.attr,
	&manage_attribute.attr,
	&update_attribute.attr,
	NULL	/* need to NULL terminate the list of attributes */
};

static struct attribute_group image_op_attr_group = {
	.attrs = image_op_attrs,
};

void __init opal_flash_update_init(void)
{
	int ret;

	/* Allocate validate image buffer */
	validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
	if (!validate_flash_data.buf) {
		pr_err("%s : Failed to allocate memory\n", __func__);
		return;
	}

	/* Make sure /sys/firmware/opal directory is created */
	if (!opal_kobj) {
		pr_warn("FLASH: opal kobject is not available\n");
		goto nokobj;
	}

	/* Create the sysfs files */
	ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
	if (ret) {
		pr_warn("FLASH: Failed to create sysfs files\n");
		goto nokobj;
	}

	ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
	if (ret) {
		pr_warn("FLASH: Failed to create sysfs files\n");
		goto nosysfs_file;
	}

	/* Set default status */
	validate_flash_data.status = FLASH_NO_OP;
	manage_flash_data.status = FLASH_NO_OP;
	update_flash_data.status = FLASH_NO_OP;
	image_data.status = IMAGE_INVALID;
	return;

nosysfs_file:
	sysfs_remove_group(opal_kobj, &image_op_attr_group);

nokobj:
	kfree(validate_flash_data.buf);
	return;
}
Commit	Line	Data
50bd6153 VH	1	/*
	2	* PowerNV OPAL Firmware Update Interface
	3	*
	4	* Copyright 2013 IBM Corp.
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11
	12	#define DEBUG
	13
	14	#include <linux/kernel.h>
	15	#include <linux/reboot.h>
	16	#include <linux/init.h>
	17	#include <linux/kobject.h>
	18	#include <linux/sysfs.h>
	19	#include <linux/slab.h>
	20	#include <linux/mm.h>
	21	#include <linux/vmalloc.h>
	22	#include <linux/pagemap.h>
2196c6f1	23	#include <linux/delay.h>
50bd6153 VH	24
	25	#include <asm/opal.h>
	26
	27	/* FLASH status codes */
	28	#define FLASH_NO_OP -1099 /* No operation initiated by user */
	29	#define FLASH_NO_AUTH -9002 /* Not a service authority partition */
	30
	31	/* Validate image status values */
	32	#define VALIDATE_IMG_READY -1001 /* Image ready for validation */
	33	#define VALIDATE_IMG_INCOMPLETE -1002 /* User copied < VALIDATE_BUF_SIZE */
	34
	35	/* Manage image status values */
	36	#define MANAGE_ACTIVE_ERR -9001 /* Cannot overwrite active img */
	37
	38	/* Flash image status values */
	39	#define FLASH_IMG_READY 0 /* Img ready for flash on reboot */
	40	#define FLASH_INVALID_IMG -1003 /* Flash image shorter than expected */
	41	#define FLASH_IMG_NULL_DATA -1004 /* Bad data in sg list entry */
	42	#define FLASH_IMG_BAD_LEN -1005 /* Bad length in sg list entry */
	43
	44	/* Manage operation tokens */
	45	#define FLASH_REJECT_TMP_SIDE 0 /* Reject temporary fw image */
	46	#define FLASH_COMMIT_TMP_SIDE 1 /* Commit temporary fw image */
	47
	48	/* Update tokens */
	49	#define FLASH_UPDATE_CANCEL 0 /* Cancel update request */
	50	#define FLASH_UPDATE_INIT 1 /* Initiate update */
	51
	52	/* Validate image update result tokens */
	53	#define VALIDATE_TMP_UPDATE 0 /* T side will be updated */
	54	#define VALIDATE_FLASH_AUTH 1 /* Partition does not have authority */
	55	#define VALIDATE_INVALID_IMG 2 /* Candidate image is not valid */
	56	#define VALIDATE_CUR_UNKNOWN 3 /* Current fixpack level is unknown */
	57	/*
	58	* Current T side will be committed to P side before being replace with new
	59	* image, and the new image is downlevel from current image
	60	*/
	61	#define VALIDATE_TMP_COMMIT_DL 4
	62	/*
	63	* Current T side will be committed to P side before being replaced with new
	64	* image
	65	*/
	66	#define VALIDATE_TMP_COMMIT 5
	67	/*
	68	* T side will be updated with a downlevel image
	69	*/
	70	#define VALIDATE_TMP_UPDATE_DL 6
	71	/*
	72	* The candidate image's release date is later than the system's firmware
	73	* service entitlement date - service warranty period has expired
	74	*/
	75	#define VALIDATE_OUT_OF_WRNTY 7
	76
	77	/* Validate buffer size */
	78	#define VALIDATE_BUF_SIZE 4096
	79
bf16a4c2 VH	80	/* XXX: Assume candidate image size is <= 1GB */
bf16a4c2 VH	81	#define MAX_IMAGE_SIZE 0x40000000
50bd6153	82
50bd6153 VH	83	/* Image status */
	84	enum {
	85	IMAGE_INVALID,
	86	IMAGE_LOADING,
	87	IMAGE_READY,
	88	};
	89
	90	/* Candidate image data */
	91	struct image_data_t {
	92	int status;
	93	void *data;
	94	uint32_t size;
	95	};
	96
	97	/* Candidate image header */
	98	struct image_header_t {
	99	uint16_t magic;
	100	uint16_t version;
	101	uint32_t size;
	102	};
	103
50bd6153 VH	104	struct validate_flash_t {
50bd6153 VH	105	int status; /* Return status */
8faaaead	106	void buf; / Candidate image buffer */
50bd6153 VH	107	uint32_t buf_size; /* Image size */
	108	uint32_t result; /* Update results token */
	109	};
	110
	111	struct manage_flash_t {
	112	int status; /* Return status */
	113	};
	114
	115	struct update_flash_t {
	116	int status; /* Return status */
	117	};
	118
	119	static struct image_header_t image_header;
	120	static struct image_data_t image_data;
	121	static struct validate_flash_t validate_flash_data;
	122	static struct manage_flash_t manage_flash_data;
3f77df7f VH	123
	124	/* Initialize update_flash_data status to No Operation */
	125	static struct update_flash_t update_flash_data = {
	126	.status = FLASH_NO_OP,
	127	};
50bd6153 VH	128
	129	static DEFINE_MUTEX(image_data_mutex);
	130
	131	/*
	132	* Validate candidate image
	133	*/
	134	static inline void opal_flash_validate(void)
	135	{
cc146d1d AB	136	long ret;
cc146d1d AB	137	void *buf = validate_flash_data.buf;
8b8f7bf4 VH	138	__be32 size = cpu_to_be32(validate_flash_data.buf_size);
8b8f7bf4 VH	139	__be32 result;
cc146d1d AB	140
cc146d1d AB	141	ret = opal_validate_flash(__pa(buf), &size, &result);
50bd6153	142
cc146d1d AB	143	validate_flash_data.status = ret;
	144	validate_flash_data.buf_size = be32_to_cpu(size);
	145	validate_flash_data.result = be32_to_cpu(result);
50bd6153 VH	146	}
	147
	148	/*
	149	* Validate output format:
	150	* validate result token
	151	* current image version details
	152	* new image version details
	153	*/
	154	static ssize_t validate_show(struct kobject *kobj,
	155	struct kobj_attribute attr, char buf)
	156	{
	157	struct validate_flash_t *args_buf = &validate_flash_data;
	158	int len;
	159
	160	/* Candidate image is not validated */
	161	if (args_buf->status < VALIDATE_TMP_UPDATE) {
	162	len = sprintf(buf, "%d\n", args_buf->status);
	163	goto out;
	164	}
	165
	166	/* Result token */
	167	len = sprintf(buf, "%d\n", args_buf->result);
	168
	169	/* Current and candidate image version details */
	170	if ((args_buf->result != VALIDATE_TMP_UPDATE) &&
	171	(args_buf->result < VALIDATE_CUR_UNKNOWN))
	172	goto out;
	173
	174	if (args_buf->buf_size > (VALIDATE_BUF_SIZE - len)) {
	175	memcpy(buf + len, args_buf->buf, VALIDATE_BUF_SIZE - len);
	176	len = VALIDATE_BUF_SIZE;
	177	} else {
	178	memcpy(buf + len, args_buf->buf, args_buf->buf_size);
	179	len += args_buf->buf_size;
	180	}
	181	out:
	182	/* Set status to default */
	183	args_buf->status = FLASH_NO_OP;
	184	return len;
	185	}
	186
	187	/*
	188	* Validate candidate firmware image
	189	*
	190	* Note:
	191	* We are only interested in first 4K bytes of the
	192	* candidate image.
	193	*/
	194	static ssize_t validate_store(struct kobject *kobj,
	195	struct kobj_attribute *attr,
	196	const char *buf, size_t count)
	197	{
	198	struct validate_flash_t *args_buf = &validate_flash_data;
	199
	200	if (buf[0] != '1')
	201	return -EINVAL;
	202
	203	mutex_lock(&image_data_mutex);
	204
	205	if (image_data.status != IMAGE_READY \|\|
	206	image_data.size < VALIDATE_BUF_SIZE) {
	207	args_buf->result = VALIDATE_INVALID_IMG;
	208	args_buf->status = VALIDATE_IMG_INCOMPLETE;
	209	goto out;
210	}
211
212	/* Copy first 4k bytes of candidate image */
213	memcpy(args_buf->buf, image_data.data, VALIDATE_BUF_SIZE);
214
215	args_buf->status = VALIDATE_IMG_READY;
216	args_buf->buf_size = VALIDATE_BUF_SIZE;
217
218	/* Validate candidate image */
219	opal_flash_validate();
220
221	out:
222	mutex_unlock(&image_data_mutex);
223	return count;
224	}
225
226	/*
227	* Manage flash routine
228	*/
229	static inline void opal_flash_manage(uint8_t op)
230	{
231	struct manage_flash_t *const args_buf = &manage_flash_data;
232
233	args_buf->status = opal_manage_flash(op);
234	}
235
236	/*
237	* Show manage flash status
238	*/
239	static ssize_t manage_show(struct kobject *kobj,
240	struct kobj_attribute attr, char buf)
241	{
242	struct manage_flash_t *const args_buf = &manage_flash_data;
243	int rc;
244
245	rc = sprintf(buf, "%d\n", args_buf->status);
246	/* Set status to default*/
247	args_buf->status = FLASH_NO_OP;
248	return rc;
249	}
250
251	/*
252	* Manage operations:
253	* 0 - Reject
254	* 1 - Commit
255	*/
256	static ssize_t manage_store(struct kobject *kobj,
257	struct kobj_attribute *attr,
258	const char *buf, size_t count)
259	{
260	uint8_t op;
261	switch (buf[0]) {
262	case '0':
263	op = FLASH_REJECT_TMP_SIDE;
264	break;
265	case '1':
266	op = FLASH_COMMIT_TMP_SIDE;
267	break;
268	default:
269	return -EINVAL;
270	}
271
272	/* commit/reject temporary image */
273	opal_flash_manage(op);
274	return count;
275	}
276
50bd6153 VH	277	/*
	278	* OPAL update flash
	279	*/
	280	static int opal_flash_update(int op)
	281	{
3441f04b	282	struct opal_sg_list *list;
50bd6153 VH	283	unsigned long addr;
	284	int64_t rc = OPAL_PARAMETER;
	285
	286	if (op == FLASH_UPDATE_CANCEL) {
	287	pr_alert("FLASH: Image update cancelled\n");
	288	addr = '\0';
	289	goto flash;
	290	}
	291
3441f04b	292	list = opal_vmalloc_to_sg_list(image_data.data, image_data.size);
50bd6153 VH	293	if (!list)
	294	goto invalid_img;
	295
	296	/* First entry address */
	297	addr = __pa(list);
	298
50bd6153 VH	299	flash:
	300	rc = opal_update_flash(addr);
	301
	302	invalid_img:
	303	return rc;
	304	}
	305
2196c6f1 VH	306	/* Return CPUs to OPAL before starting FW update */
	307	static void flash_return_cpu(void *info)
	308	{
	309	int cpu = smp_processor_id();
	310
	311	if (!cpu_online(cpu))
	312	return;
	313
	314	/* Disable IRQ */
	315	hard_irq_disable();
	316
	317	/* Return the CPU to OPAL */
	318	opal_return_cpu();
	319	}
	320
	321	/* This gets called just before system reboots */
	322	void opal_flash_term_callback(void)
	323	{
	324	struct cpumask mask;
	325
	326	if (update_flash_data.status != FLASH_IMG_READY)
	327	return;
	328
	329	pr_alert("FLASH: Flashing new firmware\n");
	330	pr_alert("FLASH: Image is %u bytes\n", image_data.size);
	331	pr_alert("FLASH: Performing flash and reboot/shutdown\n");
	332	pr_alert("FLASH: This will take several minutes. Do not power off!\n");
	333
	334	/* Small delay to help getting the above message out */
	335	msleep(500);
	336
	337	/* Return secondary CPUs to firmware */
	338	cpumask_copy(&mask, cpu_online_mask);
	339	cpumask_clear_cpu(smp_processor_id(), &mask);
	340	if (!cpumask_empty(&mask))
	341	smp_call_function_many(&mask,
	342	flash_return_cpu, NULL, false);
	343	/* Hard disable interrupts */
	344	hard_irq_disable();
	345	}
	346
50bd6153 VH	347	/*
	348	* Show candidate image status
	349	*/
	350	static ssize_t update_show(struct kobject *kobj,
	351	struct kobj_attribute attr, char buf)
	352	{
	353	struct update_flash_t *const args_buf = &update_flash_data;
	354	return sprintf(buf, "%d\n", args_buf->status);
	355	}
	356
	357	/*
	358	* Set update image flag
	359	* 1 - Flash new image
	360	* 0 - Cancel flash request
	361	*/
	362	static ssize_t update_store(struct kobject *kobj,
	363	struct kobj_attribute *attr,
	364	const char *buf, size_t count)
	365	{
	366	struct update_flash_t *const args_buf = &update_flash_data;
	367	int rc = count;
	368
	369	mutex_lock(&image_data_mutex);
	370
	371	switch (buf[0]) {
	372	case '0':
	373	if (args_buf->status == FLASH_IMG_READY)
	374	opal_flash_update(FLASH_UPDATE_CANCEL);
	375	args_buf->status = FLASH_NO_OP;
	376	break;
	377	case '1':
	378	/* Image is loaded? */
	379	if (image_data.status == IMAGE_READY)
	380	args_buf->status =
	381	opal_flash_update(FLASH_UPDATE_INIT);
	382	else
	383	args_buf->status = FLASH_INVALID_IMG;
	384	break;
	385	default:
	386	rc = -EINVAL;
	387	}
	388
	389	mutex_unlock(&image_data_mutex);
	390	return rc;
	391	}
	392
	393	/*
	394	* Free image buffer
	395	*/
	396	static void free_image_buf(void)
	397	{
	398	void *addr;
	399	int size;
	400
	401	addr = image_data.data;
	402	size = PAGE_ALIGN(image_data.size);
	403	while (size > 0) {
	404	ClearPageReserved(vmalloc_to_page(addr));
	405	addr += PAGE_SIZE;
	406	size -= PAGE_SIZE;
	407	}
	408	vfree(image_data.data);
	409	image_data.data = NULL;
	410	image_data.status = IMAGE_INVALID;
411	}
412
413	/*
414	* Allocate image buffer.
415	*/
416	static int alloc_image_buf(char *buffer, size_t count)
417	{
418	void *addr;
419	int size;
420
421	if (count < sizeof(struct image_header_t)) {
422	pr_warn("FLASH: Invalid candidate image\n");
423	return -EINVAL;
424	}
425
426	memcpy(&image_header, (void *)buffer, sizeof(struct image_header_t));
427	image_data.size = be32_to_cpu(image_header.size);
8faaaead	428	pr_debug("FLASH: Candidate image size = %u\n", image_data.size);
50bd6153 VH	429
	430	if (image_data.size > MAX_IMAGE_SIZE) {
	431	pr_warn("FLASH: Too large image\n");
	432	return -EINVAL;
	433	}
	434	if (image_data.size < VALIDATE_BUF_SIZE) {
	435	pr_warn("FLASH: Image is shorter than expected\n");
	436	return -EINVAL;
	437	}
	438
	439	image_data.data = vzalloc(PAGE_ALIGN(image_data.size));
	440	if (!image_data.data) {
	441	pr_err("%s : Failed to allocate memory\n", __func__);
	442	return -ENOMEM;
	443	}
	444
	445	/* Pin memory */
	446	addr = image_data.data;
	447	size = PAGE_ALIGN(image_data.size);
	448	while (size > 0) {
	449	SetPageReserved(vmalloc_to_page(addr));
	450	addr += PAGE_SIZE;
	451	size -= PAGE_SIZE;
	452	}
	453
	454	image_data.status = IMAGE_LOADING;
	455	return 0;
	456	}
	457
	458	/*
	459	* Copy candidate image
	460	*
	461	* Parse candidate image header to get total image size
	462	* and pre-allocate required memory.
	463	*/
	464	static ssize_t image_data_write(struct file filp, struct kobject kobj,
	465	struct bin_attribute *bin_attr,
	466	char *buffer, loff_t pos, size_t count)
	467	{
	468	int rc;
	469
	470	mutex_lock(&image_data_mutex);
	471
	472	/* New image ? */
	473	if (pos == 0) {
	474	/* Free memory, if already allocated */
	475	if (image_data.data)
	476	free_image_buf();
	477
	478	/* Cancel outstanding image update request */
	479	if (update_flash_data.status == FLASH_IMG_READY)
	480	opal_flash_update(FLASH_UPDATE_CANCEL);
	481
	482	/* Allocate memory */
	483	rc = alloc_image_buf(buffer, count);
	484	if (rc)
	485	goto out;
	486	}
	487
	488	if (image_data.status != IMAGE_LOADING) {
	489	rc = -ENOMEM;
	490	goto out;
	491	}
	492
493	if ((pos + count) > image_data.size) {
494	rc = -EINVAL;
495	goto out;
496	}
497
498	memcpy(image_data.data + pos, (void *)buffer, count);
499	rc = count;
500
501	/* Set image status */
502	if ((pos + count) == image_data.size) {
503	pr_debug("FLASH: Candidate image loaded....\n");
504	image_data.status = IMAGE_READY;
505	}
506
507	out:
508	mutex_unlock(&image_data_mutex);
509	return rc;
510	}
511
512	/*
513	* sysfs interface :
514	* OPAL uses below sysfs files for code update.
515	* We create these files under /sys/firmware/opal.
516	*
517	* image : Interface to load candidate firmware image
518	* validate_flash : Validate firmware image
519	* manage_flash : Commit/Reject firmware image
520	* update_flash : Flash new firmware image
521	*
522	*/
523	static struct bin_attribute image_data_attr = {
524	.attr = {.name = "image", .mode = 0200},
525	.size = MAX_IMAGE_SIZE, /* Limit image size */
526	.write = image_data_write,
527	};
528
529	static struct kobj_attribute validate_attribute =
530	__ATTR(validate_flash, 0600, validate_show, validate_store);
531
532	static struct kobj_attribute manage_attribute =
533	__ATTR(manage_flash, 0600, manage_show, manage_store);
534
535	static struct kobj_attribute update_attribute =
536	__ATTR(update_flash, 0600, update_show, update_store);
537
538	static struct attribute *image_op_attrs[] = {
539	&validate_attribute.attr,
540	&manage_attribute.attr,
541	&update_attribute.attr,
542	NULL /* need to NULL terminate the list of attributes */
543	};
544
545	static struct attribute_group image_op_attr_group = {
546	.attrs = image_op_attrs,
547	};
548
ed59190e	549	void __init opal_flash_update_init(void)
50bd6153 VH	550	{
	551	int ret;
	552
	553	/* Allocate validate image buffer */
	554	validate_flash_data.buf = kzalloc(VALIDATE_BUF_SIZE, GFP_KERNEL);
	555	if (!validate_flash_data.buf) {
	556	pr_err("%s : Failed to allocate memory\n", __func__);
	557	return;
	558	}
	559
	560	/* Make sure /sys/firmware/opal directory is created */
	561	if (!opal_kobj) {
	562	pr_warn("FLASH: opal kobject is not available\n");
	563	goto nokobj;
	564	}
	565
	566	/* Create the sysfs files */
	567	ret = sysfs_create_group(opal_kobj, &image_op_attr_group);
	568	if (ret) {
	569	pr_warn("FLASH: Failed to create sysfs files\n");
	570	goto nokobj;
	571	}
	572
	573	ret = sysfs_create_bin_file(opal_kobj, &image_data_attr);
	574	if (ret) {
	575	pr_warn("FLASH: Failed to create sysfs files\n");
	576	goto nosysfs_file;
	577	}
	578
	579	/* Set default status */
	580	validate_flash_data.status = FLASH_NO_OP;
	581	manage_flash_data.status = FLASH_NO_OP;
	582	update_flash_data.status = FLASH_NO_OP;
	583	image_data.status = IMAGE_INVALID;
	584	return;
	585
	586	nosysfs_file:
	587	sysfs_remove_group(opal_kobj, &image_op_attr_group);
	588
	589	nokobj:
	590	kfree(validate_flash_data.buf);
	591	return;
	592	}