Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230/* SPDX-License-Identifier: GPL-2.0 *//* * Greybus operations * * Copyright 2014 Google Inc. * Copyright 2014 Linaro Ltd. */
#ifndef __OPERATION_H#define __OPERATION_H
#include <linux/completion.h>#include <linux/kref.h>#include <linux/timer.h>#include <linux/types.h>#include <linux/workqueue.h>
struct gb_host_device;struct gb_operation;
/* The default amount of time a request is given to complete */#define GB_OPERATION_TIMEOUT_DEFAULT 1000 /* milliseconds */
/* * The top bit of the type in an operation message header indicates * whether the message is a request (bit clear) or response (bit set) */#define GB_MESSAGE_TYPE_RESPONSE ((u8)0x80)
enum gb_operation_result { GB_OP_SUCCESS = 0x00, GB_OP_INTERRUPTED = 0x01, GB_OP_TIMEOUT = 0x02, GB_OP_NO_MEMORY = 0x03, GB_OP_PROTOCOL_BAD = 0x04, GB_OP_OVERFLOW = 0x05, GB_OP_INVALID = 0x06, GB_OP_RETRY = 0x07, GB_OP_NONEXISTENT = 0x08, GB_OP_UNKNOWN_ERROR = 0xfe, GB_OP_MALFUNCTION = 0xff,};
#define GB_OPERATION_MESSAGE_SIZE_MIN sizeof(struct gb_operation_msg_hdr)#define GB_OPERATION_MESSAGE_SIZE_MAX U16_MAX
/* * Protocol code should only examine the payload and payload_size fields, and * host-controller drivers may use the hcpriv field. All other fields are * intended to be private to the operations core code. */struct gb_message { struct gb_operation *operation; struct gb_operation_msg_hdr *header;
void *payload; size_t payload_size;
void *buffer;
void *hcpriv;};
#define GB_OPERATION_FLAG_INCOMING BIT(0)#define GB_OPERATION_FLAG_UNIDIRECTIONAL BIT(1)#define GB_OPERATION_FLAG_SHORT_RESPONSE BIT(2)#define GB_OPERATION_FLAG_CORE BIT(3)
#define GB_OPERATION_FLAG_USER_MASK (GB_OPERATION_FLAG_SHORT_RESPONSE | \ GB_OPERATION_FLAG_UNIDIRECTIONAL)
/* * A Greybus operation is a remote procedure call performed over a * connection between two UniPro interfaces. * * Every operation consists of a request message sent to the other * end of the connection coupled with a reply message returned to * the sender. Every operation has a type, whose interpretation is * dependent on the protocol associated with the connection. * * Only four things in an operation structure are intended to be * directly usable by protocol handlers: the operation's connection * pointer; the operation type; the request message payload (and * size); and the response message payload (and size). Note that a * message with a 0-byte payload has a null message payload pointer. * * In addition, every operation has a result, which is an errno * value. Protocol handlers access the operation result using * gb_operation_result(). */typedef void (*gb_operation_callback)(struct gb_operation *);struct gb_operation { struct gb_connection *connection; struct gb_message *request; struct gb_message *response;
unsigned long flags; u8 type; u16 id; int errno; /* Operation result */
struct work_struct work; gb_operation_callback callback; struct completion completion; struct timer_list timer;
struct kref kref; atomic_t waiters;
int active; struct list_head links; /* connection->operations */
void *private;};
static inline boolgb_operation_is_incoming(struct gb_operation *operation){ return operation->flags & GB_OPERATION_FLAG_INCOMING;}
static inline boolgb_operation_is_unidirectional(struct gb_operation *operation){ return operation->flags & GB_OPERATION_FLAG_UNIDIRECTIONAL;}
static inline boolgb_operation_short_response_allowed(struct gb_operation *operation){ return operation->flags & GB_OPERATION_FLAG_SHORT_RESPONSE;}
static inline bool gb_operation_is_core(struct gb_operation *operation){ return operation->flags & GB_OPERATION_FLAG_CORE;}
void gb_connection_recv(struct gb_connection *connection, void *data, size_t size);
int gb_operation_result(struct gb_operation *operation);
size_t gb_operation_get_payload_size_max(struct gb_connection *connection);struct gb_operation *gb_operation_create_flags(struct gb_connection *connection, u8 type, size_t request_size, size_t response_size, unsigned long flags, gfp_t gfp);
static inline struct gb_operation *gb_operation_create(struct gb_connection *connection, u8 type, size_t request_size, size_t response_size, gfp_t gfp){ return gb_operation_create_flags(connection, type, request_size, response_size, 0, gfp);}
struct gb_operation *gb_operation_create_core(struct gb_connection *connection, u8 type, size_t request_size, size_t response_size, unsigned long flags, gfp_t gfp);
void gb_operation_get(struct gb_operation *operation);void gb_operation_put(struct gb_operation *operation);
bool gb_operation_response_alloc(struct gb_operation *operation, size_t response_size, gfp_t gfp);
int gb_operation_request_send(struct gb_operation *operation, gb_operation_callback callback, unsigned int timeout, gfp_t gfp);int gb_operation_request_send_sync_timeout(struct gb_operation *operation, unsigned int timeout);static inline intgb_operation_request_send_sync(struct gb_operation *operation){ return gb_operation_request_send_sync_timeout(operation, GB_OPERATION_TIMEOUT_DEFAULT);}
void gb_operation_cancel(struct gb_operation *operation, int errno);void gb_operation_cancel_incoming(struct gb_operation *operation, int errno);
void greybus_message_sent(struct gb_host_device *hd, struct gb_message *message, int status);
int gb_operation_sync_timeout(struct gb_connection *connection, int type, void *request, int request_size, void *response, int response_size, unsigned int timeout);int gb_operation_unidirectional_timeout(struct gb_connection *connection, int type, void *request, int request_size, unsigned int timeout);
static inline int gb_operation_sync(struct gb_connection *connection, int type, void *request, int request_size, void *response, int response_size){ return gb_operation_sync_timeout(connection, type, request, request_size, response, response_size, GB_OPERATION_TIMEOUT_DEFAULT);}
static inline int gb_operation_unidirectional(struct gb_connection *connection, int type, void *request, int request_size){ return gb_operation_unidirectional_timeout(connection, type, request, request_size, GB_OPERATION_TIMEOUT_DEFAULT);}
static inline void *gb_operation_get_data(struct gb_operation *operation){ return operation->private;}
static inline void gb_operation_set_data(struct gb_operation *operation, void *data){ operation->private = data;}
int gb_operation_init(void);void gb_operation_exit(void);
#endif /* !__OPERATION_H */