// SPDX-License-Identifier: GPL-2.0

  /*

   * Copyright (C) 2010 - 2015 UNISYS CORPORATION

   * All rights reserved.

   */

  #include <linux/acpi.h>

  #include <linux/crash_dump.h>

  #include <linux/visorbus.h>

  #include "visorbus_private.h"

  /* {72120008-4AAB-11DC-8530-444553544200} */

  #define VISOR_SIOVM_GUID GUID_INIT(0x72120008, 0x4AAB, 0x11DC, 0x85, 0x30, \
  				   0x44, 0x45, 0x53, 0x54, 0x42, 0x00)

  static const guid_t visor_vhba_channel_guid = VISOR_VHBA_CHANNEL_GUID;
  static const guid_t visor_siovm_guid = VISOR_SIOVM_GUID;
  static const guid_t visor_controlvm_channel_guid = VISOR_CONTROLVM_CHANNEL_GUID;

  #define POLLJIFFIES_CONTROLVM_FAST 1
  #define POLLJIFFIES_CONTROLVM_SLOW 100

  #define MAX_CONTROLVM_PAYLOAD_BYTES (1024 * 128)

  #define UNISYS_VISOR_LEAF_ID 0x40000000

  
  /* The s-Par leaf ID returns "UnisysSpar64" encoded across ebx, ecx, edx */

  #define UNISYS_VISOR_ID_EBX 0x73696e55
  #define UNISYS_VISOR_ID_ECX 0x70537379
  #define UNISYS_VISOR_ID_EDX 0x34367261

  /*

   * When the controlvm channel is idle for at least MIN_IDLE_SECONDS, we switch
   * to slow polling mode. As soon as we get a controlvm message, we switch back
   * to fast polling mode.

   */

  #define MIN_IDLE_SECONDS 10

  struct parser_context {
  	unsigned long allocbytes;
  	unsigned long param_bytes;
  	u8 *curr;
  	unsigned long bytes_remaining;
  	bool byte_stream;

  	struct visor_controlvm_parameters_header data;

  };

  /* VMCALL_CONTROLVM_ADDR: Used by all guests, not just IO. */

  #define VMCALL_CONTROLVM_ADDR 0x0501
  
  enum vmcall_result {
  	VMCALL_RESULT_SUCCESS = 0,
  	VMCALL_RESULT_INVALID_PARAM = 1,
  	VMCALL_RESULT_DATA_UNAVAILABLE = 2,
  	VMCALL_RESULT_FAILURE_UNAVAILABLE = 3,
  	VMCALL_RESULT_DEVICE_ERROR = 4,
  	VMCALL_RESULT_DEVICE_NOT_READY = 5
  };
  
  /*
   * struct vmcall_io_controlvm_addr_params - Structure for IO VMCALLS. Has
   *					    parameters to VMCALL_CONTROLVM_ADDR
   *					    interface.
   * @address:	   The Guest-relative physical address of the ControlVm channel.
   *		   This VMCall fills this in with the appropriate address.
   *		   Contents provided by this VMCALL (OUT).
   * @channel_bytes: The size of the ControlVm channel in bytes This VMCall fills
   *		   this in with the appropriate address. Contents provided by
   *		   this VMCALL (OUT).
   * @unused:	   Unused Bytes in the 64-Bit Aligned Struct.
   */
  struct vmcall_io_controlvm_addr_params {
  	u64 address;
  	u32 channel_bytes;
  	u8 unused[4];
  } __packed;

  struct visorchipset_device {
  	struct acpi_device *acpi_device;
  	unsigned long poll_jiffies;
  	/* when we got our last controlvm message */
  	unsigned long most_recent_message_jiffies;
  	struct delayed_work periodic_controlvm_work;

  	struct visorchannel *controlvm_channel;
  	unsigned long controlvm_payload_bytes_buffered;
  	/*
  	 * The following variables are used to handle the scenario where we are
  	 * unable to offload the payload from a controlvm message due to memory
  	 * requirements. In this scenario, we simply stash the controlvm
  	 * message, then attempt to process it again the next time
  	 * controlvm_periodic_work() runs.
  	 */
  	struct controlvm_message controlvm_pending_msg;
  	bool controlvm_pending_msg_valid;

  	struct vmcall_io_controlvm_addr_params controlvm_params;

  };

  static struct visorchipset_device *chipset_dev;

  struct parahotplug_request {
  	struct list_head list;
  	int id;
  	unsigned long expiration;

  	struct controlvm_message msg;

  };

  /* prototypes for attributes */
  static ssize_t toolaction_show(struct device *dev,

  			       struct device_attribute *attr,
  			       char *buf)
  {
  	u8 tool_action = 0;

  	int err;
  
  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,

  					 tool_action),
  				&tool_action, sizeof(u8));
  	if (err)
  		return err;

  	return sprintf(buf, "%u
  ", tool_action);

  }

  static ssize_t toolaction_store(struct device *dev,

  				struct device_attribute *attr,

  				const char *buf, size_t count)
  {
  	u8 tool_action;

  	int err;

  
  	if (kstrtou8(buf, 10, &tool_action))
  		return -EINVAL;

  	err = visorchannel_write(chipset_dev->controlvm_channel,
  				 offsetof(struct visor_controlvm_channel,
  					  tool_action),
  				 &tool_action, sizeof(u8));

  	if (err)
  		return err;

  	return count;
  }

  static DEVICE_ATTR_RW(toolaction);

  static ssize_t boottotool_show(struct device *dev,

  			       struct device_attribute *attr,
  			       char *buf)
  {

  	struct efi_visor_indication efi_visor_indication;

  	int err;
  
  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,
  					 efi_visor_ind),
  				&efi_visor_indication,
  				sizeof(struct efi_visor_indication));

  	if (err)
  		return err;

  	return sprintf(buf, "%u
  ", efi_visor_indication.boot_to_tool);

  }

  static ssize_t boottotool_store(struct device *dev,

  				struct device_attribute *attr,
  				const char *buf, size_t count)
  {

  	int val, err;

  	struct efi_visor_indication efi_visor_indication;

  
  	if (kstrtoint(buf, 10, &val))
  		return -EINVAL;

  	efi_visor_indication.boot_to_tool = val;
  	err = visorchannel_write(chipset_dev->controlvm_channel,
  				 offsetof(struct visor_controlvm_channel,
  					  efi_visor_ind),
  				 &(efi_visor_indication),
  				 sizeof(struct efi_visor_indication));

  	if (err)
  		return err;

  	return count;
  }

  static DEVICE_ATTR_RW(boottotool);

  static ssize_t error_show(struct device *dev, struct device_attribute *attr,

  			  char *buf)
  {
  	u32 error = 0;

  	int err;

  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,

  					 installation_error),
  				&error, sizeof(u32));
  	if (err)
  		return err;

  	return sprintf(buf, "%u
  ", error);

  }

  static ssize_t error_store(struct device *dev, struct device_attribute *attr,

  			   const char *buf, size_t count)
  {
  	u32 error;

  	int err;

  
  	if (kstrtou32(buf, 10, &error))
  		return -EINVAL;

  	err = visorchannel_write(chipset_dev->controlvm_channel,
  				 offsetof(struct visor_controlvm_channel,
  					  installation_error),
  				 &error, sizeof(u32));

  	if (err)
  		return err;

  	return count;
  }

  static DEVICE_ATTR_RW(error);
  
  static ssize_t textid_show(struct device *dev, struct device_attribute *attr,

  			   char *buf)
  {
  	u32 text_id = 0;

  	int err;

  	err = visorchannel_read(chipset_dev->controlvm_channel,
  				offsetof(struct visor_controlvm_channel,
  					 installation_text_id),
  				&text_id, sizeof(u32));

  	if (err)
  		return err;

  	return sprintf(buf, "%u
  ", text_id);

  }

  static ssize_t textid_store(struct device *dev, struct device_attribute *attr,

  			    const char *buf, size_t count)
  {
  	u32 text_id;

  	int err;

  
  	if (kstrtou32(buf, 10, &text_id))
  		return -EINVAL;

  	err = visorchannel_write(chipset_dev->controlvm_channel,
  				 offsetof(struct visor_controlvm_channel,
  					  installation_text_id),
  				 &text_id, sizeof(u32));

  	if (err)
  		return err;

  	return count;
  }

  static DEVICE_ATTR_RW(textid);
  
  static ssize_t remaining_steps_show(struct device *dev,

  				    struct device_attribute *attr, char *buf)
  {
  	u16 remaining_steps = 0;

  	int err;
  
  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,

  					 installation_remaining_steps),
  				&remaining_steps, sizeof(u16));
  	if (err)
  		return err;

  	return sprintf(buf, "%hu
  ", remaining_steps);

  }

  static ssize_t remaining_steps_store(struct device *dev,

  				     struct device_attribute *attr,

  				     const char *buf, size_t count)
  {
  	u16 remaining_steps;

  	int err;

  
  	if (kstrtou16(buf, 10, &remaining_steps))
  		return -EINVAL;

  	err = visorchannel_write(chipset_dev->controlvm_channel,
  				 offsetof(struct visor_controlvm_channel,
  					  installation_remaining_steps),
  				 &remaining_steps, sizeof(u16));

  	if (err)
  		return err;

  	return count;
  }

  static DEVICE_ATTR_RW(remaining_steps);

  static void controlvm_init_response(struct controlvm_message *msg,
  				    struct controlvm_message_header *msg_hdr,
  				    int response)

  {
  	memset(msg, 0, sizeof(struct controlvm_message));
  	memcpy(&msg->hdr, msg_hdr, sizeof(struct controlvm_message_header));
  	msg->hdr.payload_bytes = 0;
  	msg->hdr.payload_vm_offset = 0;
  	msg->hdr.payload_max_bytes = 0;
  	if (response < 0) {
  		msg->hdr.flags.failed = 1;
  		msg->hdr.completion_status = (u32)(-response);
  	}
  }

  static int controlvm_respond_chipset_init(
  				struct controlvm_message_header *msg_hdr,
  				int response,
  				enum visor_chipset_feature features)

  {
  	struct controlvm_message outmsg;
  
  	controlvm_init_response(&outmsg, msg_hdr, response);
  	outmsg.cmd.init_chipset.features = features;

  	return visorchannel_signalinsert(chipset_dev->controlvm_channel,

  					 CONTROLVM_QUEUE_REQUEST, &outmsg);

  }

  static int chipset_init(struct controlvm_message *inmsg)

  {
  	static int chipset_inited;

  	enum visor_chipset_feature features = 0;

  	int rc = CONTROLVM_RESP_SUCCESS;

  	int res = 0;

  	if (chipset_inited) {

  		rc = -CONTROLVM_RESP_ALREADY_DONE;

  		res = -EIO;

  		goto out_respond;

  	}
  	chipset_inited = 1;

  	/*

  	 * Set features to indicate we support parahotplug (if Command also

  	 * supports it). Set the "reply" bit so Command knows this is a
  	 * features-aware driver.

  	 */

  	features = inmsg->cmd.init_chipset.features &

  		   VISOR_CHIPSET_FEATURE_PARA_HOTPLUG;

  	features |= VISOR_CHIPSET_FEATURE_REPLY;

  out_respond:

  	if (inmsg->hdr.flags.response_expected)

  		res = controlvm_respond_chipset_init(&inmsg->hdr, rc, features);
  
  	return res;

  }

  static int controlvm_respond(struct controlvm_message_header *msg_hdr,

  			     int response, struct visor_segment_state *state)

  {

  	struct controlvm_message outmsg;

  	controlvm_init_response(&outmsg, msg_hdr, response);

  	if (outmsg.hdr.flags.test_message == 1)

  		return -EINVAL;

  	if (state) {
  		outmsg.cmd.device_change_state.state = *state;
  		outmsg.cmd.device_change_state.flags.phys_device = 1;
  	}

  	return visorchannel_signalinsert(chipset_dev->controlvm_channel,

  					 CONTROLVM_QUEUE_REQUEST, &outmsg);

  }

  enum crash_obj_type {
  	CRASH_DEV,
  	CRASH_BUS,
  };

  static int save_crash_message(struct controlvm_message *msg,
  			      enum crash_obj_type cr_type)

  {
  	u32 local_crash_msg_offset;
  	u16 local_crash_msg_count;

  	int err;

  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,

  					 saved_crash_message_count),
  				&local_crash_msg_count, sizeof(u16));
  	if (err) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to read message count
  ");

  		return err;

  	}

  	if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"invalid number of messages
  ");

  		return -EIO;

  	}

  	err = visorchannel_read(chipset_dev->controlvm_channel,

  				offsetof(struct visor_controlvm_channel,

  					 saved_crash_message_offset),
  				&local_crash_msg_offset, sizeof(u32));
  	if (err) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to read offset
  ");

  		return err;

  	}

  	switch (cr_type) {

  	case CRASH_DEV:
  		local_crash_msg_offset += sizeof(struct controlvm_message);

  		err = visorchannel_write(chipset_dev->controlvm_channel,

  					 local_crash_msg_offset, msg,

  					 sizeof(struct controlvm_message));

  		if (err) {

  			dev_err(&chipset_dev->acpi_device->dev,
  				"failed to write dev msg
  ");

  			return err;

  		}

  		break;
  	case CRASH_BUS:

  		err = visorchannel_write(chipset_dev->controlvm_channel,

  					 local_crash_msg_offset, msg,

  					 sizeof(struct controlvm_message));
  		if (err) {

  			dev_err(&chipset_dev->acpi_device->dev,
  				"failed to write bus msg
  ");

  			return err;

  		}

  		break;
  	default:

  		dev_err(&chipset_dev->acpi_device->dev,
  			"Invalid crash_obj_type
  ");

  		break;

  	}

  	return 0;

  }

  static int controlvm_responder(enum controlvm_id cmd_id,
  			       struct controlvm_message_header *pending_msg_hdr,
  			       int response)

  {

  	if (pending_msg_hdr->id != (u32)cmd_id)

  		return -EINVAL;

  	return controlvm_respond(pending_msg_hdr, response, NULL);

  }

  static int device_changestate_responder(enum controlvm_id cmd_id,
  					struct visor_device *p, int response,
  					struct visor_segment_state state)

  {

  	struct controlvm_message outmsg;

  	if (p->pending_msg_hdr->id != cmd_id)

  		return -EINVAL;

  	controlvm_init_response(&outmsg, p->pending_msg_hdr, response);

  	outmsg.cmd.device_change_state.bus_no = p->chipset_bus_no;
  	outmsg.cmd.device_change_state.dev_no = p->chipset_dev_no;

  	outmsg.cmd.device_change_state.state = state;

  	return visorchannel_signalinsert(chipset_dev->controlvm_channel,

  					 CONTROLVM_QUEUE_REQUEST, &outmsg);

  }

  static int visorbus_create(struct controlvm_message *inmsg)

  {

  	struct controlvm_message_packet *cmd = &inmsg->cmd;

  	struct controlvm_message_header *pmsg_hdr;

  	u32 bus_no = cmd->create_bus.bus_no;

  	struct visor_device *bus_info;

  	struct visorchannel *visorchannel;

  	int err;

  	bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);

  	if (bus_info && bus_info->state.created == 1) {

  		dev_err(&chipset_dev->acpi_device->dev,

  			"failed %s: already exists
  ", __func__);

  		err = -EEXIST;
  		goto err_respond;

  	}

  	bus_info = kzalloc(sizeof(*bus_info), GFP_KERNEL);
  	if (!bus_info) {

  		err = -ENOMEM;
  		goto err_respond;

  	}

  	INIT_LIST_HEAD(&bus_info->list_all);

  	bus_info->chipset_bus_no = bus_no;
  	bus_info->chipset_dev_no = BUS_ROOT_DEVICE;

  	if (guid_equal(&cmd->create_bus.bus_inst_guid, &visor_siovm_guid)) {

  		err = save_crash_message(inmsg, CRASH_BUS);
  		if (err)
  			goto err_free_bus_info;
  	}

  	if (inmsg->hdr.flags.response_expected == 1) {

  		pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);

  		if (!pmsg_hdr) {

  			err = -ENOMEM;
  			goto err_free_bus_info;

  		}

  		memcpy(pmsg_hdr, &inmsg->hdr,
  		       sizeof(struct controlvm_message_header));
  		bus_info->pending_msg_hdr = pmsg_hdr;
  	}

  	visorchannel = visorchannel_create(cmd->create_bus.channel_addr,

  					   GFP_KERNEL,

  					   &cmd->create_bus.bus_data_type_guid,
  					   false);

  	if (!visorchannel) {

  		err = -ENOMEM;
  		goto err_free_pending_msg;
  	}
  	bus_info->visorchannel = visorchannel;

  	/* Response will be handled by visorbus_create_instance on success */
  	err = visorbus_create_instance(bus_info);

  	if (err)
  		goto err_destroy_channel;

  	return 0;

  err_destroy_channel:
  	visorchannel_destroy(visorchannel);

  err_free_pending_msg:
  	kfree(bus_info->pending_msg_hdr);

  err_free_bus_info:

  	kfree(bus_info);

  err_respond:

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  static int visorbus_destroy(struct controlvm_message *inmsg)

  {

  	struct controlvm_message_header *pmsg_hdr;

  	u32 bus_no = inmsg->cmd.destroy_bus.bus_no;

  	struct visor_device *bus_info;

  	int err;

  	bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);

  	if (!bus_info) {

  		err = -ENODEV;
  		goto err_respond;

  	}
  	if (bus_info->state.created == 0) {

  		err = -ENOENT;
  		goto err_respond;

  	}
  	if (bus_info->pending_msg_hdr) {
  		/* only non-NULL if dev is still waiting on a response */

  		err = -EEXIST;
  		goto err_respond;

  	}
  	if (inmsg->hdr.flags.response_expected == 1) {
  		pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
  		if (!pmsg_hdr) {

  			err = -ENOMEM;
  			goto err_respond;

  		}

  		memcpy(pmsg_hdr, &inmsg->hdr,
  		       sizeof(struct controlvm_message_header));
  		bus_info->pending_msg_hdr = pmsg_hdr;
  	}

  	/* Response will be handled by visorbus_remove_instance */
  	visorbus_remove_instance(bus_info);

  	return 0;

  err_respond:

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  static const guid_t *parser_id_get(struct parser_context *ctx)
  {
  	return &ctx->data.id;
  }

  static void *parser_string_get(u8 *pscan, int nscan)

  {

  	int value_length;
  	void *value;

  	if (nscan == 0)
  		return NULL;

  	value_length = strnlen(pscan, nscan);
  	value = kzalloc(value_length + 1, GFP_KERNEL);

  	if (!value)
  		return NULL;
  	if (value_length > 0)
  		memcpy(value, pscan, value_length);

  	return value;
  }
  
  static void *parser_name_get(struct parser_context *ctx)
  {

  	struct visor_controlvm_parameters_header *phdr;

  
  	phdr = &ctx->data;

  	if ((unsigned long)phdr->name_offset +
  	    (unsigned long)phdr->name_length > ctx->param_bytes)

  		return NULL;

  	ctx->curr = (char *)&phdr + phdr->name_offset;
  	ctx->bytes_remaining = phdr->name_length;

  	return parser_string_get(ctx->curr, phdr->name_length);

  }

  static int visorbus_configure(struct controlvm_message *inmsg,
  			      struct parser_context *parser_ctx)

  {

  	struct controlvm_message_packet *cmd = &inmsg->cmd;

  	u32 bus_no;

  	struct visor_device *bus_info;

  	int err = 0;

  	bus_no = cmd->configure_bus.bus_no;

  	bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);

  	if (!bus_info) {

  		err = -EINVAL;
  		goto err_respond;

  	}
  	if (bus_info->state.created == 0) {

  		err = -EINVAL;
  		goto err_respond;

  	}
  	if (bus_info->pending_msg_hdr) {

  		err = -EIO;
  		goto err_respond;

  	}

  	err = visorchannel_set_clientpartition(bus_info->visorchannel,
  					       cmd->configure_bus.guest_handle);

  	if (err)
  		goto err_respond;

  	if (parser_ctx) {

  		const guid_t *partition_guid = parser_id_get(parser_ctx);
  
  		guid_copy(&bus_info->partition_guid, partition_guid);

  		bus_info->name = parser_name_get(parser_ctx);
  	}

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return 0;
  
  err_respond:

  	dev_err(&chipset_dev->acpi_device->dev,

  		"%s exited with err: %d
  ", __func__, err);

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  static int visorbus_device_create(struct controlvm_message *inmsg)

  {

  	struct controlvm_message_packet *cmd = &inmsg->cmd;

  	struct controlvm_message_header *pmsg_hdr;

  	u32 bus_no = cmd->create_device.bus_no;
  	u32 dev_no = cmd->create_device.dev_no;

  	struct visor_device *dev_info;

  	struct visor_device *bus_info;

  	struct visorchannel *visorchannel;

  	int err;

  	bus_info = visorbus_get_device_by_id(bus_no, BUS_ROOT_DEVICE, NULL);
  	if (!bus_info) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to get bus by id: %d
  ", bus_no);

  		err = -ENODEV;
  		goto err_respond;

  	}

  	if (bus_info->state.created == 0) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"bus not created, id: %d
  ", bus_no);

  		err = -EINVAL;
  		goto err_respond;

  	}

  	dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);

  	if (dev_info && dev_info->state.created == 1) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to get bus by id: %d/%d
  ", bus_no, dev_no);

  		err = -EEXIST;
  		goto err_respond;

  	}

  	dev_info = kzalloc(sizeof(*dev_info), GFP_KERNEL);
  	if (!dev_info) {

  		err = -ENOMEM;
  		goto err_respond;

  	}

  	dev_info->chipset_bus_no = bus_no;
  	dev_info->chipset_dev_no = dev_no;

  	guid_copy(&dev_info->inst, &cmd->create_device.dev_inst_guid);

  	dev_info->device.parent = &bus_info->device;

  	visorchannel = visorchannel_create(cmd->create_device.channel_addr,
  					   GFP_KERNEL,
  					   &cmd->create_device.data_type_guid,
  					   true);

  	if (!visorchannel) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to create visorchannel: %d/%d
  ",
  			bus_no, dev_no);

  		err = -ENOMEM;
  		goto err_free_dev_info;

  	}
  	dev_info->visorchannel = visorchannel;

  	guid_copy(&dev_info->channel_type_guid,
  		  &cmd->create_device.data_type_guid);
  	if (guid_equal(&cmd->create_device.data_type_guid,
  		       &visor_vhba_channel_guid)) {

  		err = save_crash_message(inmsg, CRASH_DEV);
  		if (err)

  			goto err_destroy_visorchannel;

  	}

  	if (inmsg->hdr.flags.response_expected == 1) {
  		pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
  		if (!pmsg_hdr) {

  			err = -ENOMEM;

  			goto err_destroy_visorchannel;

  		}

  		memcpy(pmsg_hdr, &inmsg->hdr,
  		       sizeof(struct controlvm_message_header));
  		dev_info->pending_msg_hdr = pmsg_hdr;
  	}

  	/* create_visor_device will send response */
  	err = create_visor_device(dev_info);

  	if (err)
  		goto err_destroy_visorchannel;

  	return 0;

  err_destroy_visorchannel:
  	visorchannel_destroy(visorchannel);

  err_free_dev_info:

  	kfree(dev_info);

  err_respond:

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  static int visorbus_device_changestate(struct controlvm_message *inmsg)

  {

  	struct controlvm_message_packet *cmd = &inmsg->cmd;

  	struct controlvm_message_header *pmsg_hdr;

  	u32 bus_no = cmd->device_change_state.bus_no;
  	u32 dev_no = cmd->device_change_state.dev_no;

  	struct visor_segment_state state = cmd->device_change_state.state;

  	struct visor_device *dev_info;

  	int err = 0;

  	dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);

  	if (!dev_info) {

  		err = -ENODEV;

  		goto err_respond;
  	}
  	if (dev_info->state.created == 0) {

  		err = -EINVAL;

  		goto err_respond;

  	}

  	if (dev_info->pending_msg_hdr) {
  		/* only non-NULL if dev is still waiting on a response */

  		err = -EIO;

  		goto err_respond;
  	}

  	if (inmsg->hdr.flags.response_expected == 1) {
  		pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
  		if (!pmsg_hdr) {

  			err = -ENOMEM;

  			goto err_respond;
  		}

  		memcpy(pmsg_hdr, &inmsg->hdr,
  		       sizeof(struct controlvm_message_header));
  		dev_info->pending_msg_hdr = pmsg_hdr;
  	}

  	if (state.alive == segment_state_running.alive &&
  	    state.operating == segment_state_running.operating)

  		/* Response will be sent from visorchipset_device_resume */
  		err = visorchipset_device_resume(dev_info);

  	/* ServerNotReady / ServerLost / SegmentStateStandby */
  	else if (state.alive == segment_state_standby.alive &&
  		 state.operating == segment_state_standby.operating)
  		/*
  		 * technically this is standby case where server is lost.

  		 * Response will be sent from visorchipset_device_pause.

  		 */

  		err = visorchipset_device_pause(dev_info);

  	if (err)
  		goto err_respond;

  	return 0;

  
  err_respond:

  	dev_err(&chipset_dev->acpi_device->dev, "failed: %d
  ", err);

  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  static int visorbus_device_destroy(struct controlvm_message *inmsg)

  {

  	struct controlvm_message_packet *cmd = &inmsg->cmd;

  	struct controlvm_message_header *pmsg_hdr;

  	u32 bus_no = cmd->destroy_device.bus_no;
  	u32 dev_no = cmd->destroy_device.dev_no;

  	struct visor_device *dev_info;

  	int err;

  	dev_info = visorbus_get_device_by_id(bus_no, dev_no, NULL);

  	if (!dev_info) {

  		err = -ENODEV;

  		goto err_respond;
  	}
  	if (dev_info->state.created == 0) {

  		err = -EINVAL;

  		goto err_respond;
  	}

  	if (dev_info->pending_msg_hdr) {
  		/* only non-NULL if dev is still waiting on a response */

  		err = -EIO;

  		goto err_respond;
  	}
  	if (inmsg->hdr.flags.response_expected == 1) {
  		pmsg_hdr = kzalloc(sizeof(*pmsg_hdr), GFP_KERNEL);
  		if (!pmsg_hdr) {

  			err = -ENOMEM;

  			goto err_respond;
  		}
  
  		memcpy(pmsg_hdr, &inmsg->hdr,
  		       sizeof(struct controlvm_message_header));
  		dev_info->pending_msg_hdr = pmsg_hdr;
  	}

  	kfree(dev_info->name);

  	remove_visor_device(dev_info);

  	return 0;

  
  err_respond:
  	if (inmsg->hdr.flags.response_expected == 1)

  		controlvm_responder(inmsg->hdr.id, &inmsg->hdr, err);

  	return err;

  }

  /*

   * The general parahotplug flow works as follows. The visorchipset receives
   * a DEVICE_CHANGESTATE message from Command specifying a physical device
   * to enable or disable. The CONTROLVM message handler calls
   * parahotplug_process_message, which then adds the message to a global list
   * and kicks off a udev event which causes a user level script to enable or
   * disable the specified device. The udev script then writes to
   * /sys/devices/platform/visorchipset/parahotplug, which causes the
   * parahotplug store functions to get called, at which point the

   * appropriate CONTROLVM message is retrieved from the list and responded to.

   */
  
  #define PARAHOTPLUG_TIMEOUT_MS 2000

  /*

   * parahotplug_next_id() - generate unique int to match an outstanding
   *                         CONTROLVM message with a udev script /sys
   *                         response

   *
   * Return: a unique integer value

   */

  static int parahotplug_next_id(void)

  {
  	static atomic_t id = ATOMIC_INIT(0);

  	return atomic_inc_return(&id);
  }

  /*

   * parahotplug_next_expiration() - returns the time (in jiffies) when a
   *                                 CONTROLVM message on the list should expire
   *                                 -- PARAHOTPLUG_TIMEOUT_MS in the future
   *
   * Return: expected expiration time (in jiffies)

   */

  static unsigned long parahotplug_next_expiration(void)

  {

  	return jiffies + msecs_to_jiffies(PARAHOTPLUG_TIMEOUT_MS);

  }

  /*

   * parahotplug_request_create() - create a parahotplug_request, which is
   *                                basically a wrapper for a CONTROLVM_MESSAGE
   *                                that we can stick on a list
   * @msg: the message to insert in the request
   *
   * Return: the request containing the provided message

   */

  static struct parahotplug_request *parahotplug_request_create(
  						struct controlvm_message *msg)

  {

  	struct parahotplug_request *req;

  	req = kmalloc(sizeof(*req), GFP_KERNEL);

  	if (!req)

  		return NULL;

  	req->id = parahotplug_next_id();
  	req->expiration = parahotplug_next_expiration();
  	req->msg = *msg;

  	return req;
  }

  /*

   * parahotplug_request_destroy() - free a parahotplug_request
   * @req: the request to deallocate

   */

  static void parahotplug_request_destroy(struct parahotplug_request *req)

  {
  	kfree(req);
  }

  static LIST_HEAD(parahotplug_request_list);

  /* lock for above */
  static DEFINE_SPINLOCK(parahotplug_request_list_lock);

  /*

   * parahotplug_request_complete() - mark request as complete
   * @id:     the id of the request
   * @active: indicates whether the request is assigned to active partition
   *

   * Called from the /sys handler, which means the user script has

   * finished the enable/disable. Find the matching identifier, and

   * respond to the CONTROLVM message with success.

   *
   * Return: 0 on success or -EINVAL on failure

   */

  static int parahotplug_request_complete(int id, u16 active)

  {

  	struct list_head *pos;
  	struct list_head *tmp;

  	struct parahotplug_request *req;

  	spin_lock(&parahotplug_request_list_lock);

  	/* Look for a request matching "id". */

  	list_for_each_safe(pos, tmp, &parahotplug_request_list) {

  		req = list_entry(pos, struct parahotplug_request, list);

  		if (req->id == id) {

  			/*
  			 * Found a match. Remove it from the list and

  			 * respond.
  			 */
  			list_del(pos);

  			spin_unlock(&parahotplug_request_list_lock);

  			req->msg.cmd.device_change_state.state.active = active;

  			if (req->msg.hdr.flags.response_expected)

  				controlvm_respond(
  				       &req->msg.hdr, CONTROLVM_RESP_SUCCESS,
  				       &req->msg.cmd.device_change_state.state);

  			parahotplug_request_destroy(req);
  			return 0;
  		}
  	}

  	spin_unlock(&parahotplug_request_list_lock);

  	return -EINVAL;

  }

  /*

   * devicedisabled_store() - disables the hotplug device
   * @dev:   sysfs interface variable not utilized in this function
   * @attr:  sysfs interface variable not utilized in this function
   * @buf:   buffer containing the device id
   * @count: the size of the buffer
   *
   * The parahotplug/devicedisabled interface gets called by our support script
   * when an SR-IOV device has been shut down. The ID is passed to the script
   * and then passed back when the device has been removed.
   *
   * Return: the size of the buffer for success or negative for error
   */
  static ssize_t devicedisabled_store(struct device *dev,
  				    struct device_attribute *attr,
  				    const char *buf, size_t count)
  {
  	unsigned int id;
  	int err;
  
  	if (kstrtouint(buf, 10, &id))
  		return -EINVAL;

  	err = parahotplug_request_complete(id, 0);
  	if (err < 0)
  		return err;
  	return count;
  }
  static DEVICE_ATTR_WO(devicedisabled);

  /*

   * deviceenabled_store() - enables the hotplug device
   * @dev:   sysfs interface variable not utilized in this function
   * @attr:  sysfs interface variable not utilized in this function
   * @buf:   buffer containing the device id
   * @count: the size of the buffer
   *
   * The parahotplug/deviceenabled interface gets called by our support script
   * when an SR-IOV device has been recovered. The ID is passed to the script
   * and then passed back when the device has been brought back up.
   *
   * Return: the size of the buffer for success or negative for error
   */
  static ssize_t deviceenabled_store(struct device *dev,
  				   struct device_attribute *attr,
  				   const char *buf, size_t count)
  {
  	unsigned int id;
  
  	if (kstrtouint(buf, 10, &id))
  		return -EINVAL;

  	parahotplug_request_complete(id, 1);
  	return count;
  }
  static DEVICE_ATTR_WO(deviceenabled);
  
  static struct attribute *visorchipset_install_attrs[] = {
  	&dev_attr_toolaction.attr,
  	&dev_attr_boottotool.attr,
  	&dev_attr_error.attr,
  	&dev_attr_textid.attr,
  	&dev_attr_remaining_steps.attr,
  	NULL
  };

  static const struct attribute_group visorchipset_install_group = {

  	.name = "install",
  	.attrs = visorchipset_install_attrs
  };
  
  static struct attribute *visorchipset_parahotplug_attrs[] = {
  	&dev_attr_devicedisabled.attr,
  	&dev_attr_deviceenabled.attr,
  	NULL
  };

  static const struct attribute_group visorchipset_parahotplug_group = {

  	.name = "parahotplug",
  	.attrs = visorchipset_parahotplug_attrs
  };
  
  static const struct attribute_group *visorchipset_dev_groups[] = {
  	&visorchipset_install_group,
  	&visorchipset_parahotplug_group,
  	NULL
  };

  /*

   * parahotplug_request_kickoff() - initiate parahotplug request
   * @req: the request to initiate
   *
   * Cause uevent to run the user level script to do the disable/enable specified
   * in the parahotplug_request.
   */

  static int parahotplug_request_kickoff(struct parahotplug_request *req)

  {
  	struct controlvm_message_packet *cmd = &req->msg.cmd;
  	char env_cmd[40], env_id[40], env_state[40], env_bus[40], env_dev[40],

  	     env_func[40];
  	char *envp[] = { env_cmd, env_id, env_state, env_bus, env_dev,
  			 env_func, NULL

  	};

  	sprintf(env_cmd, "VISOR_PARAHOTPLUG=1");
  	sprintf(env_id, "VISOR_PARAHOTPLUG_ID=%d", req->id);
  	sprintf(env_state, "VISOR_PARAHOTPLUG_STATE=%d",

  		cmd->device_change_state.state.active);

  	sprintf(env_bus, "VISOR_PARAHOTPLUG_BUS=%d",

  		cmd->device_change_state.bus_no);

  	sprintf(env_dev, "VISOR_PARAHOTPLUG_DEVICE=%d",

  		cmd->device_change_state.dev_no >> 3);

  	sprintf(env_func, "VISOR_PARAHOTPLUG_FUNCTION=%d",

  		cmd->device_change_state.dev_no & 0x7);

  	return kobject_uevent_env(&chipset_dev->acpi_device->dev.kobj,
  				  KOBJ_CHANGE, envp);

  }

  /*

   * parahotplug_process_message() - enables or disables a PCI device by kicking
   *                                 off a udev script
   * @inmsg: the message indicating whether to enable or disable

   */

  static int parahotplug_process_message(struct controlvm_message *inmsg)

  {
  	struct parahotplug_request *req;

  	int err;

  
  	req = parahotplug_request_create(inmsg);

  	if (!req)

  		return -ENOMEM;

  	/*
  	 * For enable messages, just respond with success right away, we don't
  	 * need to wait to see if the enable was successful.
  	 */

  	if (inmsg->cmd.device_change_state.state.active) {

  		err = parahotplug_request_kickoff(req);
  		if (err)
  			goto err_respond;

  		controlvm_respond(&inmsg->hdr, CONTROLVM_RESP_SUCCESS,
  				  &inmsg->cmd.device_change_state.state);

  		parahotplug_request_destroy(req);

  		return 0;

  	}

  	/*

  	 * For disable messages, add the request to the request list before
  	 * kicking off the udev script. It won't get responded to until the
  	 * script has indicated it's done.

  	 */
  	spin_lock(&parahotplug_request_list_lock);
  	list_add_tail(&req->list, &parahotplug_request_list);
  	spin_unlock(&parahotplug_request_list_lock);

  	err = parahotplug_request_kickoff(req);
  	if (err)
  		goto err_respond;

  	return 0;

  
  err_respond:

  	controlvm_respond(&inmsg->hdr, err,
  			  &inmsg->cmd.device_change_state.state);

  	return err;

  }

  /*
   * chipset_ready_uevent() - sends chipset_ready action

   *
   * Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
   *

   * Return: 0 on success, negative on failure

   */

  static int chipset_ready_uevent(struct controlvm_message_header *msg_hdr)

  {

  	int res;

  	res = kobject_uevent(&chipset_dev->acpi_device->dev.kobj, KOBJ_ONLINE);

  	if (msg_hdr->flags.response_expected)

  		controlvm_respond(msg_hdr, res, NULL);

  	return res;

  }

  /*
   * chipset_selftest_uevent() - sends chipset_selftest action
   *
   * Send ACTION=online for DEVPATH=/sys/devices/platform/visorchipset.
   *
   * Return: 0 on success, negative on failure
   */

  static int chipset_selftest_uevent(struct controlvm_message_header *msg_hdr)

  {
  	char env_selftest[20];
  	char *envp[] = { env_selftest, NULL };

  	int res;

  
  	sprintf(env_selftest, "SPARSP_SELFTEST=%d", 1);

  	res = kobject_uevent_env(&chipset_dev->acpi_device->dev.kobj,
  				 KOBJ_CHANGE, envp);

  	if (msg_hdr->flags.response_expected)

  		controlvm_respond(msg_hdr, res, NULL);

  	return res;

  }

  /*
   * chipset_notready_uevent() - sends chipset_notready action

   *
   * Send ACTION=offline for DEVPATH=/sys/devices/platform/visorchipset.
   *

   * Return: 0 on success, negative on failure

   */

  static int chipset_notready_uevent(struct controlvm_message_header *msg_hdr)

  {

  	int res = kobject_uevent(&chipset_dev->acpi_device->dev.kobj,

  				 KOBJ_OFFLINE);

  	if (msg_hdr->flags.response_expected)

  		controlvm_respond(msg_hdr, res, NULL);

  	return res;

  }

  static int unisys_vmcall(unsigned long tuple, unsigned long param)
  {
  	int result = 0;
  	unsigned int cpuid_eax, cpuid_ebx, cpuid_ecx, cpuid_edx;
  	unsigned long reg_ebx;
  	unsigned long reg_ecx;
  
  	reg_ebx = param & 0xFFFFFFFF;
  	reg_ecx = param >> 32;

  	cpuid(0x00000001, &cpuid_eax, &cpuid_ebx, &cpuid_ecx, &cpuid_edx);
  	if (!(cpuid_ecx & 0x80000000))
  		return -EPERM;

  	__asm__ __volatile__(".byte 0x00f, 0x001, 0x0c1" : "=a"(result) :

  			     "a"(tuple), "b"(reg_ebx), "c"(reg_ecx));

  	if (result)
  		goto error;

  	return 0;

  /* Need to convert from VMCALL error codes to Linux */
  error:

  	switch (result) {
  	case VMCALL_RESULT_INVALID_PARAM:
  		return -EINVAL;
  	case VMCALL_RESULT_DATA_UNAVAILABLE:
  		return -ENODEV;
  	default:
  		return -EFAULT;
  	}

  }

  static int controlvm_channel_create(struct visorchipset_device *dev)

  {

  	struct visorchannel *chan;
  	u64 addr;

  	int err;

  	err = unisys_vmcall(VMCALL_CONTROLVM_ADDR,
  			    virt_to_phys(&dev->controlvm_params));

  	if (err)
  		return err;

  	addr = dev->controlvm_params.address;

  	chan = visorchannel_create(addr, GFP_KERNEL,
  				   &visor_controlvm_channel_guid, true);

  	if (!chan)
  		return -ENOMEM;
  	dev->controlvm_channel = chan;

  	return 0;

  }

  static void setup_crash_devices_work_queue(struct work_struct *work)

  {

  	struct controlvm_message local_crash_bus_msg;
  	struct controlvm_message local_crash_dev_msg;

  	struct controlvm_message msg = {
  		.hdr.id = CONTROLVM_CHIPSET_INIT,
  		.cmd.init_chipset = {
  			.bus_count = 23,
  			.switch_count = 0,
  		},
  	};

  	u32 local_crash_msg_offset;
  	u16 local_crash_msg_count;

  	/* send init chipset msg */

  	chipset_init(&msg);

  	/* get saved message count */

  	if (visorchannel_read(chipset_dev->controlvm_channel,

  			      offsetof(struct visor_controlvm_channel,

  				       saved_crash_message_count),

  			      &local_crash_msg_count, sizeof(u16)) < 0) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to read channel
  ");

  		return;
  	}

  	if (local_crash_msg_count != CONTROLVM_CRASHMSG_MAX) {

  		dev_err(&chipset_dev->acpi_device->dev, "invalid count
  ");

  		return;
  	}

  	/* get saved crash message offset */

  	if (visorchannel_read(chipset_dev->controlvm_channel,

  			      offsetof(struct visor_controlvm_channel,

  				       saved_crash_message_offset),

  			      &local_crash_msg_offset, sizeof(u32)) < 0) {

  		dev_err(&chipset_dev->acpi_device->dev,
  			"failed to read channel
  ");

  		return;
  	}