greybus: operation: create gb_operation_sync for sending "simple" messages

[mirror_ubuntu-bionic-kernel.git] / drivers / staging / greybus / operation.h

/*
 * Greybus operations
 *
 * Copyright 2014 Google Inc.
 *
 * Released under the GPLv2 only.
 */

#ifndef __OPERATION_H
#define __OPERATION_H

#include <linux/completion.h>

struct gb_operation;

enum gb_operation_result {
	GB_OP_SUCCESS		= 0,
	GB_OP_INVALID		= 1,
	GB_OP_NO_MEMORY		= 2,
	GB_OP_INTERRUPTED	= 3,
	GB_OP_RETRY		= 4,
	GB_OP_PROTOCOL_BAD	= 5,
	GB_OP_OVERFLOW		= 6,
	GB_OP_TIMEOUT		= 0xff,
};

struct gb_message {
	struct gb_operation_msg_hdr	*header;
	void				*payload;
	size_t				size;	/* header + payload */
	struct gb_operation		*operation;

	void				*cookie;

	u8				buffer[];
};

/*
 * A Greybus operation is a remote procedure call performed over a
 * connection between the AP and a function on Greybus module.
 * Every operation consists of a request message sent to the other
 * end of the connection coupled with a reply returned to the
 * sender.
 *
 * The state for managing active requests on a connection is held in
 * the connection structure.
 *
 * YADA YADA
 *
 * submitting each request and providing its matching response to
 * the caller when it arrives.  Operations normally complete
 * asynchronously, and when an operation's response arrives its
 * callback function is executed.  The callback pointer is supplied
 * at the time the operation is submitted; a null callback pointer
 * causes synchronous operation--the caller is blocked until
 * the response arrives.  In addition, it is possible to await
 * the completion of a submitted asynchronous operation.
 *
 * A Greybus device operation includes a Greybus buffer to hold the
 * data sent to the device.  The only field within a Greybus
 * operation that should be used by a caller is the payload pointer,
 * which should be used to populate the request data.  This pointer
 * is guaranteed to be 64-bit aligned.
 * XXX and callback?
 */
typedef void (*gb_operation_callback)(struct gb_operation *);
struct gb_operation {
	struct gb_connection	*connection;
	struct gb_message	*request;
	struct gb_message	*response;
	u16			id;

	int			errno;		/* Operation result */

	struct work_struct	work;
	gb_operation_callback	callback;	/* If asynchronous */
	struct completion	completion;	/* Used if no callback */
	struct delayed_work	timeout_work;

	struct kref		kref;
	struct list_head	links;	/* connection->{operations,pending} */
};

void gb_connection_recv(struct gb_connection *connection,
					void *data, size_t size);

struct gb_operation *gb_operation_create(struct gb_connection *connection,
					u8 type, size_t request_size,
					size_t response_size);
void gb_operation_get(struct gb_operation *operation);
void gb_operation_put(struct gb_operation *operation);
static inline void gb_operation_destroy(struct gb_operation *operation)
{
	gb_operation_put(operation);
}

int gb_operation_request_send(struct gb_operation *operation,
				gb_operation_callback callback);
int gb_operation_response_send(struct gb_operation *operation);

void gb_operation_cancel(struct gb_operation *operation, int errno);

int gb_operation_status_map(u8 status);

void greybus_data_sent(struct greybus_host_device *hd,
				void *header, int status);

int gb_operation_sync(struct gb_connection *connection, int type,
		      void *request, int request_size,
		      void *response, int response_size);

int gb_operation_init(void);
void gb_operation_exit(void);

#endif /* !__OPERATION_H */