blob: 0894ced31957cf64f992e4676fdd402056e2a39b [file] [log] [blame]
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001/*
2 * drivers/s390/net/iucv.h
3 * IUCV base support.
4 *
5 * S390 version
6 * Copyright 2000, 2006 IBM Corporation
7 * Author(s):Alan Altmark (Alan_Altmark@us.ibm.com)
8 * Xenia Tkatschow (xenia@us.ibm.com)
9 * Rewritten for af_iucv:
10 * Martin Schwidefsky <schwidefsky@de.ibm.com>
11 *
12 *
13 * Functionality:
14 * To explore any of the IUCV functions, one must first register their
15 * program using iucv_register(). Once your program has successfully
16 * completed a register, it can exploit the other functions.
17 * For furthur reference on all IUCV functionality, refer to the
18 * CP Programming Services book, also available on the web thru
Martin Schwidefsky04b090d2007-04-28 23:03:59 -070019 * www.vm.ibm.com/pubs, manual # SC24-6084
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080020 *
21 * Definition of Return Codes
22 * - All positive return codes including zero are reflected back
23 * from CP. The definition of each return code can be found in
24 * CP Programming Services book.
25 * - Return Code of:
26 * -EINVAL: Invalid value
27 * -ENOMEM: storage allocation failed
28 */
29
30#include <linux/types.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090031#include <linux/slab.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080032#include <asm/debug.h>
33
34/*
35 * IUCV option flags usable by device drivers:
36 *
37 * IUCV_IPRMDATA Indicates that your program can handle a message in the
38 * parameter list / a message is sent in the parameter list.
39 * Used for iucv_path_accept, iucv_path_connect,
40 * iucv_message_reply, iucv_message_send, iucv_message_send2way.
41 * IUCV_IPQUSCE Indicates that you do not want to receive messages on this
42 * path until an iucv_path_resume is issued.
43 * Used for iucv_path_accept, iucv_path_connect.
44 * IUCV_IPBUFLST Indicates that an address list is used for the message data.
45 * Used for iucv_message_receive, iucv_message_send,
46 * iucv_message_send2way.
47 * IUCV_IPPRTY Specifies that you want to send priority messages.
48 * Used for iucv_path_accept, iucv_path_connect,
49 * iucv_message_reply, iucv_message_send, iucv_message_send2way.
50 * IUCV_IPSYNC Indicates a synchronous send request.
51 * Used for iucv_message_send, iucv_message_send2way.
52 * IUCV_IPANSLST Indicates that an address list is used for the reply data.
53 * Used for iucv_message_reply, iucv_message_send2way.
54 * IUCV_IPLOCAL Specifies that the communication partner has to be on the
55 * local system. If local is specified no target class can be
56 * specified.
57 * Used for iucv_path_connect.
58 *
59 * All flags are defined in the input field IPFLAGS1 of each function
60 * and can be found in CP Programming Services.
61 */
62#define IUCV_IPRMDATA 0x80
63#define IUCV_IPQUSCE 0x40
64#define IUCV_IPBUFLST 0x40
65#define IUCV_IPPRTY 0x20
66#define IUCV_IPANSLST 0x08
67#define IUCV_IPSYNC 0x04
68#define IUCV_IPLOCAL 0x01
69
70/*
71 * iucv_array : Defines buffer array.
72 * Inside the array may be 31- bit addresses and 31-bit lengths.
73 * Use a pointer to an iucv_array as the buffer, reply or answer
74 * parameter on iucv_message_send, iucv_message_send2way, iucv_message_receive
75 * and iucv_message_reply if IUCV_IPBUFLST or IUCV_IPANSLST are used.
76 */
77struct iucv_array {
78 u32 address;
79 u32 length;
80} __attribute__ ((aligned (8)));
81
82extern struct bus_type iucv_bus;
83extern struct device *iucv_root;
84
85/*
86 * struct iucv_path
87 * pathid: 16 bit path identification
88 * msglim: 16 bit message limit
89 * flags: properties of the path: IPRMDATA, IPQUSCE, IPPRTY
90 * handler: address of iucv handler structure
91 * private: private information of the handler associated with the path
92 * list: list_head for the iucv_handler path list.
93 */
94struct iucv_path {
95 u16 pathid;
96 u16 msglim;
97 u8 flags;
98 void *private;
99 struct iucv_handler *handler;
100 struct list_head list;
101};
102
103/*
104 * struct iucv_message
105 * id: 32 bit message id
106 * audit: 32 bit error information of purged or replied messages
107 * class: 32 bit target class of a message (source class for replies)
108 * tag: 32 bit tag to be associated with the message
109 * length: 32 bit length of the message / reply
110 * reply_size: 32 bit maximum allowed length of the reply
111 * rmmsg: 8 byte inline message
112 * flags: message properties (IUCV_IPPRTY)
113 */
114struct iucv_message {
115 u32 id;
116 u32 audit;
117 u32 class;
118 u32 tag;
119 u32 length;
120 u32 reply_size;
121 u8 rmmsg[8];
122 u8 flags;
Frank Blaschka96d042a2011-08-08 01:33:49 +0000123} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800124
125/*
126 * struct iucv_handler
127 *
128 * A vector of functions that handle IUCV interrupts. Each functions gets
129 * a parameter area as defined by the CP Programming Services and private
130 * pointer that is provided by the user of the interface.
131 */
132struct iucv_handler {
133 /*
134 * The path_pending function is called after an iucv interrupt
135 * type 0x01 has been received. The base code allocates a path
136 * structure and "asks" the handler if this path belongs to the
137 * handler. To accept the path the path_pending function needs
138 * to call iucv_path_accept and return 0. If the callback returns
139 * a value != 0 the iucv base code will continue with the next
140 * handler. The order in which the path_pending functions are
141 * called is the order of the registration of the iucv handlers
142 * to the base code.
143 */
144 int (*path_pending)(struct iucv_path *, u8 ipvmid[8], u8 ipuser[16]);
145 /*
146 * The path_complete function is called after an iucv interrupt
147 * type 0x02 has been received for a path that has been established
148 * for this handler with iucv_path_connect and got accepted by the
149 * peer with iucv_path_accept.
150 */
151 void (*path_complete)(struct iucv_path *, u8 ipuser[16]);
152 /*
153 * The path_severed function is called after an iucv interrupt
154 * type 0x03 has been received. The communication peer shutdown
155 * his end of the communication path. The path still exists and
156 * remaining messages can be received until a iucv_path_sever
157 * shuts down the other end of the path as well.
158 */
159 void (*path_severed)(struct iucv_path *, u8 ipuser[16]);
160 /*
161 * The path_quiesced function is called after an icuv interrupt
162 * type 0x04 has been received. The communication peer has quiesced
163 * the path. Delivery of messages is stopped until iucv_path_resume
164 * has been called.
165 */
166 void (*path_quiesced)(struct iucv_path *, u8 ipuser[16]);
167 /*
168 * The path_resumed function is called after an icuv interrupt
169 * type 0x05 has been received. The communication peer has resumed
170 * the path.
171 */
172 void (*path_resumed)(struct iucv_path *, u8 ipuser[16]);
173 /*
174 * The message_pending function is called after an icuv interrupt
175 * type 0x06 or type 0x07 has been received. A new message is
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300176 * available and can be received with iucv_message_receive.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800177 */
178 void (*message_pending)(struct iucv_path *, struct iucv_message *);
179 /*
180 * The message_complete function is called after an icuv interrupt
181 * type 0x08 or type 0x09 has been received. A message send with
182 * iucv_message_send2way has been replied to. The reply can be
183 * received with iucv_message_receive.
184 */
185 void (*message_complete)(struct iucv_path *, struct iucv_message *);
186
187 struct list_head list;
188 struct list_head paths;
189};
190
191/**
192 * iucv_register:
193 * @handler: address of iucv handler structure
194 * @smp: != 0 indicates that the handler can deal with out of order messages
195 *
196 * Registers a driver with IUCV.
197 *
198 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid
199 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
200 */
201int iucv_register(struct iucv_handler *handler, int smp);
202
203/**
204 * iucv_unregister
205 * @handler: address of iucv handler structure
206 * @smp: != 0 indicates that the handler can deal with out of order messages
207 *
208 * Unregister driver from IUCV.
209 */
210void iucv_unregister(struct iucv_handler *handle, int smp);
211
212/**
213 * iucv_path_alloc
214 * @msglim: initial message limit
215 * @flags: initial flags
216 * @gfp: kmalloc allocation flag
217 *
218 * Allocate a new path structure for use with iucv_connect.
219 *
220 * Returns NULL if the memory allocation failed or a pointer to the
221 * path structure.
222 */
223static inline struct iucv_path *iucv_path_alloc(u16 msglim, u8 flags, gfp_t gfp)
224{
225 struct iucv_path *path;
226
227 path = kzalloc(sizeof(struct iucv_path), gfp);
228 if (path) {
229 path->msglim = msglim;
230 path->flags = flags;
231 }
232 return path;
233}
234
235/**
236 * iucv_path_free
237 * @path: address of iucv path structure
238 *
239 * Frees a path structure.
240 */
241static inline void iucv_path_free(struct iucv_path *path)
242{
243 kfree(path);
244}
245
246/**
247 * iucv_path_accept
248 * @path: address of iucv path structure
249 * @handler: address of iucv handler structure
250 * @userdata: 16 bytes of data reflected to the communication partner
251 * @private: private data passed to interrupt handlers for this path
252 *
253 * This function is issued after the user received a connection pending
254 * external interrupt and now wishes to complete the IUCV communication path.
255 *
256 * Returns the result of the CP IUCV call.
257 */
258int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
259 u8 userdata[16], void *private);
260
261/**
262 * iucv_path_connect
263 * @path: address of iucv path structure
264 * @handler: address of iucv handler structure
265 * @userid: 8-byte user identification
266 * @system: 8-byte target system identification
267 * @userdata: 16 bytes of data reflected to the communication partner
268 * @private: private data passed to interrupt handlers for this path
269 *
270 * This function establishes an IUCV path. Although the connect may complete
271 * successfully, you are not able to use the path until you receive an IUCV
272 * Connection Complete external interrupt.
273 *
274 * Returns the result of the CP IUCV call.
275 */
276int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
277 u8 userid[8], u8 system[8], u8 userdata[16],
278 void *private);
279
280/**
281 * iucv_path_quiesce:
282 * @path: address of iucv path structure
283 * @userdata: 16 bytes of data reflected to the communication partner
284 *
285 * This function temporarily suspends incoming messages on an IUCV path.
286 * You can later reactivate the path by invoking the iucv_resume function.
287 *
288 * Returns the result from the CP IUCV call.
289 */
290int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16]);
291
292/**
293 * iucv_path_resume:
294 * @path: address of iucv path structure
295 * @userdata: 16 bytes of data reflected to the communication partner
296 *
297 * This function resumes incoming messages on an IUCV path that has
298 * been stopped with iucv_path_quiesce.
299 *
300 * Returns the result from the CP IUCV call.
301 */
302int iucv_path_resume(struct iucv_path *path, u8 userdata[16]);
303
304/**
305 * iucv_path_sever
306 * @path: address of iucv path structure
307 * @userdata: 16 bytes of data reflected to the communication partner
308 *
309 * This function terminates an IUCV path.
310 *
311 * Returns the result from the CP IUCV call.
312 */
313int iucv_path_sever(struct iucv_path *path, u8 userdata[16]);
314
315/**
316 * iucv_message_purge
317 * @path: address of iucv path structure
318 * @msg: address of iucv msg structure
319 * @srccls: source class of message
320 *
321 * Cancels a message you have sent.
322 *
323 * Returns the result from the CP IUCV call.
324 */
325int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
326 u32 srccls);
327
328/**
329 * iucv_message_receive
330 * @path: address of iucv path structure
331 * @msg: address of iucv msg structure
332 * @flags: flags that affect how the message is received (IUCV_IPBUFLST)
333 * @buffer: address of data buffer or address of struct iucv_array
334 * @size: length of data buffer
335 * @residual:
336 *
337 * This function receives messages that are being sent to you over
338 * established paths. This function will deal with RMDATA messages
339 * embedded in struct iucv_message as well.
340 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +0100341 * Locking: local_bh_enable/local_bh_disable
342 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800343 * Returns the result from the CP IUCV call.
344 */
345int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
346 u8 flags, void *buffer, size_t size, size_t *residual);
347
348/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +0100349 * __iucv_message_receive
350 * @path: address of iucv path structure
351 * @msg: address of iucv msg structure
352 * @flags: flags that affect how the message is received (IUCV_IPBUFLST)
353 * @buffer: address of data buffer or address of struct iucv_array
354 * @size: length of data buffer
355 * @residual:
356 *
357 * This function receives messages that are being sent to you over
358 * established paths. This function will deal with RMDATA messages
359 * embedded in struct iucv_message as well.
360 *
361 * Locking: no locking.
362 *
363 * Returns the result from the CP IUCV call.
364 */
365int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
366 u8 flags, void *buffer, size_t size,
367 size_t *residual);
368
369/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800370 * iucv_message_reject
371 * @path: address of iucv path structure
372 * @msg: address of iucv msg structure
373 *
374 * The reject function refuses a specified message. Between the time you
375 * are notified of a message and the time that you complete the message,
376 * the message may be rejected.
377 *
378 * Returns the result from the CP IUCV call.
379 */
380int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg);
381
382/**
383 * iucv_message_reply
384 * @path: address of iucv path structure
385 * @msg: address of iucv msg structure
386 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
387 * @reply: address of data buffer or address of struct iucv_array
388 * @size: length of reply data buffer
389 *
390 * This function responds to the two-way messages that you receive. You
391 * must identify completely the message to which you wish to reply. ie,
392 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
393 * the parameter list.
394 *
395 * Returns the result from the CP IUCV call.
396 */
397int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
398 u8 flags, void *reply, size_t size);
399
400/**
401 * iucv_message_send
402 * @path: address of iucv path structure
403 * @msg: address of iucv msg structure
404 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
405 * @srccls: source class of message
406 * @buffer: address of data buffer or address of struct iucv_array
407 * @size: length of send buffer
408 *
409 * This function transmits data to another application. Data to be
410 * transmitted is in a buffer and this is a one-way message and the
411 * receiver will not reply to the message.
412 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +0100413 * Locking: local_bh_enable/local_bh_disable
414 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800415 * Returns the result from the CP IUCV call.
416 */
417int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
418 u8 flags, u32 srccls, void *buffer, size_t size);
419
420/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +0100421 * __iucv_message_send
422 * @path: address of iucv path structure
423 * @msg: address of iucv msg structure
424 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
425 * @srccls: source class of message
426 * @buffer: address of data buffer or address of struct iucv_array
427 * @size: length of send buffer
428 *
429 * This function transmits data to another application. Data to be
430 * transmitted is in a buffer and this is a one-way message and the
431 * receiver will not reply to the message.
432 *
433 * Locking: no locking.
434 *
435 * Returns the result from the CP IUCV call.
436 */
437int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
438 u8 flags, u32 srccls, void *buffer, size_t size);
439
440/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800441 * iucv_message_send2way
442 * @path: address of iucv path structure
443 * @msg: address of iucv msg structure
444 * @flags: how the message is sent and the reply is received
445 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
446 * @srccls: source class of message
447 * @buffer: address of data buffer or address of struct iucv_array
448 * @size: length of send buffer
449 * @ansbuf: address of answer buffer or address of struct iucv_array
450 * @asize: size of reply buffer
451 *
452 * This function transmits data to another application. Data to be
453 * transmitted is in a buffer. The receiver of the send is expected to
454 * reply to the message and a buffer is provided into which IUCV moves
455 * the reply to this message.
456 *
457 * Returns the result from the CP IUCV call.
458 */
459int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
460 u8 flags, u32 srccls, void *buffer, size_t size,
461 void *answer, size_t asize, size_t *residual);
Frank Blaschka96d042a2011-08-08 01:33:49 +0000462
463struct iucv_interface {
464 int (*message_receive)(struct iucv_path *path, struct iucv_message *msg,
465 u8 flags, void *buffer, size_t size, size_t *residual);
466 int (*__message_receive)(struct iucv_path *path,
467 struct iucv_message *msg, u8 flags, void *buffer, size_t size,
468 size_t *residual);
469 int (*message_reply)(struct iucv_path *path, struct iucv_message *msg,
470 u8 flags, void *reply, size_t size);
471 int (*message_reject)(struct iucv_path *path, struct iucv_message *msg);
472 int (*message_send)(struct iucv_path *path, struct iucv_message *msg,
473 u8 flags, u32 srccls, void *buffer, size_t size);
474 int (*__message_send)(struct iucv_path *path, struct iucv_message *msg,
475 u8 flags, u32 srccls, void *buffer, size_t size);
476 int (*message_send2way)(struct iucv_path *path,
477 struct iucv_message *msg, u8 flags, u32 srccls, void *buffer,
478 size_t size, void *answer, size_t asize, size_t *residual);
479 int (*message_purge)(struct iucv_path *path, struct iucv_message *msg,
480 u32 srccls);
481 int (*path_accept)(struct iucv_path *path, struct iucv_handler *handler,
482 u8 userdata[16], void *private);
483 int (*path_connect)(struct iucv_path *path,
484 struct iucv_handler *handler,
485 u8 userid[8], u8 system[8], u8 userdata[16], void *private);
486 int (*path_quiesce)(struct iucv_path *path, u8 userdata[16]);
487 int (*path_resume)(struct iucv_path *path, u8 userdata[16]);
488 int (*path_sever)(struct iucv_path *path, u8 userdata[16]);
489 int (*iucv_register)(struct iucv_handler *handler, int smp);
490 void (*iucv_unregister)(struct iucv_handler *handler, int smp);
491 struct bus_type *bus;
492 struct device *root;
493};
494
495extern struct iucv_interface iucv_if;