drivers/visorbus/visorchannel.c - linux - Git at Google

 // 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);
	// 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);