![Greg Kroah-Hartman](/assets/img/avatar_default.png)
Now that the SPDX tag is in all greybus files, that identifies the license in a specific and legally-defined manner. So the extra GPL text wording can be removed as it is no longer needed at all. This is done on a quest to remove the 700+ different ways that files in the kernel describe the GPL license text. And there's unneeded stuff like the address (sometimes incorrect) for the FSF which is never needed. No copyright headers or other non-license-description text was removed. Cc: Vaibhav Hiremath <hvaibhav.linux@gmail.com> Reviewed-by: Alex Elder <elder@linaro.org> Acked-by: Vaibhav Agarwal <vaibhav.sr@gmail.com> Acked-by: David Lin <dtwlin@gmail.com> Acked-by: Johan Hovold <johan@kernel.org> Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Mark Greer <mgreer@animalcreek.com> Acked-by: Rui Miguel Silva <rmfrfs@gmail.com> Acked-by: "Bryan O'Donoghue" <pure.logic@nexus-software.ie> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
225 lines
6.4 KiB
C
225 lines
6.4 KiB
C
// 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>
|
|
|
|
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 bool
|
|
gb_operation_is_incoming(struct gb_operation *operation)
|
|
{
|
|
return operation->flags & GB_OPERATION_FLAG_INCOMING;
|
|
}
|
|
|
|
static inline bool
|
|
gb_operation_is_unidirectional(struct gb_operation *operation)
|
|
{
|
|
return operation->flags & GB_OPERATION_FLAG_UNIDIRECTIONAL;
|
|
}
|
|
|
|
static inline bool
|
|
gb_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 int
|
|
gb_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 */
|