// SPDX-License-Identifier: GPL-2.0

  /*

   * Copyright (C) 2010 - 2015 UNISYS CORPORATION

   * All rights reserved.

   */
  
  /*

   *  This provides s-Par channel communication primitives, which are

   *  independent of the mechanism used to access the channel data.

   */

  #include <linux/uuid.h>

  #include <linux/io.h>

  #include <linux/slab.h>

  #include <linux/visorbus.h>

  #include "visorbus_private.h"

  #include "controlvmchannel.h"

  #define VISOR_DRV_NAME "visorchannel"

  #define VISOR_CONSOLEVIDEO_CHANNEL_GUID \

  	GUID_INIT(0x3cd6e705, 0xd6a2, 0x4aa5, \
  		  0xad, 0x5c, 0x7b, 0x8, 0x88, 0x9d, 0xff, 0xe2)

  static const guid_t visor_video_guid = VISOR_CONSOLEVIDEO_CHANNEL_GUID;

  struct visorchannel {

  	u64 physaddr;

  	ulong nbytes;

  	void *mapped;

  	bool requested;

  	struct channel_header chan_hdr;

  	guid_t guid;

  	/*

  	 * channel creator knows if more than one thread will be inserting or
  	 * removing

  	 */
  	bool needs_lock;
  	/* protect head writes in chan_hdr */
  	spinlock_t insert_lock;
  	/* protect tail writes in chan_hdr */
  	spinlock_t remove_lock;

  	guid_t type;
  	guid_t inst;

  };

  void visorchannel_destroy(struct visorchannel *channel)

  {

  	if (!channel)

  		return;

  	if (channel->mapped) {

  		memunmap(channel->mapped);

  		if (channel->requested)
  			release_mem_region(channel->physaddr, channel->nbytes);

  	}

  	kfree(channel);
  }

  u64 visorchannel_get_physaddr(struct visorchannel *channel)

  {

  	return channel->physaddr;

  }

  ulong visorchannel_get_nbytes(struct visorchannel *channel)

  {

  	return channel->nbytes;

  }

  char *visorchannel_guid_id(const guid_t *guid, char *s)

  {

  	sprintf(s, "%pUL", guid);
  	return s;

  }

  char *visorchannel_id(struct visorchannel *channel, char *s)

  {

  	return visorchannel_guid_id(&channel->guid, s);

  }

  char *visorchannel_zoneid(struct visorchannel *channel, char *s)

  {

  	return visorchannel_guid_id(&channel->chan_hdr.zone_guid, s);

  }

  u64 visorchannel_get_clientpartition(struct visorchannel *channel)

  {

  	return channel->chan_hdr.partition_handle;

  }

  int visorchannel_set_clientpartition(struct visorchannel *channel,
  				     u64 partition_handle)

  {
  	channel->chan_hdr.partition_handle = partition_handle;
  	return 0;
  }

  /**

   * visorchannel_get_guid() - queries the GUID of the designated channel

   * @channel: the channel to query
   *

   * Return: the GUID of the provided channel

   */

  const guid_t *visorchannel_get_guid(struct visorchannel *channel)

  {

  	return &channel->guid;

  }

  EXPORT_SYMBOL_GPL(visorchannel_get_guid);

  int visorchannel_read(struct visorchannel *channel, ulong offset, void *dest,
  		      ulong nbytes)

  {

  	if (offset + nbytes > channel->nbytes)

  		return -EIO;

  	memcpy(dest, channel->mapped + offset, nbytes);

  	return 0;

  }

  int visorchannel_write(struct visorchannel *channel, ulong offset, void *dest,
  		       ulong nbytes)

  {

  	size_t chdr_size = sizeof(struct channel_header);
  	size_t copy_size;

  	if (offset + nbytes > channel->nbytes)

  		return -EIO;

  	if (offset < chdr_size) {

  		copy_size = min(chdr_size - offset, nbytes);

  		memcpy(((char *)(&channel->chan_hdr)) + offset,

  		       dest, copy_size);

  	}

  	memcpy(channel->mapped + offset, dest, nbytes);

  	return 0;

  }

  void *visorchannel_get_header(struct visorchannel *channel)

  {

  	return &channel->chan_hdr;

  }

  /*
   * Return offset of a specific SIGNAL_QUEUE_HEADER from the beginning of a
   * channel header

   */

  static int sig_queue_offset(struct channel_header *chan_hdr, int q)

  {
  	return ((chan_hdr)->ch_space_offset +
  	       ((q) * sizeof(struct signal_queue_header)));
  }

  /*
   * Return offset of a specific queue entry (data) from the beginning of a
   * channel header

   */

  static int sig_data_offset(struct channel_header *chan_hdr, int q,
  			   struct signal_queue_header *sig_hdr, int slot)

  {
  	return (sig_queue_offset(chan_hdr, q) + sig_hdr->sig_base_offset +
  	       (slot * sig_hdr->signal_size));
  }

  /*

   * Write the contents of a specific field within a SIGNAL_QUEUE_HEADER back into
   * host memory

   */

  #define SIG_WRITE_FIELD(channel, queue, sig_hdr, FIELD) \
  	visorchannel_write(channel, \

  			   sig_queue_offset(&channel->chan_hdr, queue) + \

  			   offsetof(struct signal_queue_header, FIELD), \

  			   &((sig_hdr)->FIELD), \

  			   sizeof((sig_hdr)->FIELD))

  static int sig_read_header(struct visorchannel *channel, u32 queue,
  			   struct signal_queue_header *sig_hdr)

  {

  	if (channel->chan_hdr.ch_space_offset < sizeof(struct channel_header))

  		return -EINVAL;

  
  	/* Read the appropriate SIGNAL_QUEUE_HEADER into local memory. */

  	return visorchannel_read(channel,

  				 sig_queue_offset(&channel->chan_hdr, queue),

  				 sig_hdr, sizeof(struct signal_queue_header));

  }

  static int sig_read_data(struct visorchannel *channel, u32 queue,
  			 struct signal_queue_header *sig_hdr, u32 slot,
  			 void *data)

  {

  	int signal_data_offset = sig_data_offset(&channel->chan_hdr, queue,

  						 sig_hdr, slot);

  	return visorchannel_read(channel, signal_data_offset,
  				 data, sig_hdr->signal_size);

  }

  static int sig_write_data(struct visorchannel *channel, u32 queue,
  			  struct signal_queue_header *sig_hdr, u32 slot,
  			  void *data)

  {

  	int signal_data_offset = sig_data_offset(&channel->chan_hdr, queue,

  						 sig_hdr, slot);

  	return visorchannel_write(channel, signal_data_offset,
  				  data, sig_hdr->signal_size);

  }

  static int signalremove_inner(struct visorchannel *channel, u32 queue,
  			      void *msg)

  {

  	struct signal_queue_header sig_hdr;

  	int error;
  
  	error = sig_read_header(channel, queue, &sig_hdr);
  	if (error)
  		return error;

  	/* No signals to remove; have caller try again. */

  	if (sig_hdr.head == sig_hdr.tail)

  		return -EAGAIN;

  	sig_hdr.tail = (sig_hdr.tail + 1) % sig_hdr.max_slots;

  	error = sig_read_data(channel, queue, &sig_hdr, sig_hdr.tail, msg);
  	if (error)
  		return error;

  	sig_hdr.num_received++;

  	/*

  	 * For each data field in SIGNAL_QUEUE_HEADER that was modified, update
  	 * host memory. Required for channel sync.

  	 */

  	mb();

  	error = SIG_WRITE_FIELD(channel, queue, &sig_hdr, tail);
  	if (error)
  		return error;
  	error = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_received);
  	if (error)
  		return error;

  	return 0;

  }

  /**
   * visorchannel_signalremove() - removes a message from the designated
   *                               channel/queue
   * @channel: the channel the message will be removed from
   * @queue:   the queue the message will be removed from
   * @msg:     the message to remove
   *

   * Return: integer error code indicating the status of the removal

   */

  int visorchannel_signalremove(struct visorchannel *channel, u32 queue,
  			      void *msg)

  {

  	int rc;

  	unsigned long flags;

  
  	if (channel->needs_lock) {

  		spin_lock_irqsave(&channel->remove_lock, flags);

  		rc = signalremove_inner(channel, queue, msg);

  		spin_unlock_irqrestore(&channel->remove_lock, flags);

  	} else {
  		rc = signalremove_inner(channel, queue, msg);
  	}

  	return rc;

  }
  EXPORT_SYMBOL_GPL(visorchannel_signalremove);

  static bool queue_empty(struct visorchannel *channel, u32 queue)

  {
  	struct signal_queue_header sig_hdr;
  
  	if (sig_read_header(channel, queue, &sig_hdr))
  		return true;

  	return (sig_hdr.head == sig_hdr.tail);
  }

  /**

   * visorchannel_signalempty() - checks if the designated channel/queue contains
   *				any messages

   * @channel: the channel to query
   * @queue:   the queue in the channel to query
   *
   * Return: boolean indicating whether any messages in the designated
   *         channel/queue are present
   */

  bool visorchannel_signalempty(struct visorchannel *channel, u32 queue)

  {

  	bool rc;
  	unsigned long flags;

  	if (!channel->needs_lock)
  		return queue_empty(channel, queue);

  	spin_lock_irqsave(&channel->remove_lock, flags);
  	rc = queue_empty(channel, queue);
  	spin_unlock_irqrestore(&channel->remove_lock, flags);

  	return rc;
  }
  EXPORT_SYMBOL_GPL(visorchannel_signalempty);

  static int signalinsert_inner(struct visorchannel *channel, u32 queue,
  			      void *msg)

  {

  	struct signal_queue_header sig_hdr;

  	int err;

  	err = sig_read_header(channel, queue, &sig_hdr);
  	if (err)
  		return err;

  	sig_hdr.head = (sig_hdr.head + 1) % sig_hdr.max_slots;

  	if (sig_hdr.head == sig_hdr.tail) {
  		sig_hdr.num_overflows++;

  		err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_overflows);
  		if (err)
  			return err;

  		return -EIO;

  	}

  	err = sig_write_data(channel, queue, &sig_hdr, sig_hdr.head, msg);
  	if (err)
  		return err;

  	sig_hdr.num_sent++;

  	/*

  	 * For each data field in SIGNAL_QUEUE_HEADER that was modified, update
  	 * host memory. Required for channel sync.

  	 */

  	mb();

  	err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, head);
  	if (err)
  		return err;
  	err = SIG_WRITE_FIELD(channel, queue, &sig_hdr, num_sent);
  	if (err)
  		return err;

  	return 0;

  }

  /*

   * visorchannel_create() - creates the struct visorchannel abstraction for a
   *                         data area in memory, but does NOT modify this data
   *                         area

   * @physaddr:      physical address of start of channel

   * @gfp:           gfp_t to use when allocating memory for the data struct

   * @guid:          GUID that identifies channel type;

   * @needs_lock:    must specify true if you have multiple threads of execution
   *                 that will be calling visorchannel methods of this
   *                 visorchannel at the same time
   *
   * Return: pointer to visorchannel that was created if successful,
   *         otherwise NULL
   */

  struct visorchannel *visorchannel_create(u64 physaddr, gfp_t gfp,
  					 const guid_t *guid, bool needs_lock)

  {
  	struct visorchannel *channel;
  	int err;
  	size_t size = sizeof(struct channel_header);
  
  	if (physaddr == 0)
  		return NULL;
  
  	channel = kzalloc(sizeof(*channel), gfp);
  	if (!channel)
  		return NULL;

  	channel->needs_lock = needs_lock;
  	spin_lock_init(&channel->insert_lock);
  	spin_lock_init(&channel->remove_lock);

  	/*

  	 * Video driver constains the efi framebuffer so it will get a conflict
  	 * resource when requesting its full mem region. Since we are only
  	 * using the efi framebuffer for video we can ignore this. Remember that
  	 * we haven't requested it so we don't try to release later on.

  	 */

  	channel->requested = request_mem_region(physaddr, size, VISOR_DRV_NAME);

  	if (!channel->requested && !guid_equal(guid, &visor_video_guid))

  		/* we only care about errors if this is not the video channel */
  		goto err_destroy_channel;

  	channel->mapped = memremap(physaddr, size, MEMREMAP_WB);
  	if (!channel->mapped) {
  		release_mem_region(physaddr, size);
  		goto err_destroy_channel;
  	}

  	channel->physaddr = physaddr;
  	channel->nbytes = size;

  	err = visorchannel_read(channel, 0, &channel->chan_hdr, size);

  	if (err)
  		goto err_destroy_channel;

  	size = (ulong)channel->chan_hdr.size;

  	memunmap(channel->mapped);
  	if (channel->requested)
  		release_mem_region(channel->physaddr, channel->nbytes);
  	channel->mapped = NULL;

  	channel->requested = request_mem_region(channel->physaddr, size,
  						VISOR_DRV_NAME);

  	if (!channel->requested && !guid_equal(guid, &visor_video_guid))

  		/* we only care about errors if this is not the video channel */
  		goto err_destroy_channel;

  	channel->mapped = memremap(channel->physaddr, size, MEMREMAP_WB);

  	if (!channel->mapped) {

  		release_mem_region(channel->physaddr, size);

  		goto err_destroy_channel;
  	}

  	channel->nbytes = size;

  	guid_copy(&channel->guid, guid);

  	return channel;
  
  err_destroy_channel:
  	visorchannel_destroy(channel);
  	return NULL;
  }

  /**

   * visorchannel_signalinsert() - inserts a message into the designated
   *                               channel/queue
   * @channel: the channel the message will be added to
   * @queue:   the queue the message will be added to
   * @msg:     the message to insert
   *

   * Return: integer error code indicating the status of the insertion

   */

  int visorchannel_signalinsert(struct visorchannel *channel, u32 queue,
  			      void *msg)

  {

  	int rc;

  	unsigned long flags;

  
  	if (channel->needs_lock) {

  		spin_lock_irqsave(&channel->insert_lock, flags);

  		rc = signalinsert_inner(channel, queue, msg);

  		spin_unlock_irqrestore(&channel->insert_lock, flags);

  	} else {
  		rc = signalinsert_inner(channel, queue, msg);
  	}

  	return rc;

  }
  EXPORT_SYMBOL_GPL(visorchannel_signalinsert);