forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
496 lines
17 KiB
496 lines
17 KiB
/* SPDX-License-Identifier: GPL-2.0 */ |
|
/* |
|
* drivers/s390/net/iucv.h |
|
* IUCV base support. |
|
* |
|
* S390 version |
|
* Copyright 2000, 2006 IBM Corporation |
|
* Author(s):Alan Altmark ([email protected]) |
|
* Xenia Tkatschow ([email protected]) |
|
* Rewritten for af_iucv: |
|
* Martin Schwidefsky <[email protected]> |
|
* |
|
* |
|
* Functionality: |
|
* To explore any of the IUCV functions, one must first register their |
|
* program using iucv_register(). Once your program has successfully |
|
* completed a register, it can exploit the other functions. |
|
* For furthur reference on all IUCV functionality, refer to the |
|
* CP Programming Services book, also available on the web thru |
|
* www.vm.ibm.com/pubs, manual # SC24-6084 |
|
* |
|
* Definition of Return Codes |
|
* - All positive return codes including zero are reflected back |
|
* from CP. The definition of each return code can be found in |
|
* CP Programming Services book. |
|
* - Return Code of: |
|
* -EINVAL: Invalid value |
|
* -ENOMEM: storage allocation failed |
|
*/ |
|
|
|
#include <linux/types.h> |
|
#include <linux/slab.h> |
|
#include <asm/debug.h> |
|
|
|
/* |
|
* IUCV option flags usable by device drivers: |
|
* |
|
* IUCV_IPRMDATA Indicates that your program can handle a message in the |
|
* parameter list / a message is sent in the parameter list. |
|
* Used for iucv_path_accept, iucv_path_connect, |
|
* iucv_message_reply, iucv_message_send, iucv_message_send2way. |
|
* IUCV_IPQUSCE Indicates that you do not want to receive messages on this |
|
* path until an iucv_path_resume is issued. |
|
* Used for iucv_path_accept, iucv_path_connect. |
|
* IUCV_IPBUFLST Indicates that an address list is used for the message data. |
|
* Used for iucv_message_receive, iucv_message_send, |
|
* iucv_message_send2way. |
|
* IUCV_IPPRTY Specifies that you want to send priority messages. |
|
* Used for iucv_path_accept, iucv_path_connect, |
|
* iucv_message_reply, iucv_message_send, iucv_message_send2way. |
|
* IUCV_IPSYNC Indicates a synchronous send request. |
|
* Used for iucv_message_send, iucv_message_send2way. |
|
* IUCV_IPANSLST Indicates that an address list is used for the reply data. |
|
* Used for iucv_message_reply, iucv_message_send2way. |
|
* IUCV_IPLOCAL Specifies that the communication partner has to be on the |
|
* local system. If local is specified no target class can be |
|
* specified. |
|
* Used for iucv_path_connect. |
|
* |
|
* All flags are defined in the input field IPFLAGS1 of each function |
|
* and can be found in CP Programming Services. |
|
*/ |
|
#define IUCV_IPRMDATA 0x80 |
|
#define IUCV_IPQUSCE 0x40 |
|
#define IUCV_IPBUFLST 0x40 |
|
#define IUCV_IPPRTY 0x20 |
|
#define IUCV_IPANSLST 0x08 |
|
#define IUCV_IPSYNC 0x04 |
|
#define IUCV_IPLOCAL 0x01 |
|
|
|
/* |
|
* iucv_array : Defines buffer array. |
|
* Inside the array may be 31- bit addresses and 31-bit lengths. |
|
* Use a pointer to an iucv_array as the buffer, reply or answer |
|
* parameter on iucv_message_send, iucv_message_send2way, iucv_message_receive |
|
* and iucv_message_reply if IUCV_IPBUFLST or IUCV_IPANSLST are used. |
|
*/ |
|
struct iucv_array { |
|
u32 address; |
|
u32 length; |
|
} __attribute__ ((aligned (8))); |
|
|
|
extern struct bus_type iucv_bus; |
|
extern struct device *iucv_root; |
|
|
|
/* |
|
* struct iucv_path |
|
* pathid: 16 bit path identification |
|
* msglim: 16 bit message limit |
|
* flags: properties of the path: IPRMDATA, IPQUSCE, IPPRTY |
|
* handler: address of iucv handler structure |
|
* private: private information of the handler associated with the path |
|
* list: list_head for the iucv_handler path list. |
|
*/ |
|
struct iucv_path { |
|
u16 pathid; |
|
u16 msglim; |
|
u8 flags; |
|
void *private; |
|
struct iucv_handler *handler; |
|
struct list_head list; |
|
}; |
|
|
|
/* |
|
* struct iucv_message |
|
* id: 32 bit message id |
|
* audit: 32 bit error information of purged or replied messages |
|
* class: 32 bit target class of a message (source class for replies) |
|
* tag: 32 bit tag to be associated with the message |
|
* length: 32 bit length of the message / reply |
|
* reply_size: 32 bit maximum allowed length of the reply |
|
* rmmsg: 8 byte inline message |
|
* flags: message properties (IUCV_IPPRTY) |
|
*/ |
|
struct iucv_message { |
|
u32 id; |
|
u32 audit; |
|
u32 class; |
|
u32 tag; |
|
u32 length; |
|
u32 reply_size; |
|
u8 rmmsg[8]; |
|
u8 flags; |
|
} __packed; |
|
|
|
/* |
|
* struct iucv_handler |
|
* |
|
* A vector of functions that handle IUCV interrupts. Each functions gets |
|
* a parameter area as defined by the CP Programming Services and private |
|
* pointer that is provided by the user of the interface. |
|
*/ |
|
struct iucv_handler { |
|
/* |
|
* The path_pending function is called after an iucv interrupt |
|
* type 0x01 has been received. The base code allocates a path |
|
* structure and "asks" the handler if this path belongs to the |
|
* handler. To accept the path the path_pending function needs |
|
* to call iucv_path_accept and return 0. If the callback returns |
|
* a value != 0 the iucv base code will continue with the next |
|
* handler. The order in which the path_pending functions are |
|
* called is the order of the registration of the iucv handlers |
|
* to the base code. |
|
*/ |
|
int (*path_pending)(struct iucv_path *, u8 *ipvmid, u8 *ipuser); |
|
/* |
|
* The path_complete function is called after an iucv interrupt |
|
* type 0x02 has been received for a path that has been established |
|
* for this handler with iucv_path_connect and got accepted by the |
|
* peer with iucv_path_accept. |
|
*/ |
|
void (*path_complete)(struct iucv_path *, u8 *ipuser); |
|
/* |
|
* The path_severed function is called after an iucv interrupt |
|
* type 0x03 has been received. The communication peer shutdown |
|
* his end of the communication path. The path still exists and |
|
* remaining messages can be received until a iucv_path_sever |
|
* shuts down the other end of the path as well. |
|
*/ |
|
void (*path_severed)(struct iucv_path *, u8 *ipuser); |
|
/* |
|
* The path_quiesced function is called after an icuv interrupt |
|
* type 0x04 has been received. The communication peer has quiesced |
|
* the path. Delivery of messages is stopped until iucv_path_resume |
|
* has been called. |
|
*/ |
|
void (*path_quiesced)(struct iucv_path *, u8 *ipuser); |
|
/* |
|
* The path_resumed function is called after an icuv interrupt |
|
* type 0x05 has been received. The communication peer has resumed |
|
* the path. |
|
*/ |
|
void (*path_resumed)(struct iucv_path *, u8 *ipuser); |
|
/* |
|
* The message_pending function is called after an icuv interrupt |
|
* type 0x06 or type 0x07 has been received. A new message is |
|
* available and can be received with iucv_message_receive. |
|
*/ |
|
void (*message_pending)(struct iucv_path *, struct iucv_message *); |
|
/* |
|
* The message_complete function is called after an icuv interrupt |
|
* type 0x08 or type 0x09 has been received. A message send with |
|
* iucv_message_send2way has been replied to. The reply can be |
|
* received with iucv_message_receive. |
|
*/ |
|
void (*message_complete)(struct iucv_path *, struct iucv_message *); |
|
|
|
struct list_head list; |
|
struct list_head paths; |
|
}; |
|
|
|
/** |
|
* iucv_register: |
|
* @handler: address of iucv handler structure |
|
* @smp: != 0 indicates that the handler can deal with out of order messages |
|
* |
|
* Registers a driver with IUCV. |
|
* |
|
* Returns 0 on success, -ENOMEM if the memory allocation for the pathid |
|
* table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus. |
|
*/ |
|
int iucv_register(struct iucv_handler *handler, int smp); |
|
|
|
/** |
|
* iucv_unregister |
|
* @handler: address of iucv handler structure |
|
* @smp: != 0 indicates that the handler can deal with out of order messages |
|
* |
|
* Unregister driver from IUCV. |
|
*/ |
|
void iucv_unregister(struct iucv_handler *handle, int smp); |
|
|
|
/** |
|
* iucv_path_alloc |
|
* @msglim: initial message limit |
|
* @flags: initial flags |
|
* @gfp: kmalloc allocation flag |
|
* |
|
* Allocate a new path structure for use with iucv_connect. |
|
* |
|
* Returns NULL if the memory allocation failed or a pointer to the |
|
* path structure. |
|
*/ |
|
static inline struct iucv_path *iucv_path_alloc(u16 msglim, u8 flags, gfp_t gfp) |
|
{ |
|
struct iucv_path *path; |
|
|
|
path = kzalloc(sizeof(struct iucv_path), gfp); |
|
if (path) { |
|
path->msglim = msglim; |
|
path->flags = flags; |
|
} |
|
return path; |
|
} |
|
|
|
/** |
|
* iucv_path_free |
|
* @path: address of iucv path structure |
|
* |
|
* Frees a path structure. |
|
*/ |
|
static inline void iucv_path_free(struct iucv_path *path) |
|
{ |
|
kfree(path); |
|
} |
|
|
|
/** |
|
* iucv_path_accept |
|
* @path: address of iucv path structure |
|
* @handler: address of iucv handler structure |
|
* @userdata: 16 bytes of data reflected to the communication partner |
|
* @private: private data passed to interrupt handlers for this path |
|
* |
|
* This function is issued after the user received a connection pending |
|
* external interrupt and now wishes to complete the IUCV communication path. |
|
* |
|
* Returns the result of the CP IUCV call. |
|
*/ |
|
int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler, |
|
u8 *userdata, void *private); |
|
|
|
/** |
|
* iucv_path_connect |
|
* @path: address of iucv path structure |
|
* @handler: address of iucv handler structure |
|
* @userid: 8-byte user identification |
|
* @system: 8-byte target system identification |
|
* @userdata: 16 bytes of data reflected to the communication partner |
|
* @private: private data passed to interrupt handlers for this path |
|
* |
|
* This function establishes an IUCV path. Although the connect may complete |
|
* successfully, you are not able to use the path until you receive an IUCV |
|
* Connection Complete external interrupt. |
|
* |
|
* Returns the result of the CP IUCV call. |
|
*/ |
|
int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler, |
|
u8 *userid, u8 *system, u8 *userdata, |
|
void *private); |
|
|
|
/** |
|
* iucv_path_quiesce: |
|
* @path: address of iucv path structure |
|
* @userdata: 16 bytes of data reflected to the communication partner |
|
* |
|
* This function temporarily suspends incoming messages on an IUCV path. |
|
* You can later reactivate the path by invoking the iucv_resume function. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_path_quiesce(struct iucv_path *path, u8 *userdata); |
|
|
|
/** |
|
* iucv_path_resume: |
|
* @path: address of iucv path structure |
|
* @userdata: 16 bytes of data reflected to the communication partner |
|
* |
|
* This function resumes incoming messages on an IUCV path that has |
|
* been stopped with iucv_path_quiesce. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_path_resume(struct iucv_path *path, u8 *userdata); |
|
|
|
/** |
|
* iucv_path_sever |
|
* @path: address of iucv path structure |
|
* @userdata: 16 bytes of data reflected to the communication partner |
|
* |
|
* This function terminates an IUCV path. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_path_sever(struct iucv_path *path, u8 *userdata); |
|
|
|
/** |
|
* iucv_message_purge |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @srccls: source class of message |
|
* |
|
* Cancels a message you have sent. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg, |
|
u32 srccls); |
|
|
|
/** |
|
* iucv_message_receive |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: flags that affect how the message is received (IUCV_IPBUFLST) |
|
* @buffer: address of data buffer or address of struct iucv_array |
|
* @size: length of data buffer |
|
* @residual: |
|
* |
|
* This function receives messages that are being sent to you over |
|
* established paths. This function will deal with RMDATA messages |
|
* embedded in struct iucv_message as well. |
|
* |
|
* Locking: local_bh_enable/local_bh_disable |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, void *buffer, size_t size, size_t *residual); |
|
|
|
/** |
|
* __iucv_message_receive |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: flags that affect how the message is received (IUCV_IPBUFLST) |
|
* @buffer: address of data buffer or address of struct iucv_array |
|
* @size: length of data buffer |
|
* @residual: |
|
* |
|
* This function receives messages that are being sent to you over |
|
* established paths. This function will deal with RMDATA messages |
|
* embedded in struct iucv_message as well. |
|
* |
|
* Locking: no locking. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, void *buffer, size_t size, |
|
size_t *residual); |
|
|
|
/** |
|
* iucv_message_reject |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* |
|
* The reject function refuses a specified message. Between the time you |
|
* are notified of a message and the time that you complete the message, |
|
* the message may be rejected. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg); |
|
|
|
/** |
|
* iucv_message_reply |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) |
|
* @reply: address of data buffer or address of struct iucv_array |
|
* @size: length of reply data buffer |
|
* |
|
* This function responds to the two-way messages that you receive. You |
|
* must identify completely the message to which you wish to reply. ie, |
|
* pathid, msgid, and trgcls. Prmmsg signifies the data is moved into |
|
* the parameter list. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, void *reply, size_t size); |
|
|
|
/** |
|
* iucv_message_send |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) |
|
* @srccls: source class of message |
|
* @buffer: address of data buffer or address of struct iucv_array |
|
* @size: length of send buffer |
|
* |
|
* This function transmits data to another application. Data to be |
|
* transmitted is in a buffer and this is a one-way message and the |
|
* receiver will not reply to the message. |
|
* |
|
* Locking: local_bh_enable/local_bh_disable |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_send(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, u32 srccls, void *buffer, size_t size); |
|
|
|
/** |
|
* __iucv_message_send |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) |
|
* @srccls: source class of message |
|
* @buffer: address of data buffer or address of struct iucv_array |
|
* @size: length of send buffer |
|
* |
|
* This function transmits data to another application. Data to be |
|
* transmitted is in a buffer and this is a one-way message and the |
|
* receiver will not reply to the message. |
|
* |
|
* Locking: no locking. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, u32 srccls, void *buffer, size_t size); |
|
|
|
/** |
|
* iucv_message_send2way |
|
* @path: address of iucv path structure |
|
* @msg: address of iucv msg structure |
|
* @flags: how the message is sent and the reply is received |
|
* (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST) |
|
* @srccls: source class of message |
|
* @buffer: address of data buffer or address of struct iucv_array |
|
* @size: length of send buffer |
|
* @ansbuf: address of answer buffer or address of struct iucv_array |
|
* @asize: size of reply buffer |
|
* |
|
* This function transmits data to another application. Data to be |
|
* transmitted is in a buffer. The receiver of the send is expected to |
|
* reply to the message and a buffer is provided into which IUCV moves |
|
* the reply to this message. |
|
* |
|
* Returns the result from the CP IUCV call. |
|
*/ |
|
int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, u32 srccls, void *buffer, size_t size, |
|
void *answer, size_t asize, size_t *residual); |
|
|
|
struct iucv_interface { |
|
int (*message_receive)(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, void *buffer, size_t size, size_t *residual); |
|
int (*__message_receive)(struct iucv_path *path, |
|
struct iucv_message *msg, u8 flags, void *buffer, size_t size, |
|
size_t *residual); |
|
int (*message_reply)(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, void *reply, size_t size); |
|
int (*message_reject)(struct iucv_path *path, struct iucv_message *msg); |
|
int (*message_send)(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, u32 srccls, void *buffer, size_t size); |
|
int (*__message_send)(struct iucv_path *path, struct iucv_message *msg, |
|
u8 flags, u32 srccls, void *buffer, size_t size); |
|
int (*message_send2way)(struct iucv_path *path, |
|
struct iucv_message *msg, u8 flags, u32 srccls, void *buffer, |
|
size_t size, void *answer, size_t asize, size_t *residual); |
|
int (*message_purge)(struct iucv_path *path, struct iucv_message *msg, |
|
u32 srccls); |
|
int (*path_accept)(struct iucv_path *path, struct iucv_handler *handler, |
|
u8 userdata[16], void *private); |
|
int (*path_connect)(struct iucv_path *path, |
|
struct iucv_handler *handler, |
|
u8 userid[8], u8 system[8], u8 userdata[16], void *private); |
|
int (*path_quiesce)(struct iucv_path *path, u8 userdata[16]); |
|
int (*path_resume)(struct iucv_path *path, u8 userdata[16]); |
|
int (*path_sever)(struct iucv_path *path, u8 userdata[16]); |
|
int (*iucv_register)(struct iucv_handler *handler, int smp); |
|
void (*iucv_unregister)(struct iucv_handler *handler, int smp); |
|
struct bus_type *bus; |
|
struct device *root; |
|
}; |
|
|
|
extern struct iucv_interface iucv_if;
|
|
|