projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] kfree cleanup: drivers/s390
[deliverable/linux.git] / drivers / s390 / net / iucv.c
1 /*
2 * $Id: iucv.c,v 1.45 2005/04/26 22:59:06 braunu Exp $
3 *
4 * IUCV network driver
5 *
6 * Copyright (C) 2001 IBM Deutschland Entwicklung GmbH, IBM Corporation
7 * Author(s):
8 * Original source:
9 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
10 * Xenia Tkatschow (xenia@us.ibm.com)
11 * 2Gb awareness and general cleanup:
12 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
13 *
14 * Documentation used:
15 * The original source
16 * CP Programming Service, IBM document # SC24-5760
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; either version 2, or (at your option)
21 * any later version.
22 *
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public License
29 * along with this program; if not, write to the Free Software
30 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 *
32 * RELEASE-TAG: IUCV lowlevel driver $Revision: 1.45 $
33 *
34 */
35 \f
36 /* #define DEBUG */
37
38 #include <linux/module.h>
39 #include <linux/moduleparam.h>
40 #include <linux/config.h>
41
42 #include <linux/spinlock.h>
43 #include <linux/kernel.h>
44 #include <linux/slab.h>
45 #include <linux/init.h>
46 #include <linux/interrupt.h>
47 #include <linux/list.h>
48 #include <linux/errno.h>
49 #include <linux/err.h>
50 #include <linux/device.h>
51 #include <asm/atomic.h>
52 #include "iucv.h"
53 #include <asm/io.h>
54 #include <asm/s390_ext.h>
55 #include <asm/ebcdic.h>
56 #include <asm/smp.h>
57 #include <asm/ccwdev.h> //for root device stuff
58
59 /* FLAGS:
60 * All flags are defined in the field IPFLAGS1 of each function
61 * and can be found in CP Programming Services.
62 * IPSRCCLS - Indicates you have specified a source class
63 * IPFGMCL - Indicates you have specified a target class
64 * IPFGPID - Indicates you have specified a pathid
65 * IPFGMID - Indicates you have specified a message ID
66 * IPANSLST - Indicates that you are using an address list for
67 * reply data
68 * IPBUFLST - Indicates that you are using an address list for
69 * message data
70 */
71
72 #define IPSRCCLS 0x01
73 #define IPFGMCL 0x01
74 #define IPFGPID 0x02
75 #define IPFGMID 0x04
76 #define IPANSLST 0x08
77 #define IPBUFLST 0x40
78
79 static int
80 iucv_bus_match (struct device *dev, struct device_driver *drv)
81 {
82 return 0;
83 }
84
85 struct bus_type iucv_bus = {
86 .name = "iucv",
87 .match = iucv_bus_match,
88 };
89
90 struct device *iucv_root;
91
92 /* General IUCV interrupt structure */
93 typedef struct {
94 __u16 ippathid;
95 __u8 res1;
96 __u8 iptype;
97 __u32 res2;
98 __u8 ipvmid[8];
99 __u8 res3[24];
100 } iucv_GeneralInterrupt;
101
102 static iucv_GeneralInterrupt *iucv_external_int_buffer = NULL;
103
104 /* Spin Lock declaration */
105
106 static DEFINE_SPINLOCK(iucv_lock);
107
108 static int messagesDisabled = 0;
109
110 /***************INTERRUPT HANDLING ***************/
111
112 typedef struct {
113 struct list_head queue;
114 iucv_GeneralInterrupt data;
115 } iucv_irqdata;
116
117 static struct list_head iucv_irq_queue;
118 static DEFINE_SPINLOCK(iucv_irq_queue_lock);
119
120 /*
121 *Internal function prototypes
122 */
123 static void iucv_tasklet_handler(unsigned long);
124 static void iucv_irq_handler(struct pt_regs *, __u16);
125
126 static DECLARE_TASKLET(iucv_tasklet,iucv_tasklet_handler,0);
127
128 /************ FUNCTION ID'S ****************************/
129
130 #define ACCEPT 10
131 #define CONNECT 11
132 #define DECLARE_BUFFER 12
133 #define PURGE 9
134 #define QUERY 0
135 #define QUIESCE 13
136 #define RECEIVE 5
137 #define REJECT 8
138 #define REPLY 6
139 #define RESUME 14
140 #define RETRIEVE_BUFFER 2
141 #define SEND 4
142 #define SETMASK 16
143 #define SEVER 15
144
145 /**
146 * Structure: handler
147 * members: list - list management.
148 * structure: id
149 * userid - 8 char array of machine identification
150 * user_data - 16 char array for user identification
151 * mask - 24 char array used to compare the 2 previous
152 * interrupt_table - vector of interrupt functions.
153 * pgm_data - ulong, application data that is passed
154 * to the interrupt handlers
155 */
156 typedef struct handler_t {
157 struct list_head list;
158 struct {
159 __u8 userid[8];
160 __u8 user_data[16];
161 __u8 mask[24];
162 } id;
163 iucv_interrupt_ops_t *interrupt_table;
164 void *pgm_data;
165 } handler;
166
167 /**
168 * iucv_handler_table: List of registered handlers.
169 */
170 static struct list_head iucv_handler_table;
171
172 /**
173 * iucv_pathid_table: an array of *handler pointing into
174 * iucv_handler_table for fast indexing by pathid;
175 */
176 static handler **iucv_pathid_table;
177
178 static unsigned long max_connections;
179
180 /**
181 * iucv_cpuid: contains the logical cpu number of the cpu which
182 * has declared the iucv buffer by issuing DECLARE_BUFFER.
183 * If no cpu has done the initialization iucv_cpuid contains -1.
184 */
185 static int iucv_cpuid = -1;
186 /**
187 * register_flag: is 0 when external interrupt has not been registered
188 */
189 static int register_flag;
190
191 /****************FIVE 40-BYTE PARAMETER STRUCTURES******************/
192 /* Data struct 1: iparml_control
193 * Used for iucv_accept
194 * iucv_connect
195 * iucv_quiesce
196 * iucv_resume
197 * iucv_sever
198 * iucv_retrieve_buffer
199 * Data struct 2: iparml_dpl (data in parameter list)
200 * Used for iucv_send_prmmsg
201 * iucv_send2way_prmmsg
202 * iucv_send2way_prmmsg_array
203 * iucv_reply_prmmsg
204 * Data struct 3: iparml_db (data in a buffer)
205 * Used for iucv_receive
206 * iucv_receive_array
207 * iucv_reject
208 * iucv_reply
209 * iucv_reply_array
210 * iucv_send
211 * iucv_send_array
212 * iucv_send2way
213 * iucv_send2way_array
214 * iucv_declare_buffer
215 * Data struct 4: iparml_purge
216 * Used for iucv_purge
217 * iucv_query
218 * Data struct 5: iparml_set_mask
219 * Used for iucv_set_mask
220 */
221
222 typedef struct {
223 __u16 ippathid;
224 __u8 ipflags1;
225 __u8 iprcode;
226 __u16 ipmsglim;
227 __u16 res1;
228 __u8 ipvmid[8];
229 __u8 ipuser[16];
230 __u8 iptarget[8];
231 } iparml_control;
232
233 typedef struct {
234 __u16 ippathid;
235 __u8 ipflags1;
236 __u8 iprcode;
237 __u32 ipmsgid;
238 __u32 iptrgcls;
239 __u8 iprmmsg[8];
240 __u32 ipsrccls;
241 __u32 ipmsgtag;
242 __u32 ipbfadr2;
243 __u32 ipbfln2f;
244 __u32 res;
245 } iparml_dpl;
246
247 typedef struct {
248 __u16 ippathid;
249 __u8 ipflags1;
250 __u8 iprcode;
251 __u32 ipmsgid;
252 __u32 iptrgcls;
253 __u32 ipbfadr1;
254 __u32 ipbfln1f;
255 __u32 ipsrccls;
256 __u32 ipmsgtag;
257 __u32 ipbfadr2;
258 __u32 ipbfln2f;
259 __u32 res;
260 } iparml_db;
261
262 typedef struct {
263 __u16 ippathid;
264 __u8 ipflags1;
265 __u8 iprcode;
266 __u32 ipmsgid;
267 __u8 ipaudit[3];
268 __u8 res1[5];
269 __u32 res2;
270 __u32 ipsrccls;
271 __u32 ipmsgtag;
272 __u32 res3[3];
273 } iparml_purge;
274
275 typedef struct {
276 __u8 ipmask;
277 __u8 res1[2];
278 __u8 iprcode;
279 __u32 res2[9];
280 } iparml_set_mask;
281
282 typedef struct {
283 union {
284 iparml_control p_ctrl;
285 iparml_dpl p_dpl;
286 iparml_db p_db;
287 iparml_purge p_purge;
288 iparml_set_mask p_set_mask;
289 } param;
290 atomic_t in_use;
291 __u32 res;
292 } __attribute__ ((aligned(8))) iucv_param;
293 #define PARAM_POOL_SIZE (PAGE_SIZE / sizeof(iucv_param))
294
295 static iucv_param * iucv_param_pool;
296
297 MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
298 MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
299 MODULE_LICENSE("GPL");
300
301 /*
302 * Debugging stuff
303 *******************************************************************************/
304 \f
305
306 #ifdef DEBUG
307 static int debuglevel = 0;
308
309 module_param(debuglevel, int, 0);
310 MODULE_PARM_DESC(debuglevel,
311 "Specifies the debug level (0=off ... 3=all)");
312
313 static void
314 iucv_dumpit(char *title, void *buf, int len)
315 {
316 int i;
317 __u8 *p = (__u8 *)buf;
318
319 if (debuglevel < 3)
320 return;
321
322 printk(KERN_DEBUG "%s\n", title);
323 printk(" ");
324 for (i = 0; i < len; i++) {
325 if (!(i % 16) && i != 0)
326 printk ("\n ");
327 else if (!(i % 4) && i != 0)
328 printk(" ");
329 printk("%02X", *p++);
330 }
331 if (len % 16)
332 printk ("\n");
333 return;
334 }
335 #define iucv_debug(lvl, fmt, args...) \
336 do { \
337 if (debuglevel >= lvl) \
338 printk(KERN_DEBUG "%s: " fmt "\n", __FUNCTION__ , ## args); \
339 } while (0)
340
341 #else
342
343 #define iucv_debug(lvl, fmt, args...)
344 #define iucv_dumpit(title, buf, len)
345
346 #endif
347
348 /*
349 * Internal functions
350 *******************************************************************************/
351 \f
352 /**
353 * print start banner
354 */
355 static void
356 iucv_banner(void)
357 {
358 char vbuf[] = "$Revision: 1.45 $";
359 char *version = vbuf;
360
361 if ((version = strchr(version, ':'))) {
362 char *p = strchr(version + 1, '$');
363 if (p)
364 *p = '\0';
365 } else
366 version = " ??? ";
367 printk(KERN_INFO
368 "IUCV lowlevel driver Version%s initialized\n", version);
369 }
370
371 /**
372 * iucv_init - Initialization
373 *
374 * Allocates and initializes various data structures.
375 */
376 static int
377 iucv_init(void)
378 {
379 int ret;
380
381 if (iucv_external_int_buffer)
382 return 0;
383
384 if (!MACHINE_IS_VM) {
385 printk(KERN_ERR "IUCV: IUCV connection needs VM as base\n");
386 return -EPROTONOSUPPORT;
387 }
388
389 ret = bus_register(&iucv_bus);
390 if (ret) {
391 printk(KERN_ERR "IUCV: failed to register bus.\n");
392 return ret;
393 }
394
395 iucv_root = s390_root_dev_register("iucv");
396 if (IS_ERR(iucv_root)) {
397 printk(KERN_ERR "IUCV: failed to register iucv root.\n");
398 bus_unregister(&iucv_bus);
399 return PTR_ERR(iucv_root);
400 }
401
402 /* Note: GFP_DMA used used to get memory below 2G */
403 iucv_external_int_buffer = kmalloc(sizeof(iucv_GeneralInterrupt),
404 GFP_KERNEL|GFP_DMA);
405 if (!iucv_external_int_buffer) {
406 printk(KERN_WARNING
407 "%s: Could not allocate external interrupt buffer\n",
408 __FUNCTION__);
409 s390_root_dev_unregister(iucv_root);
410 bus_unregister(&iucv_bus);
411 return -ENOMEM;
412 }
413 memset(iucv_external_int_buffer, 0, sizeof(iucv_GeneralInterrupt));
414
415 /* Initialize parameter pool */
416 iucv_param_pool = kmalloc(sizeof(iucv_param) * PARAM_POOL_SIZE,
417 GFP_KERNEL|GFP_DMA);
418 if (!iucv_param_pool) {
419 printk(KERN_WARNING "%s: Could not allocate param pool\n",
420 __FUNCTION__);
421 kfree(iucv_external_int_buffer);
422 iucv_external_int_buffer = NULL;
423 s390_root_dev_unregister(iucv_root);
424 bus_unregister(&iucv_bus);
425 return -ENOMEM;
426 }
427 memset(iucv_param_pool, 0, sizeof(iucv_param) * PARAM_POOL_SIZE);
428
429 /* Initialize irq queue */
430 INIT_LIST_HEAD(&iucv_irq_queue);
431
432 /* Initialize handler table */
433 INIT_LIST_HEAD(&iucv_handler_table);
434
435 iucv_banner();
436 return 0;
437 }
438
439 /**
440 * iucv_exit - De-Initialization
441 *
442 * Frees everything allocated from iucv_init.
443 */
444 static int iucv_retrieve_buffer (void);
445
446 static void
447 iucv_exit(void)
448 {
449 iucv_retrieve_buffer();
450 kfree(iucv_external_int_buffer);
451 iucv_external_int_buffer = NULL;
452 kfree(iucv_param_pool);
453 iucv_param_pool = NULL;
454 s390_root_dev_unregister(iucv_root);
455 bus_unregister(&iucv_bus);
456 printk(KERN_INFO "IUCV lowlevel driver unloaded\n");
457 }
458
459 /**
460 * grab_param: - Get a parameter buffer from the pre-allocated pool.
461 *
462 * This function searches for an unused element in the pre-allocated pool
463 * of parameter buffers. If one is found, it marks it "in use" and returns
464 * a pointer to it. The calling function is responsible for releasing it
465 * when it has finished its usage.
466 *
467 * Returns: A pointer to iucv_param.
468 */
469 static __inline__ iucv_param *
470 grab_param(void)
471 {
472 iucv_param *ptr;
473 static int hint = 0;
474
475 ptr = iucv_param_pool + hint;
476 do {
477 ptr++;
478 if (ptr >= iucv_param_pool + PARAM_POOL_SIZE)
479 ptr = iucv_param_pool;
480 } while (atomic_compare_and_swap(0, 1, &ptr->in_use));
481 hint = ptr - iucv_param_pool;
482
483 memset(&ptr->param, 0, sizeof(ptr->param));
484 return ptr;
485 }
486
487 /**
488 * release_param - Release a parameter buffer.
489 * @p: A pointer to a struct iucv_param, previously obtained by calling
490 * grab_param().
491 *
492 * This function marks the specified parameter buffer "unused".
493 */
494 static __inline__ void
495 release_param(void *p)
496 {
497 atomic_set(&((iucv_param *)p)->in_use, 0);
498 }
499
500 /**
501 * iucv_add_handler: - Add a new handler
502 * @new_handler: handle that is being entered into chain.
503 *
504 * Places new handle on iucv_handler_table, if identical handler is not
505 * found.
506 *
507 * Returns: 0 on success, !0 on failure (handler already in chain).
508 */
509 static int
510 iucv_add_handler (handler *new)
511 {
512 ulong flags;
513
514 iucv_debug(1, "entering");
515 iucv_dumpit("handler:", new, sizeof(handler));
516
517 spin_lock_irqsave (&iucv_lock, flags);
518 if (!list_empty(&iucv_handler_table)) {
519 struct list_head *lh;
520
521 /**
522 * Search list for handler with identical id. If one
523 * is found, the new handler is _not_ added.
524 */
525 list_for_each(lh, &iucv_handler_table) {
526 handler *h = list_entry(lh, handler, list);
527 if (!memcmp(&new->id, &h->id, sizeof(h->id))) {
528 iucv_debug(1, "ret 1");
529 spin_unlock_irqrestore (&iucv_lock, flags);
530 return 1;
531 }
532 }
533 }
534 /**
535 * If we get here, no handler was found.
536 */
537 INIT_LIST_HEAD(&new->list);
538 list_add(&new->list, &iucv_handler_table);
539 spin_unlock_irqrestore (&iucv_lock, flags);
540
541 iucv_debug(1, "exiting");
542 return 0;
543 }
544
545 /**
546 * b2f0:
547 * @code: identifier of IUCV call to CP.
548 * @parm: pointer to 40 byte iparml area passed to CP
549 *
550 * Calls CP to execute IUCV commands.
551 *
552 * Returns: return code from CP's IUCV call
553 */
554 static __inline__ ulong
555 b2f0(__u32 code, void *parm)
556 {
557 iucv_dumpit("iparml before b2f0 call:", parm, sizeof(iucv_param));
558
559 asm volatile (
560 "LRA 1,0(%1)\n\t"
561 "LR 0,%0\n\t"
562 ".long 0xb2f01000"
563 :
564 : "d" (code), "a" (parm)
565 : "0", "1"
566 );
567
568 iucv_dumpit("iparml after b2f0 call:", parm, sizeof(iucv_param));
569
570 return (unsigned long)*((__u8 *)(parm + 3));
571 }
572
573 /*
574 * Name: iucv_add_pathid
575 * Purpose: Adds a path id to the system.
576 * Input: pathid - pathid that is going to be entered into system
577 * handle - address of handler that the pathid will be associated
578 * with.
579 * pgm_data - token passed in by application.
580 * Output: 0: successful addition of pathid
581 * - EINVAL - pathid entry is being used by another application
582 * - ENOMEM - storage allocation for a new pathid table failed
583 */
584 static int
585 __iucv_add_pathid(__u16 pathid, handler *handler)
586 {
587
588 iucv_debug(1, "entering");
589
590 iucv_debug(1, "handler is pointing to %p", handler);
591
592 if (pathid > (max_connections - 1))
593 return -EINVAL;
594
595 if (iucv_pathid_table[pathid]) {
596 iucv_debug(1, "pathid entry is %p", iucv_pathid_table[pathid]);
597 printk(KERN_WARNING
598 "%s: Pathid being used, error.\n", __FUNCTION__);
599 return -EINVAL;
600 }
601 iucv_pathid_table[pathid] = handler;
602
603 iucv_debug(1, "exiting");
604 return 0;
605 } /* end of add_pathid function */
606
607 static int
608 iucv_add_pathid(__u16 pathid, handler *handler)
609 {
610 ulong flags;
611 int rc;
612
613 spin_lock_irqsave (&iucv_lock, flags);
614 rc = __iucv_add_pathid(pathid, handler);
615 spin_unlock_irqrestore (&iucv_lock, flags);
616 return rc;
617 }
618
619 static void
620 iucv_remove_pathid(__u16 pathid)
621 {
622 ulong flags;
623
624 if (pathid > (max_connections - 1))
625 return;
626
627 spin_lock_irqsave (&iucv_lock, flags);
628 iucv_pathid_table[pathid] = NULL;
629 spin_unlock_irqrestore (&iucv_lock, flags);
630 }
631
632 /**
633 * iucv_declare_buffer_cpuid
634 * Register at VM for subsequent IUCV operations. This is executed
635 * on the reserved CPU iucv_cpuid. Called from iucv_declare_buffer().
636 */
637 static void
638 iucv_declare_buffer_cpuid (void *result)
639 {
640 iparml_db *parm;
641
642 parm = (iparml_db *)grab_param();
643 parm->ipbfadr1 = virt_to_phys(iucv_external_int_buffer);
644 if ((*((ulong *)result) = b2f0(DECLARE_BUFFER, parm)) == 1)
645 *((ulong *)result) = parm->iprcode;
646 release_param(parm);
647 }
648
649 /**
650 * iucv_retrieve_buffer_cpuid:
651 * Unregister IUCV usage at VM. This is always executed on the same
652 * cpu that registered the buffer to VM.
653 * Called from iucv_retrieve_buffer().
654 */
655 static void
656 iucv_retrieve_buffer_cpuid (void *cpu)
657 {
658 iparml_control *parm;
659
660 parm = (iparml_control *)grab_param();
661 b2f0(RETRIEVE_BUFFER, parm);
662 release_param(parm);
663 }
664
665 /**
666 * Name: iucv_declare_buffer
667 * Purpose: Specifies the guests real address of an external
668 * interrupt.
669 * Input: void
670 * Output: iprcode - return code from b2f0 call
671 */
672 static int
673 iucv_declare_buffer (void)
674 {
675 unsigned long flags;
676 ulong b2f0_result;
677
678 iucv_debug(1, "entering");
679 b2f0_result = -ENODEV;
680 spin_lock_irqsave (&iucv_lock, flags);
681 if (iucv_cpuid == -1) {
682 /* Reserve any cpu for use by iucv. */
683 iucv_cpuid = smp_get_cpu(CPU_MASK_ALL);
684 spin_unlock_irqrestore (&iucv_lock, flags);
685 smp_call_function_on(iucv_declare_buffer_cpuid,
686 &b2f0_result, 0, 1, iucv_cpuid);
687 if (b2f0_result) {
688 smp_put_cpu(iucv_cpuid);
689 iucv_cpuid = -1;
690 }
691 iucv_debug(1, "Address of EIB = %p", iucv_external_int_buffer);
692 } else {
693 spin_unlock_irqrestore (&iucv_lock, flags);
694 b2f0_result = 0;
695 }
696 iucv_debug(1, "exiting");
697 return b2f0_result;
698 }
699
700 /**
701 * iucv_retrieve_buffer:
702 *
703 * Terminates all use of IUCV.
704 * Returns: return code from CP
705 */
706 static int
707 iucv_retrieve_buffer (void)
708 {
709 iucv_debug(1, "entering");
710 if (iucv_cpuid != -1) {
711 smp_call_function_on(iucv_retrieve_buffer_cpuid,
712 0, 0, 1, iucv_cpuid);
713 /* Release the cpu reserved by iucv_declare_buffer. */
714 smp_put_cpu(iucv_cpuid);
715 iucv_cpuid = -1;
716 }
717 iucv_debug(1, "exiting");
718 return 0;
719 }
720
721 /**
722 * iucv_remove_handler:
723 * @users_handler: handler to be removed
724 *
725 * Remove handler when application unregisters.
726 */
727 static void
728 iucv_remove_handler(handler *handler)
729 {
730 unsigned long flags;
731
732 if ((!iucv_pathid_table) || (!handler))
733 return;
734
735 iucv_debug(1, "entering");
736
737 spin_lock_irqsave (&iucv_lock, flags);
738 list_del(&handler->list);
739 if (list_empty(&iucv_handler_table)) {
740 if (register_flag) {
741 unregister_external_interrupt(0x4000, iucv_irq_handler);
742 register_flag = 0;
743 }
744 }
745 spin_unlock_irqrestore (&iucv_lock, flags);
746
747 iucv_debug(1, "exiting");
748 return;
749 }
750
751 /**
752 * iucv_register_program:
753 * @pgmname: user identification
754 * @userid: machine identification
755 * @pgmmask: Indicates which bits in the pgmname and userid combined will be
756 * used to determine who is given control.
757 * @ops: Address of interrupt handler table.
758 * @pgm_data: Application data to be passed to interrupt handlers.
759 *
760 * Registers an application with IUCV.
761 * Returns:
762 * The address of handler, or NULL on failure.
763 * NOTE on pgmmask:
764 * If pgmname, userid and pgmmask are provided, pgmmask is entered into the
765 * handler as is.
766 * If pgmmask is NULL, the internal mask is set to all 0xff's
767 * When userid is NULL, the first 8 bytes of the internal mask are forced
768 * to 0x00.
769 * If pgmmask and userid are NULL, the first 8 bytes of the internal mask
770 * are forced to 0x00 and the last 16 bytes to 0xff.
771 */
772
773 iucv_handle_t
774 iucv_register_program (__u8 pgmname[16],
775 __u8 userid[8],
776 __u8 pgmmask[24],
777 iucv_interrupt_ops_t * ops, void *pgm_data)
778 {
779 ulong rc = 0; /* return code from function calls */
780 handler *new_handler;
781
782 iucv_debug(1, "entering");
783
784 if (ops == NULL) {
785 /* interrupt table is not defined */
786 printk(KERN_WARNING "%s: Interrupt table is not defined, "
787 "exiting\n", __FUNCTION__);
788 return NULL;
789 }
790 if (!pgmname) {
791 printk(KERN_WARNING "%s: pgmname not provided\n", __FUNCTION__);
792 return NULL;
793 }
794
795 /* Allocate handler entry */
796 new_handler = (handler *)kmalloc(sizeof(handler), GFP_ATOMIC);
797 if (new_handler == NULL) {
798 printk(KERN_WARNING "%s: storage allocation for new handler "
799 "failed.\n", __FUNCTION__);
800 return NULL;
801 }
802
803 if (!iucv_pathid_table) {
804 if (iucv_init()) {
805 kfree(new_handler);
806 return NULL;
807 }
808
809 max_connections = iucv_query_maxconn();
810 iucv_pathid_table = kmalloc(max_connections * sizeof(handler *),
811 GFP_ATOMIC);
812 if (iucv_pathid_table == NULL) {
813 printk(KERN_WARNING "%s: iucv_pathid_table storage "
814 "allocation failed\n", __FUNCTION__);
815 kfree(new_handler);
816 return NULL;
817 }
818 memset (iucv_pathid_table, 0, max_connections * sizeof(handler *));
819 }
820 memset(new_handler, 0, sizeof (handler));
821 memcpy(new_handler->id.user_data, pgmname,
822 sizeof (new_handler->id.user_data));
823 if (userid) {
824 memcpy (new_handler->id.userid, userid,
825 sizeof (new_handler->id.userid));
826 ASCEBC (new_handler->id.userid,
827 sizeof (new_handler->id.userid));
828 EBC_TOUPPER (new_handler->id.userid,
829 sizeof (new_handler->id.userid));
830
831 if (pgmmask) {
832 memcpy (new_handler->id.mask, pgmmask,
833 sizeof (new_handler->id.mask));
834 } else {
835 memset (new_handler->id.mask, 0xFF,
836 sizeof (new_handler->id.mask));
837 }
838 } else {
839 if (pgmmask) {
840 memcpy (new_handler->id.mask, pgmmask,
841 sizeof (new_handler->id.mask));
842 } else {
843 memset (new_handler->id.mask, 0xFF,
844 sizeof (new_handler->id.mask));
845 }
846 memset (new_handler->id.userid, 0x00,
847 sizeof (new_handler->id.userid));
848 }
849 /* fill in the rest of handler */
850 new_handler->pgm_data = pgm_data;
851 new_handler->interrupt_table = ops;
852
853 /*
854 * Check if someone else is registered with same pgmname, userid
855 * and mask. If someone is already registered with same pgmname,
856 * userid and mask, registration will fail and NULL will be returned
857 * to the application.
858 * If identical handler not found, then handler is added to list.
859 */
860 rc = iucv_add_handler(new_handler);
861 if (rc) {
862 printk(KERN_WARNING "%s: Someone already registered with same "
863 "pgmname, userid, pgmmask\n", __FUNCTION__);
864 kfree (new_handler);
865 return NULL;
866 }
867
868 rc = iucv_declare_buffer();
869 if (rc) {
870 char *err = "Unknown";
871 iucv_remove_handler(new_handler);
872 kfree(new_handler);
873 switch(rc) {
874 case 0x03:
875 err = "Directory error";
876 break;
877 case 0x0a:
878 err = "Invalid length";
879 break;
880 case 0x13:
881 err = "Buffer already exists";
882 break;
883 case 0x3e:
884 err = "Buffer overlap";
885 break;
886 case 0x5c:
887 err = "Paging or storage error";
888 break;
889 }
890 printk(KERN_WARNING "%s: iucv_declare_buffer "
891 "returned error 0x%02lx (%s)\n", __FUNCTION__, rc, err);
892 return NULL;
893 }
894 if (!register_flag) {
895 /* request the 0x4000 external interrupt */
896 rc = register_external_interrupt (0x4000, iucv_irq_handler);
897 if (rc) {
898 iucv_remove_handler(new_handler);
899 kfree (new_handler);
900 printk(KERN_WARNING "%s: "
901 "register_external_interrupt returned %ld\n",
902 __FUNCTION__, rc);
903 return NULL;
904
905 }
906 register_flag = 1;
907 }
908 iucv_debug(1, "exiting");
909 return new_handler;
910 } /* end of register function */
911
912 /**
913 * iucv_unregister_program:
914 * @handle: address of handler
915 *
916 * Unregister application with IUCV.
917 * Returns:
918 * 0 on success, -EINVAL, if specified handle is invalid.
919 */
920
921 int
922 iucv_unregister_program (iucv_handle_t handle)
923 {
924 handler *h = NULL;
925 struct list_head *lh;
926 int i;
927 ulong flags;
928
929 iucv_debug(1, "entering");
930 iucv_debug(1, "address of handler is %p", h);
931
932 /* Checking if handle is valid */
933 spin_lock_irqsave (&iucv_lock, flags);
934 list_for_each(lh, &iucv_handler_table) {
935 if ((handler *)handle == list_entry(lh, handler, list)) {
936 h = (handler *)handle;
937 break;
938 }
939 }
940 if (!h) {
941 spin_unlock_irqrestore (&iucv_lock, flags);
942 if (handle)
943 printk(KERN_WARNING
944 "%s: Handler not found in iucv_handler_table.\n",
945 __FUNCTION__);
946 else
947 printk(KERN_WARNING
948 "%s: NULL handle passed by application.\n",
949 __FUNCTION__);
950 return -EINVAL;
951 }
952
953 /**
954 * First, walk thru iucv_pathid_table and sever any pathid which is
955 * still pointing to the handler to be removed.
956 */
957 for (i = 0; i < max_connections; i++)
958 if (iucv_pathid_table[i] == h) {
959 spin_unlock_irqrestore (&iucv_lock, flags);
960 iucv_sever(i, h->id.user_data);
961 spin_lock_irqsave(&iucv_lock, flags);
962 }
963 spin_unlock_irqrestore (&iucv_lock, flags);
964
965 iucv_remove_handler(h);
966 kfree(h);
967
968 iucv_debug(1, "exiting");
969 return 0;
970 }
971
972 /**
973 * iucv_accept:
974 * @pathid: Path identification number
975 * @msglim_reqstd: The number of outstanding messages requested.
976 * @user_data: Data specified by the iucv_connect function.
977 * @flags1: Contains options for this path.
978 * - IPPRTY (0x20) Specifies if you want to send priority message.
979 * - IPRMDATA (0x80) Specifies whether your program can handle a message
980 * in the parameter list.
981 * - IPQUSCE (0x40) Specifies whether you want to quiesce the path being
982 * established.
983 * @handle: Address of handler.
984 * @pgm_data: Application data passed to interrupt handlers.
985 * @flags1_out: Pointer to an int. If not NULL, on return the options for
986 * the path are stored at the given location:
987 * - IPPRTY (0x20) Indicates you may send a priority message.
988 * @msglim: Pointer to an __u16. If not NULL, on return the maximum
989 * number of outstanding messages is stored at the given
990 * location.
991 *
992 * This function is issued after the user receives a Connection Pending external
993 * interrupt and now wishes to complete the IUCV communication path.
994 * Returns:
995 * return code from CP
996 */
997 int
998 iucv_accept(__u16 pathid, __u16 msglim_reqstd,
999 __u8 user_data[16], int flags1,
1000 iucv_handle_t handle, void *pgm_data,
1001 int *flags1_out, __u16 * msglim)
1002 {
1003 ulong b2f0_result = 0;
1004 ulong flags;
1005 struct list_head *lh;
1006 handler *h = NULL;
1007 iparml_control *parm;
1008
1009 iucv_debug(1, "entering");
1010 iucv_debug(1, "pathid = %d", pathid);
1011
1012 /* Checking if handle is valid */
1013 spin_lock_irqsave (&iucv_lock, flags);
1014 list_for_each(lh, &iucv_handler_table) {
1015 if ((handler *)handle == list_entry(lh, handler, list)) {
1016 h = (handler *)handle;
1017 break;
1018 }
1019 }
1020 spin_unlock_irqrestore (&iucv_lock, flags);
1021
1022 if (!h) {
1023 if (handle)
1024 printk(KERN_WARNING
1025 "%s: Handler not found in iucv_handler_table.\n",
1026 __FUNCTION__);
1027 else
1028 printk(KERN_WARNING
1029 "%s: NULL handle passed by application.\n",
1030 __FUNCTION__);
1031 return -EINVAL;
1032 }
1033
1034 parm = (iparml_control *)grab_param();
1035
1036 parm->ippathid = pathid;
1037 parm->ipmsglim = msglim_reqstd;
1038 if (user_data)
1039 memcpy(parm->ipuser, user_data, sizeof(parm->ipuser));
1040
1041 parm->ipflags1 = (__u8)flags1;
1042 b2f0_result = b2f0(ACCEPT, parm);
1043
1044 if (!b2f0_result) {
1045 if (msglim)
1046 *msglim = parm->ipmsglim;
1047 if (pgm_data)
1048 h->pgm_data = pgm_data;
1049 if (flags1_out)
1050 *flags1_out = (parm->ipflags1 & IPPRTY) ? IPPRTY : 0;
1051 }
1052 release_param(parm);
1053
1054 iucv_debug(1, "exiting");
1055 return b2f0_result;
1056 }
1057
1058 /**
1059 * iucv_connect:
1060 * @pathid: Path identification number
1061 * @msglim_reqstd: Number of outstanding messages requested
1062 * @user_data: 16-byte user data
1063 * @userid: 8-byte of user identification
1064 * @system_name: 8-byte identifying the system name
1065 * @flags1: Specifies options for this path:
1066 * - IPPRTY (0x20) Specifies if you want to send priority message.
1067 * - IPRMDATA (0x80) Specifies whether your program can handle a message
1068 * in the parameter list.
1069 * - IPQUSCE (0x40) Specifies whether you want to quiesce the path being
1070 * established.
1071 * - IPLOCAL (0x01) Allows an application to force the partner to be on the
1072 * local system. If local is specified then target class
1073 * cannot be specified.
1074 * @flags1_out: Pointer to an int. If not NULL, on return the options for
1075 * the path are stored at the given location:
1076 * - IPPRTY (0x20) Indicates you may send a priority message.
1077 * @msglim: Pointer to an __u16. If not NULL, on return the maximum
1078 * number of outstanding messages is stored at the given
1079 * location.
1080 * @handle: Address of handler.
1081 * @pgm_data: Application data to be passed to interrupt handlers.
1082 *
1083 * This function establishes an IUCV path. Although the connect may complete
1084 * successfully, you are not able to use the path until you receive an IUCV
1085 * Connection Complete external interrupt.
1086 * Returns: return code from CP, or one of the following
1087 * - ENOMEM
1088 * - return code from iucv_declare_buffer
1089 * - EINVAL - invalid handle passed by application
1090 * - EINVAL - pathid address is NULL
1091 * - ENOMEM - pathid table storage allocation failed
1092 * - return code from internal function add_pathid
1093 */
1094 int
1095 iucv_connect (__u16 *pathid, __u16 msglim_reqstd,
1096 __u8 user_data[16], __u8 userid[8],
1097 __u8 system_name[8], int flags1,
1098 int *flags1_out, __u16 * msglim,
1099 iucv_handle_t handle, void *pgm_data)
1100 {
1101 iparml_control *parm;
1102 iparml_control local_parm;
1103 struct list_head *lh;
1104 ulong b2f0_result = 0;
1105 ulong flags;
1106 int add_pathid_result = 0;
1107 handler *h = NULL;
1108 __u8 no_memory[16] = "NO MEMORY";
1109
1110 iucv_debug(1, "entering");
1111
1112 /* Checking if handle is valid */
1113 spin_lock_irqsave (&iucv_lock, flags);
1114 list_for_each(lh, &iucv_handler_table) {
1115 if ((handler *)handle == list_entry(lh, handler, list)) {
1116 h = (handler *)handle;
1117 break;
1118 }
1119 }
1120 spin_unlock_irqrestore (&iucv_lock, flags);
1121
1122 if (!h) {
1123 if (handle)
1124 printk(KERN_WARNING
1125 "%s: Handler not found in iucv_handler_table.\n",
1126 __FUNCTION__);
1127 else
1128 printk(KERN_WARNING
1129 "%s: NULL handle passed by application.\n",
1130 __FUNCTION__);
1131 return -EINVAL;
1132 }
1133
1134 if (pathid == NULL) {
1135 printk(KERN_WARNING "%s: NULL pathid pointer\n",
1136 __FUNCTION__);
1137 return -EINVAL;
1138 }
1139
1140 parm = (iparml_control *)grab_param();
1141
1142 parm->ipmsglim = msglim_reqstd;
1143
1144 if (user_data)
1145 memcpy(parm->ipuser, user_data, sizeof(parm->ipuser));
1146
1147 if (userid) {
1148 memcpy(parm->ipvmid, userid, sizeof(parm->ipvmid));
1149 ASCEBC(parm->ipvmid, sizeof(parm->ipvmid));
1150 EBC_TOUPPER(parm->ipvmid, sizeof(parm->ipvmid));
1151 }
1152
1153 if (system_name) {
1154 memcpy(parm->iptarget, system_name, sizeof(parm->iptarget));
1155 ASCEBC(parm->iptarget, sizeof(parm->iptarget));
1156 EBC_TOUPPER(parm->iptarget, sizeof(parm->iptarget));
1157 }
1158
1159 /* In order to establish an IUCV connection, the procedure is:
1160 *
1161 * b2f0(CONNECT)
1162 * take the ippathid from the b2f0 call
1163 * register the handler to the ippathid
1164 *
1165 * Unfortunately, the ConnectionEstablished message gets sent after the
1166 * b2f0(CONNECT) call but before the register is handled.
1167 *
1168 * In order for this race condition to be eliminated, the IUCV Control
1169 * Interrupts must be disabled for the above procedure.
1170 *
1171 * David Kennedy <dkennedy@linuxcare.com>
1172 */
1173
1174 /* Enable everything but IUCV Control messages */
1175 iucv_setmask(~(AllInterrupts));
1176 messagesDisabled = 1;
1177
1178 spin_lock_irqsave (&iucv_lock, flags);
1179 parm->ipflags1 = (__u8)flags1;
1180 b2f0_result = b2f0(CONNECT, parm);
1181 memcpy(&local_parm, parm, sizeof(local_parm));
1182 release_param(parm);
1183 parm = &local_parm;
1184 if (!b2f0_result)
1185 add_pathid_result = __iucv_add_pathid(parm->ippathid, h);
1186 spin_unlock_irqrestore (&iucv_lock, flags);
1187
1188 if (b2f0_result) {
1189 iucv_setmask(~0);
1190 messagesDisabled = 0;
1191 return b2f0_result;
1192 }
1193
1194 *pathid = parm->ippathid;
1195
1196 /* Enable everything again */
1197 iucv_setmask(IUCVControlInterruptsFlag);
1198
1199 if (msglim)
1200 *msglim = parm->ipmsglim;
1201 if (flags1_out)
1202 *flags1_out = (parm->ipflags1 & IPPRTY) ? IPPRTY : 0;
1203
1204 if (add_pathid_result) {
1205 iucv_sever(*pathid, no_memory);
1206 printk(KERN_WARNING "%s: add_pathid failed with rc ="
1207 " %d\n", __FUNCTION__, add_pathid_result);
1208 return(add_pathid_result);
1209 }
1210
1211 iucv_debug(1, "exiting");
1212 return b2f0_result;
1213 }
1214
1215 /**
1216 * iucv_purge:
1217 * @pathid: Path identification number
1218 * @msgid: Message ID of message to purge.
1219 * @srccls: Message class of the message to purge.
1220 * @audit: Pointer to an __u32. If not NULL, on return, information about
1221 * asynchronous errors that may have affected the normal completion
1222 * of this message ist stored at the given location.
1223 *
1224 * Cancels a message you have sent.
1225 * Returns: return code from CP
1226 */
1227 int
1228 iucv_purge (__u16 pathid, __u32 msgid, __u32 srccls, __u32 *audit)
1229 {
1230 iparml_purge *parm;
1231 ulong b2f0_result = 0;
1232
1233 iucv_debug(1, "entering");
1234 iucv_debug(1, "pathid = %d", pathid);
1235
1236 parm = (iparml_purge *)grab_param();
1237
1238 parm->ipmsgid = msgid;
1239 parm->ippathid = pathid;
1240 parm->ipsrccls = srccls;
1241 parm->ipflags1 |= (IPSRCCLS | IPFGMID | IPFGPID);
1242 b2f0_result = b2f0(PURGE, parm);
1243
1244 if (!b2f0_result && audit) {
1245 memcpy(audit, parm->ipaudit, sizeof(parm->ipaudit));
1246 /* parm->ipaudit has only 3 bytes */
1247 *audit >>= 8;
1248 }
1249
1250 release_param(parm);
1251
1252 iucv_debug(1, "b2f0_result = %ld", b2f0_result);
1253 iucv_debug(1, "exiting");
1254 return b2f0_result;
1255 }
1256
1257 /**
1258 * iucv_query_generic:
1259 * @want_maxconn: Flag, describing which value is to be returned.
1260 *
1261 * Helper function for iucv_query_maxconn() and iucv_query_bufsize().
1262 *
1263 * Returns: The buffersize, if want_maxconn is 0; the maximum number of
1264 * connections, if want_maxconn is 1 or an error-code < 0 on failure.
1265 */
1266 static int
1267 iucv_query_generic(int want_maxconn)
1268 {
1269 iparml_purge *parm = (iparml_purge *)grab_param();
1270 int bufsize, maxconn;
1271 int ccode;
1272
1273 /**
1274 * Call b2f0 and store R0 (max buffer size),
1275 * R1 (max connections) and CC.
1276 */
1277 asm volatile (
1278 "LRA 1,0(%4)\n\t"
1279 "LR 0,%3\n\t"
1280 ".long 0xb2f01000\n\t"
1281 "IPM %0\n\t"
1282 "SRL %0,28\n\t"
1283 "ST 0,%1\n\t"
1284 "ST 1,%2\n\t"
1285 : "=d" (ccode), "=m" (bufsize), "=m" (maxconn)
1286 : "d" (QUERY), "a" (parm)
1287 : "0", "1", "cc"
1288 );
1289 release_param(parm);
1290
1291 if (ccode)
1292 return -EPERM;
1293 if (want_maxconn)
1294 return maxconn;
1295 return bufsize;
1296 }
1297
1298 /**
1299 * iucv_query_maxconn:
1300 *
1301 * Determines the maximum number of connections thay may be established.
1302 *
1303 * Returns: Maximum number of connections that can be.
1304 */
1305 ulong
1306 iucv_query_maxconn(void)
1307 {
1308 return iucv_query_generic(1);
1309 }
1310
1311 /**
1312 * iucv_query_bufsize:
1313 *
1314 * Determines the size of the external interrupt buffer.
1315 *
1316 * Returns: Size of external interrupt buffer.
1317 */
1318 ulong
1319 iucv_query_bufsize (void)
1320 {
1321 return iucv_query_generic(0);
1322 }
1323
1324 /**
1325 * iucv_quiesce:
1326 * @pathid: Path identification number
1327 * @user_data: 16-byte user data
1328 *
1329 * Temporarily suspends incoming messages on an IUCV path.
1330 * You can later reactivate the path by invoking the iucv_resume function.
1331 * Returns: return code from CP
1332 */
1333 int
1334 iucv_quiesce (__u16 pathid, __u8 user_data[16])
1335 {
1336 iparml_control *parm;
1337 ulong b2f0_result = 0;
1338
1339 iucv_debug(1, "entering");
1340 iucv_debug(1, "pathid = %d", pathid);
1341
1342 parm = (iparml_control *)grab_param();
1343
1344 memcpy(parm->ipuser, user_data, sizeof(parm->ipuser));
1345 parm->ippathid = pathid;
1346
1347 b2f0_result = b2f0(QUIESCE, parm);
1348 release_param(parm);
1349
1350 iucv_debug(1, "b2f0_result = %ld", b2f0_result);
1351 iucv_debug(1, "exiting");
1352
1353 return b2f0_result;
1354 }
1355
1356 /**
1357 * iucv_receive:
1358 * @pathid: Path identification number.
1359 * @buffer: Address of buffer to receive. Must be below 2G.
1360 * @buflen: Length of buffer to receive.
1361 * @msgid: Specifies the message ID.
1362 * @trgcls: Specifies target class.
1363 * @flags1_out: Receives options for path on return.
1364 * - IPNORPY (0x10) Specifies whether a reply is required
1365 * - IPPRTY (0x20) Specifies if you want to send priority message
1366 * - IPRMDATA (0x80) Specifies the data is contained in the parameter list
1367 * @residual_buffer: Receives the address of buffer updated by the number
1368 * of bytes you have received on return.
1369 * @residual_length: On return, receives one of the following values:
1370 * - 0 If the receive buffer is the same length as
1371 * the message.
1372 * - Remaining bytes in buffer If the receive buffer is longer than the
1373 * message.
1374 * - Remaining bytes in message If the receive buffer is shorter than the
1375 * message.
1376 *
1377 * This function receives messages that are being sent to you over established
1378 * paths.
1379 * Returns: return code from CP IUCV call; If the receive buffer is shorter
1380 * than the message, always 5
1381 * -EINVAL - buffer address is pointing to NULL
1382 */
1383 int
1384 iucv_receive (__u16 pathid, __u32 msgid, __u32 trgcls,
1385 void *buffer, ulong buflen,
1386 int *flags1_out, ulong * residual_buffer, ulong * residual_length)
1387 {
1388 iparml_db *parm;
1389 ulong b2f0_result;
1390 int moved = 0; /* number of bytes moved from parmlist to buffer */
1391
1392 iucv_debug(2, "entering");
1393
1394 if (!buffer)
1395 return -EINVAL;
1396
1397 parm = (iparml_db *)grab_param();
1398
1399 parm->ipbfadr1 = (__u32) (addr_t) buffer;
1400 parm->ipbfln1f = (__u32) ((ulong) buflen);
1401 parm->ipmsgid = msgid;
1402 parm->ippathid = pathid;
1403 parm->iptrgcls = trgcls;
1404 parm->ipflags1 = (IPFGPID | IPFGMID | IPFGMCL);
1405
1406 b2f0_result = b2f0(RECEIVE, parm);
1407
1408 if (!b2f0_result || b2f0_result == 5) {
1409 if (flags1_out) {
1410 iucv_debug(2, "*flags1_out = %d", *flags1_out);
1411 *flags1_out = (parm->ipflags1 & (~0x07));
1412 iucv_debug(2, "*flags1_out = %d", *flags1_out);
1413 }
1414
1415 if (!(parm->ipflags1 & IPRMDATA)) { /*msg not in parmlist */
1416 if (residual_length)
1417 *residual_length = parm->ipbfln1f;
1418
1419 if (residual_buffer)
1420 *residual_buffer = parm->ipbfadr1;
1421 } else {
1422 moved = min_t (unsigned long, buflen, 8);
1423
1424 memcpy ((char *) buffer,
1425 (char *) &parm->ipbfadr1, moved);
1426
1427 if (buflen < 8)
1428 b2f0_result = 5;
1429
1430 if (residual_length)
1431 *residual_length = abs (buflen - 8);
1432
1433 if (residual_buffer)
1434 *residual_buffer = (ulong) (buffer + moved);
1435 }
1436 }
1437 release_param(parm);
1438
1439 iucv_debug(2, "exiting");
1440 return b2f0_result;
1441 }
1442
1443 /*
1444 * Name: iucv_receive_array
1445 * Purpose: This function receives messages that are being sent to you
1446 * over established paths.
1447 * Input: pathid - path identification number
1448 * buffer - address of array of buffers
1449 * buflen - total length of buffers
1450 * msgid - specifies the message ID.
1451 * trgcls - specifies target class
1452 * Output:
1453 * flags1_out: Options for path.
1454 * IPNORPY - 0x10 specifies whether a reply is required
1455 * IPPRTY - 0x20 specifies if you want to send priority message
1456 * IPRMDATA - 0x80 specifies the data is contained in the parameter list
1457 * residual_buffer - address points to the current list entry IUCV
1458 * is working on.
1459 * residual_length -
1460 * Contains one of the following values, if the receive buffer is:
1461 * The same length as the message, this field is zero.
1462 * Longer than the message, this field contains the number of
1463 * bytes remaining in the buffer.
1464 * Shorter than the message, this field contains the residual
1465 * count (that is, the number of bytes remaining in the
1466 * message that does not fit into the buffer. In this case
1467 * b2f0_result = 5.
1468 * Return: b2f0_result - return code from CP
1469 * (-EINVAL) - buffer address is NULL
1470 */
1471 int
1472 iucv_receive_array (__u16 pathid,
1473 __u32 msgid, __u32 trgcls,
1474 iucv_array_t * buffer, ulong buflen,
1475 int *flags1_out,
1476 ulong * residual_buffer, ulong * residual_length)
1477 {
1478 iparml_db *parm;
1479 ulong b2f0_result;
1480 int i = 0, moved = 0, need_to_move = 8, dyn_len;
1481
1482 iucv_debug(2, "entering");
1483
1484 if (!buffer)
1485 return -EINVAL;
1486
1487 parm = (iparml_db *)grab_param();
1488
1489 parm->ipbfadr1 = (__u32) ((ulong) buffer);
1490 parm->ipbfln1f = (__u32) buflen;
1491 parm->ipmsgid = msgid;
1492 parm->ippathid = pathid;
1493 parm->iptrgcls = trgcls;
1494 parm->ipflags1 = (IPBUFLST | IPFGPID | IPFGMID | IPFGMCL);
1495
1496 b2f0_result = b2f0(RECEIVE, parm);
1497
1498 if (!b2f0_result || b2f0_result == 5) {
1499
1500 if (flags1_out) {
1501 iucv_debug(2, "*flags1_out = %d", *flags1_out);
1502 *flags1_out = (parm->ipflags1 & (~0x07));
1503 iucv_debug(2, "*flags1_out = %d", *flags1_out);
1504 }
1505
1506 if (!(parm->ipflags1 & IPRMDATA)) { /*msg not in parmlist */
1507
1508 if (residual_length)
1509 *residual_length = parm->ipbfln1f;
1510
1511 if (residual_buffer)
1512 *residual_buffer = parm->ipbfadr1;
1513
1514 } else {
1515 /* copy msg from parmlist to users array. */
1516
1517 while ((moved < 8) && (moved < buflen)) {
1518 dyn_len =
1519 min_t (unsigned int,
1520 (buffer + i)->length, need_to_move);
1521
1522 memcpy ((char *)((ulong)((buffer + i)->address)),
1523 ((char *) &parm->ipbfadr1) + moved,
1524 dyn_len);
1525
1526 moved += dyn_len;
1527 need_to_move -= dyn_len;
1528
1529 (buffer + i)->address =
1530 (__u32)
1531 ((ulong)(__u8 *) ((ulong)(buffer + i)->address)
1532 + dyn_len);
1533
1534 (buffer + i)->length -= dyn_len;
1535 i++;
1536 }
1537
1538 if (need_to_move) /* buflen < 8 bytes */
1539 b2f0_result = 5;
1540
1541 if (residual_length)
1542 *residual_length = abs (buflen - 8);
1543
1544 if (residual_buffer) {
1545 if (!moved)
1546 *residual_buffer = (ulong) buffer;
1547 else
1548 *residual_buffer =
1549 (ulong) (buffer + (i - 1));
1550 }
1551
1552 }
1553 }
1554 release_param(parm);
1555
1556 iucv_debug(2, "exiting");
1557 return b2f0_result;
1558 }
1559
1560 /**
1561 * iucv_reject:
1562 * @pathid: Path identification number.
1563 * @msgid: Message ID of the message to reject.
1564 * @trgcls: Target class of the message to reject.
1565 * Returns: return code from CP
1566 *
1567 * Refuses a specified message. Between the time you are notified of a
1568 * message and the time that you complete the message, the message may
1569 * be rejected.
1570 */
1571 int
1572 iucv_reject (__u16 pathid, __u32 msgid, __u32 trgcls)
1573 {
1574 iparml_db *parm;
1575 ulong b2f0_result = 0;
1576
1577 iucv_debug(1, "entering");
1578 iucv_debug(1, "pathid = %d", pathid);
1579
1580 parm = (iparml_db *)grab_param();
1581
1582 parm->ippathid = pathid;
1583 parm->ipmsgid = msgid;
1584 parm->iptrgcls = trgcls;
1585 parm->ipflags1 = (IPFGMCL | IPFGMID | IPFGPID);
1586
1587 b2f0_result = b2f0(REJECT, parm);
1588 release_param(parm);
1589
1590 iucv_debug(1, "b2f0_result = %ld", b2f0_result);
1591 iucv_debug(1, "exiting");
1592
1593 return b2f0_result;
1594 }
1595
1596 /*
1597 * Name: iucv_reply
1598 * Purpose: This function responds to the two-way messages that you
1599 * receive. You must identify completely the message to
1600 * which you wish to reply. ie, pathid, msgid, and trgcls.
1601 * Input: pathid - path identification number
1602 * msgid - specifies the message ID.
1603 * trgcls - specifies target class
1604 * flags1 - option for path
1605 * IPPRTY- 0x20 - specifies if you want to send priority message
1606 * buffer - address of reply buffer
1607 * buflen - length of reply buffer
1608 * Output: ipbfadr2 - Address of buffer updated by the number
1609 * of bytes you have moved.
1610 * ipbfln2f - Contains one of the following values:
1611 * If the answer buffer is the same length as the reply, this field
1612 * contains zero.
1613 * If the answer buffer is longer than the reply, this field contains
1614 * the number of bytes remaining in the buffer.
1615 * If the answer buffer is shorter than the reply, this field contains
1616 * a residual count (that is, the number of bytes remianing in the
1617 * reply that does not fit into the buffer. In this
1618 * case b2f0_result = 5.
1619 * Return: b2f0_result - return code from CP
1620 * (-EINVAL) - buffer address is NULL
1621 */
1622 int
1623 iucv_reply (__u16 pathid,
1624 __u32 msgid, __u32 trgcls,
1625 int flags1,
1626 void *buffer, ulong buflen, ulong * ipbfadr2, ulong * ipbfln2f)
1627 {
1628 iparml_db *parm;
1629 ulong b2f0_result;
1630
1631 iucv_debug(2, "entering");
1632
1633 if (!buffer)
1634 return -EINVAL;
1635
1636 parm = (iparml_db *)grab_param();
1637
1638 parm->ipbfadr2 = (__u32) ((ulong) buffer);
1639 parm->ipbfln2f = (__u32) buflen; /* length of message */
1640 parm->ippathid = pathid;
1641 parm->ipmsgid = msgid;
1642 parm->iptrgcls = trgcls;
1643 parm->ipflags1 = (__u8) flags1; /* priority message */
1644
1645 b2f0_result = b2f0(REPLY, parm);
1646
1647 if ((!b2f0_result) || (b2f0_result == 5)) {
1648 if (ipbfadr2)
1649 *ipbfadr2 = parm->ipbfadr2;
1650 if (ipbfln2f)
1651 *ipbfln2f = parm->ipbfln2f;
1652 }
1653 release_param(parm);
1654
1655 iucv_debug(2, "exiting");
1656
1657 return b2f0_result;
1658 }
1659
1660 /*
1661 * Name: iucv_reply_array
1662 * Purpose: This function responds to the two-way messages that you
1663 * receive. You must identify completely the message to
1664 * which you wish to reply. ie, pathid, msgid, and trgcls.
1665 * The array identifies a list of addresses and lengths of
1666 * discontiguous buffers that contains the reply data.
1667 * Input: pathid - path identification number
1668 * msgid - specifies the message ID.
1669 * trgcls - specifies target class
1670 * flags1 - option for path
1671 * IPPRTY- specifies if you want to send priority message
1672 * buffer - address of array of reply buffers
1673 * buflen - total length of reply buffers
1674 * Output: ipbfadr2 - Address of buffer which IUCV is currently working on.
1675 * ipbfln2f - Contains one of the following values:
1676 * If the answer buffer is the same length as the reply, this field
1677 * contains zero.
1678 * If the answer buffer is longer than the reply, this field contains
1679 * the number of bytes remaining in the buffer.
1680 * If the answer buffer is shorter than the reply, this field contains
1681 * a residual count (that is, the number of bytes remianing in the
1682 * reply that does not fit into the buffer. In this
1683 * case b2f0_result = 5.
1684 * Return: b2f0_result - return code from CP
1685 * (-EINVAL) - buffer address is NULL
1686 */
1687 int
1688 iucv_reply_array (__u16 pathid,
1689 __u32 msgid, __u32 trgcls,
1690 int flags1,
1691 iucv_array_t * buffer,
1692 ulong buflen, ulong * ipbfadr2, ulong * ipbfln2f)
1693 {
1694 iparml_db *parm;
1695 ulong b2f0_result;
1696
1697 iucv_debug(2, "entering");
1698
1699 if (!buffer)
1700 return -EINVAL;
1701
1702 parm = (iparml_db *)grab_param();
1703
1704 parm->ipbfadr2 = (__u32) ((ulong) buffer);
1705 parm->ipbfln2f = buflen; /* length of message */
1706 parm->ippathid = pathid;
1707 parm->ipmsgid = msgid;
1708 parm->iptrgcls = trgcls;
1709 parm->ipflags1 = (IPANSLST | flags1);
1710
1711 b2f0_result = b2f0(REPLY, parm);
1712
1713 if ((!b2f0_result) || (b2f0_result == 5)) {
1714
1715 if (ipbfadr2)
1716 *ipbfadr2 = parm->ipbfadr2;
1717 if (ipbfln2f)
1718 *ipbfln2f = parm->ipbfln2f;
1719 }
1720 release_param(parm);
1721
1722 iucv_debug(2, "exiting");
1723
1724 return b2f0_result;
1725 }
1726
1727 /*
1728 * Name: iucv_reply_prmmsg
1729 * Purpose: This function responds to the two-way messages that you
1730 * receive. You must identify completely the message to
1731 * which you wish to reply. ie, pathid, msgid, and trgcls.
1732 * Prmmsg signifies the data is moved into the
1733 * parameter list.
1734 * Input: pathid - path identification number
1735 * msgid - specifies the message ID.
1736 * trgcls - specifies target class
1737 * flags1 - option for path
1738 * IPPRTY- specifies if you want to send priority message
1739 * prmmsg - 8-bytes of data to be placed into the parameter
1740 * list.
1741 * Output: NA
1742 * Return: b2f0_result - return code from CP
1743 */
1744 int
1745 iucv_reply_prmmsg (__u16 pathid,
1746 __u32 msgid, __u32 trgcls, int flags1, __u8 prmmsg[8])
1747 {
1748 iparml_dpl *parm;
1749 ulong b2f0_result;
1750
1751 iucv_debug(2, "entering");
1752
1753 parm = (iparml_dpl *)grab_param();
1754
1755 parm->ippathid = pathid;
1756 parm->ipmsgid = msgid;
1757 parm->iptrgcls = trgcls;
1758 memcpy(parm->iprmmsg, prmmsg, sizeof (parm->iprmmsg));
1759 parm->ipflags1 = (IPRMDATA | flags1);
1760
1761 b2f0_result = b2f0(REPLY, parm);
1762 release_param(parm);
1763
1764 iucv_debug(2, "exiting");
1765
1766 return b2f0_result;
1767 }
1768
1769 /**
1770 * iucv_resume:
1771 * @pathid: Path identification number
1772 * @user_data: 16-byte of user data
1773 *
1774 * This function restores communication over a quiesced path.
1775 * Returns: return code from CP
1776 */
1777 int
1778 iucv_resume (__u16 pathid, __u8 user_data[16])
1779 {
1780 iparml_control *parm;
1781 ulong b2f0_result = 0;
1782
1783 iucv_debug(1, "entering");
1784 iucv_debug(1, "pathid = %d", pathid);
1785
1786 parm = (iparml_control *)grab_param();
1787
1788 memcpy (parm->ipuser, user_data, sizeof (*user_data));
1789 parm->ippathid = pathid;
1790
1791 b2f0_result = b2f0(RESUME, parm);
1792 release_param(parm);
1793
1794 iucv_debug(1, "exiting");
1795
1796 return b2f0_result;
1797 }
1798
1799 /*
1800 * Name: iucv_send
1801 * Purpose: sends messages
1802 * Input: pathid - ushort, pathid
1803 * msgid - ulong *, id of message returned to caller
1804 * trgcls - ulong, target message class
1805 * srccls - ulong, source message class
1806 * msgtag - ulong, message tag
1807 * flags1 - Contains options for this path.
1808 * IPPRTY - Ox20 - specifies if you want to send a priority message.
1809 * buffer - pointer to buffer
1810 * buflen - ulong, length of buffer
1811 * Output: b2f0_result - return code from b2f0 call
1812 * msgid - returns message id
1813 */
1814 int
1815 iucv_send (__u16 pathid, __u32 * msgid,
1816 __u32 trgcls, __u32 srccls,
1817 __u32 msgtag, int flags1, void *buffer, ulong buflen)
1818 {
1819 iparml_db *parm;
1820 ulong b2f0_result;
1821
1822 iucv_debug(2, "entering");
1823
1824 if (!buffer)
1825 return -EINVAL;
1826
1827 parm = (iparml_db *)grab_param();
1828
1829 parm->ipbfadr1 = (__u32) ((ulong) buffer);
1830 parm->ippathid = pathid;
1831 parm->iptrgcls = trgcls;
1832 parm->ipbfln1f = (__u32) buflen; /* length of message */
1833 parm->ipsrccls = srccls;
1834 parm->ipmsgtag = msgtag;
1835 parm->ipflags1 = (IPNORPY | flags1); /* one way priority message */
1836
1837 b2f0_result = b2f0(SEND, parm);
1838
1839 if ((!b2f0_result) && (msgid))
1840 *msgid = parm->ipmsgid;
1841 release_param(parm);
1842
1843 iucv_debug(2, "exiting");
1844
1845 return b2f0_result;
1846 }
1847
1848 /*
1849 * Name: iucv_send_array
1850 * Purpose: This function transmits data to another application.
1851 * The contents of buffer is the address of the array of
1852 * addresses and lengths of discontiguous buffers that hold
1853 * the message text. This is a one-way message and the
1854 * receiver will not reply to the message.
1855 * Input: pathid - path identification number
1856 * trgcls - specifies target class
1857 * srccls - specifies the source message class
1858 * msgtag - specifies a tag to be associated witht the message
1859 * flags1 - option for path
1860 * IPPRTY- specifies if you want to send priority message
1861 * buffer - address of array of send buffers
1862 * buflen - total length of send buffers
1863 * Output: msgid - specifies the message ID.
1864 * Return: b2f0_result - return code from CP
1865 * (-EINVAL) - buffer address is NULL
1866 */
1867 int
1868 iucv_send_array (__u16 pathid,
1869 __u32 * msgid,
1870 __u32 trgcls,
1871 __u32 srccls,
1872 __u32 msgtag, int flags1, iucv_array_t * buffer, ulong buflen)
1873 {
1874 iparml_db *parm;
1875 ulong b2f0_result;
1876
1877 iucv_debug(2, "entering");
1878
1879 if (!buffer)
1880 return -EINVAL;
1881
1882 parm = (iparml_db *)grab_param();
1883
1884 parm->ippathid = pathid;
1885 parm->iptrgcls = trgcls;
1886 parm->ipbfadr1 = (__u32) ((ulong) buffer);
1887 parm->ipbfln1f = (__u32) buflen; /* length of message */
1888 parm->ipsrccls = srccls;
1889 parm->ipmsgtag = msgtag;
1890 parm->ipflags1 = (IPNORPY | IPBUFLST | flags1);
1891 b2f0_result = b2f0(SEND, parm);
1892
1893 if ((!b2f0_result) && (msgid))
1894 *msgid = parm->ipmsgid;
1895 release_param(parm);
1896
1897 iucv_debug(2, "exiting");
1898 return b2f0_result;
1899 }
1900
1901 /*
1902 * Name: iucv_send_prmmsg
1903 * Purpose: This function transmits data to another application.
1904 * Prmmsg specifies that the 8-bytes of data are to be moved
1905 * into the parameter list. This is a one-way message and the
1906 * receiver will not reply to the message.
1907 * Input: pathid - path identification number
1908 * trgcls - specifies target class
1909 * srccls - specifies the source message class
1910 * msgtag - specifies a tag to be associated with the message
1911 * flags1 - option for path
1912 * IPPRTY- specifies if you want to send priority message
1913 * prmmsg - 8-bytes of data to be placed into parameter list
1914 * Output: msgid - specifies the message ID.
1915 * Return: b2f0_result - return code from CP
1916 */
1917 int
1918 iucv_send_prmmsg (__u16 pathid,
1919 __u32 * msgid,
1920 __u32 trgcls,
1921 __u32 srccls, __u32 msgtag, int flags1, __u8 prmmsg[8])
1922 {
1923 iparml_dpl *parm;
1924 ulong b2f0_result;
1925
1926 iucv_debug(2, "entering");
1927
1928 parm = (iparml_dpl *)grab_param();
1929
1930 parm->ippathid = pathid;
1931 parm->iptrgcls = trgcls;
1932 parm->ipsrccls = srccls;
1933 parm->ipmsgtag = msgtag;
1934 parm->ipflags1 = (IPRMDATA | IPNORPY | flags1);
1935 memcpy(parm->iprmmsg, prmmsg, sizeof(parm->iprmmsg));
1936
1937 b2f0_result = b2f0(SEND, parm);
1938
1939 if ((!b2f0_result) && (msgid))
1940 *msgid = parm->ipmsgid;
1941 release_param(parm);
1942
1943 iucv_debug(2, "exiting");
1944
1945 return b2f0_result;
1946 }
1947
1948 /*
1949 * Name: iucv_send2way
1950 * Purpose: This function transmits data to another application.
1951 * Data to be transmitted is in a buffer. The receiver
1952 * of the send is expected to reply to the message and
1953 * a buffer is provided into which IUCV moves the reply
1954 * to this message.
1955 * Input: pathid - path identification number
1956 * trgcls - specifies target class
1957 * srccls - specifies the source message class
1958 * msgtag - specifies a tag associated with the message
1959 * flags1 - option for path
1960 * IPPRTY- specifies if you want to send priority message
1961 * buffer - address of send buffer
1962 * buflen - length of send buffer
1963 * ansbuf - address of buffer to reply with
1964 * anslen - length of buffer to reply with
1965 * Output: msgid - specifies the message ID.
1966 * Return: b2f0_result - return code from CP
1967 * (-EINVAL) - buffer or ansbuf address is NULL
1968 */
1969 int
1970 iucv_send2way (__u16 pathid,
1971 __u32 * msgid,
1972 __u32 trgcls,
1973 __u32 srccls,
1974 __u32 msgtag,
1975 int flags1,
1976 void *buffer, ulong buflen, void *ansbuf, ulong anslen)
1977 {
1978 iparml_db *parm;
1979 ulong b2f0_result;
1980
1981 iucv_debug(2, "entering");
1982
1983 if (!buffer || !ansbuf)
1984 return -EINVAL;
1985
1986 parm = (iparml_db *)grab_param();
1987
1988 parm->ippathid = pathid;
1989 parm->iptrgcls = trgcls;
1990 parm->ipbfadr1 = (__u32) ((ulong) buffer);
1991 parm->ipbfln1f = (__u32) buflen; /* length of message */
1992 parm->ipbfadr2 = (__u32) ((ulong) ansbuf);
1993 parm->ipbfln2f = (__u32) anslen;
1994 parm->ipsrccls = srccls;
1995 parm->ipmsgtag = msgtag;
1996 parm->ipflags1 = flags1; /* priority message */
1997
1998 b2f0_result = b2f0(SEND, parm);
1999
2000 if ((!b2f0_result) && (msgid))
2001 *msgid = parm->ipmsgid;
2002 release_param(parm);
2003
2004 iucv_debug(2, "exiting");
2005
2006 return b2f0_result;
2007 }
2008
2009 /*
2010 * Name: iucv_send2way_array
2011 * Purpose: This function transmits data to another application.
2012 * The contents of buffer is the address of the array of
2013 * addresses and lengths of discontiguous buffers that hold
2014 * the message text. The receiver of the send is expected to
2015 * reply to the message and a buffer is provided into which
2016 * IUCV moves the reply to this message.
2017 * Input: pathid - path identification number
2018 * trgcls - specifies target class
2019 * srccls - specifies the source message class
2020 * msgtag - spcifies a tag to be associated with the message
2021 * flags1 - option for path
2022 * IPPRTY- specifies if you want to send priority message
2023 * buffer - address of array of send buffers
2024 * buflen - total length of send buffers
2025 * ansbuf - address of buffer to reply with
2026 * anslen - length of buffer to reply with
2027 * Output: msgid - specifies the message ID.
2028 * Return: b2f0_result - return code from CP
2029 * (-EINVAL) - buffer address is NULL
2030 */
2031 int
2032 iucv_send2way_array (__u16 pathid,
2033 __u32 * msgid,
2034 __u32 trgcls,
2035 __u32 srccls,
2036 __u32 msgtag,
2037 int flags1,
2038 iucv_array_t * buffer,
2039 ulong buflen, iucv_array_t * ansbuf, ulong anslen)
2040 {
2041 iparml_db *parm;
2042 ulong b2f0_result;
2043
2044 iucv_debug(2, "entering");
2045
2046 if (!buffer || !ansbuf)
2047 return -EINVAL;
2048
2049 parm = (iparml_db *)grab_param();
2050
2051 parm->ippathid = pathid;
2052 parm->iptrgcls = trgcls;
2053 parm->ipbfadr1 = (__u32) ((ulong) buffer);
2054 parm->ipbfln1f = (__u32) buflen; /* length of message */
2055 parm->ipbfadr2 = (__u32) ((ulong) ansbuf);
2056 parm->ipbfln2f = (__u32) anslen;
2057 parm->ipsrccls = srccls;
2058 parm->ipmsgtag = msgtag;
2059 parm->ipflags1 = (IPBUFLST | IPANSLST | flags1);
2060 b2f0_result = b2f0(SEND, parm);
2061 if ((!b2f0_result) && (msgid))
2062 *msgid = parm->ipmsgid;
2063 release_param(parm);
2064
2065 iucv_debug(2, "exiting");
2066 return b2f0_result;
2067 }
2068
2069 /*
2070 * Name: iucv_send2way_prmmsg
2071 * Purpose: This function transmits data to another application.
2072 * Prmmsg specifies that the 8-bytes of data are to be moved
2073 * into the parameter list. This is a two-way message and the
2074 * receiver of the message is expected to reply. A buffer
2075 * is provided into which IUCV moves the reply to this
2076 * message.
2077 * Input: pathid - path identification number
2078 * trgcls - specifies target class
2079 * srccls - specifies the source message class
2080 * msgtag - specifies a tag to be associated with the message
2081 * flags1 - option for path
2082 * IPPRTY- specifies if you want to send priority message
2083 * prmmsg - 8-bytes of data to be placed in parameter list
2084 * ansbuf - address of buffer to reply with
2085 * anslen - length of buffer to reply with
2086 * Output: msgid - specifies the message ID.
2087 * Return: b2f0_result - return code from CP
2088 * (-EINVAL) - buffer address is NULL
2089 */
2090 int
2091 iucv_send2way_prmmsg (__u16 pathid,
2092 __u32 * msgid,
2093 __u32 trgcls,
2094 __u32 srccls,
2095 __u32 msgtag,
2096 ulong flags1, __u8 prmmsg[8], void *ansbuf, ulong anslen)
2097 {
2098 iparml_dpl *parm;
2099 ulong b2f0_result;
2100
2101 iucv_debug(2, "entering");
2102
2103 if (!ansbuf)
2104 return -EINVAL;
2105
2106 parm = (iparml_dpl *)grab_param();
2107
2108 parm->ippathid = pathid;
2109 parm->iptrgcls = trgcls;
2110 parm->ipsrccls = srccls;
2111 parm->ipmsgtag = msgtag;
2112 parm->ipbfadr2 = (__u32) ((ulong) ansbuf);
2113 parm->ipbfln2f = (__u32) anslen;
2114 parm->ipflags1 = (IPRMDATA | flags1); /* message in prmlist */
2115 memcpy(parm->iprmmsg, prmmsg, sizeof(parm->iprmmsg));
2116
2117 b2f0_result = b2f0(SEND, parm);
2118
2119 if ((!b2f0_result) && (msgid))
2120 *msgid = parm->ipmsgid;
2121 release_param(parm);
2122
2123 iucv_debug(2, "exiting");
2124
2125 return b2f0_result;
2126 }
2127
2128 /*
2129 * Name: iucv_send2way_prmmsg_array
2130 * Purpose: This function transmits data to another application.
2131 * Prmmsg specifies that the 8-bytes of data are to be moved
2132 * into the parameter list. This is a two-way message and the
2133 * receiver of the message is expected to reply. A buffer
2134 * is provided into which IUCV moves the reply to this
2135 * message. The contents of ansbuf is the address of the
2136 * array of addresses and lengths of discontiguous buffers
2137 * that contain the reply.
2138 * Input: pathid - path identification number
2139 * trgcls - specifies target class
2140 * srccls - specifies the source message class
2141 * msgtag - specifies a tag to be associated with the message
2142 * flags1 - option for path
2143 * IPPRTY- specifies if you want to send priority message
2144 * prmmsg - 8-bytes of data to be placed into the parameter list
2145 * ansbuf - address of buffer to reply with
2146 * anslen - length of buffer to reply with
2147 * Output: msgid - specifies the message ID.
2148 * Return: b2f0_result - return code from CP
2149 * (-EINVAL) - ansbuf address is NULL
2150 */
2151 int
2152 iucv_send2way_prmmsg_array (__u16 pathid,
2153 __u32 * msgid,
2154 __u32 trgcls,
2155 __u32 srccls,
2156 __u32 msgtag,
2157 int flags1,
2158 __u8 prmmsg[8],
2159 iucv_array_t * ansbuf, ulong anslen)
2160 {
2161 iparml_dpl *parm;
2162 ulong b2f0_result;
2163
2164 iucv_debug(2, "entering");
2165
2166 if (!ansbuf)
2167 return -EINVAL;
2168
2169 parm = (iparml_dpl *)grab_param();
2170
2171 parm->ippathid = pathid;
2172 parm->iptrgcls = trgcls;
2173 parm->ipsrccls = srccls;
2174 parm->ipmsgtag = msgtag;
2175 parm->ipbfadr2 = (__u32) ((ulong) ansbuf);
2176 parm->ipbfln2f = (__u32) anslen;
2177 parm->ipflags1 = (IPRMDATA | IPANSLST | flags1);
2178 memcpy(parm->iprmmsg, prmmsg, sizeof(parm->iprmmsg));
2179 b2f0_result = b2f0(SEND, parm);
2180 if ((!b2f0_result) && (msgid))
2181 *msgid = parm->ipmsgid;
2182 release_param(parm);
2183
2184 iucv_debug(2, "exiting");
2185 return b2f0_result;
2186 }
2187
2188 void
2189 iucv_setmask_cpuid (void *result)
2190 {
2191 iparml_set_mask *parm;
2192
2193 iucv_debug(1, "entering");
2194 parm = (iparml_set_mask *)grab_param();
2195 parm->ipmask = *((__u8*)result);
2196 *((ulong *)result) = b2f0(SETMASK, parm);
2197 release_param(parm);
2198
2199 iucv_debug(1, "b2f0_result = %ld", *((ulong *)result));
2200 iucv_debug(1, "exiting");
2201 }
2202
2203 /*
2204 * Name: iucv_setmask
2205 * Purpose: This function enables or disables the following IUCV
2206 * external interruptions: Nonpriority and priority message
2207 * interrupts, nonpriority and priority reply interrupts.
2208 * Input: SetMaskFlag - options for interrupts
2209 * 0x80 - Nonpriority_MessagePendingInterruptsFlag
2210 * 0x40 - Priority_MessagePendingInterruptsFlag
2211 * 0x20 - Nonpriority_MessageCompletionInterruptsFlag
2212 * 0x10 - Priority_MessageCompletionInterruptsFlag
2213 * 0x08 - IUCVControlInterruptsFlag
2214 * Output: NA
2215 * Return: b2f0_result - return code from CP
2216 */
2217 int
2218 iucv_setmask (int SetMaskFlag)
2219 {
2220 union {
2221 ulong result;
2222 __u8 param;
2223 } u;
2224 int cpu;
2225
2226 u.param = SetMaskFlag;
2227 cpu = get_cpu();
2228 smp_call_function_on(iucv_setmask_cpuid, &u, 0, 1, iucv_cpuid);
2229 put_cpu();
2230
2231 return u.result;
2232 }
2233
2234 /**
2235 * iucv_sever:
2236 * @pathid: Path identification number
2237 * @user_data: 16-byte of user data
2238 *
2239 * This function terminates an iucv path.
2240 * Returns: return code from CP
2241 */
2242 int
2243 iucv_sever(__u16 pathid, __u8 user_data[16])
2244 {
2245 iparml_control *parm;
2246 ulong b2f0_result = 0;
2247
2248 iucv_debug(1, "entering");
2249 parm = (iparml_control *)grab_param();
2250
2251 memcpy(parm->ipuser, user_data, sizeof(parm->ipuser));
2252 parm->ippathid = pathid;
2253
2254 b2f0_result = b2f0(SEVER, parm);
2255
2256 if (!b2f0_result)
2257 iucv_remove_pathid(pathid);
2258 release_param(parm);
2259
2260 iucv_debug(1, "exiting");
2261 return b2f0_result;
2262 }
2263
2264 /*
2265 * Interrupt Handlers
2266 *******************************************************************************/
2267
2268 /**
2269 * iucv_irq_handler:
2270 * @regs: Current registers
2271 * @code: irq code
2272 *
2273 * Handles external interrupts coming in from CP.
2274 * Places the interrupt buffer on a queue and schedules iucv_tasklet_handler().
2275 */
2276 static void
2277 iucv_irq_handler(struct pt_regs *regs, __u16 code)
2278 {
2279 iucv_irqdata *irqdata;
2280
2281 irqdata = kmalloc(sizeof(iucv_irqdata), GFP_ATOMIC);
2282 if (!irqdata) {
2283 printk(KERN_WARNING "%s: out of memory\n", __FUNCTION__);
2284 return;
2285 }
2286
2287 memcpy(&irqdata->data, iucv_external_int_buffer,
2288 sizeof(iucv_GeneralInterrupt));
2289
2290 spin_lock(&iucv_irq_queue_lock);
2291 list_add_tail(&irqdata->queue, &iucv_irq_queue);
2292 spin_unlock(&iucv_irq_queue_lock);
2293
2294 tasklet_schedule(&iucv_tasklet);
2295 }
2296
2297 /**
2298 * iucv_do_int:
2299 * @int_buf: Pointer to copy of external interrupt buffer
2300 *
2301 * The workhorse for handling interrupts queued by iucv_irq_handler().
2302 * This function is called from the bottom half iucv_tasklet_handler().
2303 */
2304 static void
2305 iucv_do_int(iucv_GeneralInterrupt * int_buf)
2306 {
2307 handler *h = NULL;
2308 struct list_head *lh;
2309 ulong flags;
2310 iucv_interrupt_ops_t *interrupt = NULL; /* interrupt addresses */
2311 __u8 temp_buff1[24], temp_buff2[24]; /* masked handler id. */
2312 int rc = 0, j = 0;
2313 __u8 no_listener[16] = "NO LISTENER";
2314
2315 iucv_debug(2, "entering, pathid %d, type %02X",
2316 int_buf->ippathid, int_buf->iptype);
2317 iucv_dumpit("External Interrupt Buffer:",
2318 int_buf, sizeof(iucv_GeneralInterrupt));
2319
2320 ASCEBC (no_listener, 16);
2321
2322 if (int_buf->iptype != 01) {
2323 if ((int_buf->ippathid) > (max_connections - 1)) {
2324 printk(KERN_WARNING "%s: Got interrupt with pathid %d"
2325 " > max_connections (%ld)\n", __FUNCTION__,
2326 int_buf->ippathid, max_connections - 1);
2327 } else {
2328 h = iucv_pathid_table[int_buf->ippathid];
2329 interrupt = h->interrupt_table;
2330 iucv_dumpit("Handler:", h, sizeof(handler));
2331 }
2332 }
2333
2334 /* end of if statement */
2335 switch (int_buf->iptype) {
2336 case 0x01: /* connection pending */
2337 if (messagesDisabled) {
2338 iucv_setmask(~0);
2339 messagesDisabled = 0;
2340 }
2341 spin_lock_irqsave(&iucv_lock, flags);
2342 list_for_each(lh, &iucv_handler_table) {
2343 h = list_entry(lh, handler, list);
2344 memcpy(temp_buff1, &(int_buf->ipvmid), 24);
2345 memcpy(temp_buff2, &(h->id.userid), 24);
2346 for (j = 0; j < 24; j++) {
2347 temp_buff1[j] &= (h->id.mask)[j];
2348 temp_buff2[j] &= (h->id.mask)[j];
2349 }
2350
2351 iucv_dumpit("temp_buff1:",
2352 temp_buff1, sizeof(temp_buff1));
2353 iucv_dumpit("temp_buff2",
2354 temp_buff2, sizeof(temp_buff2));
2355
2356 if (!memcmp (temp_buff1, temp_buff2, 24)) {
2357
2358 iucv_debug(2,
2359 "found a matching handler");
2360 break;
2361 } else
2362 h = NULL;
2363 }
2364 spin_unlock_irqrestore (&iucv_lock, flags);
2365 if (h) {
2366 /* ADD PATH TO PATHID TABLE */
2367 rc = iucv_add_pathid(int_buf->ippathid, h);
2368 if (rc) {
2369 iucv_sever (int_buf->ippathid,
2370 no_listener);
2371 iucv_debug(1,
2372 "add_pathid failed, rc = %d",
2373 rc);
2374 } else {
2375 interrupt = h->interrupt_table;
2376 if (interrupt->ConnectionPending) {
2377 EBCASC (int_buf->ipvmid, 8);
2378 interrupt->ConnectionPending(
2379 (iucv_ConnectionPending *)int_buf,
2380 h->pgm_data);
2381 } else
2382 iucv_sever(int_buf->ippathid,
2383 no_listener);
2384 }
2385 } else
2386 iucv_sever(int_buf->ippathid, no_listener);
2387 break;
2388
2389 case 0x02: /*connection complete */
2390 if (messagesDisabled) {
2391 iucv_setmask(~0);
2392 messagesDisabled = 0;
2393 }
2394 if (h) {
2395 if (interrupt->ConnectionComplete)
2396 {
2397 interrupt->ConnectionComplete(
2398 (iucv_ConnectionComplete *)int_buf,
2399 h->pgm_data);
2400 }
2401 else
2402 iucv_debug(1,
2403 "ConnectionComplete not called");
2404 } else
2405 iucv_sever(int_buf->ippathid, no_listener);
2406 break;
2407
2408 case 0x03: /* connection severed */
2409 if (messagesDisabled) {
2410 iucv_setmask(~0);
2411 messagesDisabled = 0;
2412 }
2413 if (h) {
2414 if (interrupt->ConnectionSevered)
2415 interrupt->ConnectionSevered(
2416 (iucv_ConnectionSevered *)int_buf,
2417 h->pgm_data);
2418
2419 else
2420 iucv_sever (int_buf->ippathid, no_listener);
2421 } else
2422 iucv_sever(int_buf->ippathid, no_listener);
2423 break;
2424
2425 case 0x04: /* connection quiesced */
2426 if (messagesDisabled) {
2427 iucv_setmask(~0);
2428 messagesDisabled = 0;
2429 }
2430 if (h) {
2431 if (interrupt->ConnectionQuiesced)
2432 interrupt->ConnectionQuiesced(
2433 (iucv_ConnectionQuiesced *)int_buf,
2434 h->pgm_data);
2435 else
2436 iucv_debug(1,
2437 "ConnectionQuiesced not called");
2438 }
2439 break;
2440
2441 case 0x05: /* connection resumed */
2442 if (messagesDisabled) {
2443 iucv_setmask(~0);
2444 messagesDisabled = 0;
2445 }
2446 if (h) {
2447 if (interrupt->ConnectionResumed)
2448 interrupt->ConnectionResumed(
2449 (iucv_ConnectionResumed *)int_buf,
2450 h->pgm_data);
2451 else
2452 iucv_debug(1,
2453 "ConnectionResumed not called");
2454 }
2455 break;
2456
2457 case 0x06: /* priority message complete */
2458 case 0x07: /* nonpriority message complete */
2459 if (h) {
2460 if (interrupt->MessageComplete)
2461 interrupt->MessageComplete(
2462 (iucv_MessageComplete *)int_buf,
2463 h->pgm_data);
2464 else
2465 iucv_debug(2,
2466 "MessageComplete not called");
2467 }
2468 break;
2469
2470 case 0x08: /* priority message pending */
2471 case 0x09: /* nonpriority message pending */
2472 if (h) {
2473 if (interrupt->MessagePending)
2474 interrupt->MessagePending(
2475 (iucv_MessagePending *) int_buf,
2476 h->pgm_data);
2477 else
2478 iucv_debug(2,
2479 "MessagePending not called");
2480 }
2481 break;
2482 default: /* unknown iucv type */
2483 printk(KERN_WARNING "%s: unknown iucv interrupt\n",
2484 __FUNCTION__);
2485 break;
2486 } /* end switch */
2487
2488 iucv_debug(2, "exiting pathid %d, type %02X",
2489 int_buf->ippathid, int_buf->iptype);
2490
2491 return;
2492 }
2493
2494 /**
2495 * iucv_tasklet_handler:
2496 *
2497 * This function loops over the queue of irq buffers and runs iucv_do_int()
2498 * on every queue element.
2499 */
2500 static void
2501 iucv_tasklet_handler(unsigned long ignored)
2502 {
2503 struct list_head head;
2504 struct list_head *next;
2505 ulong flags;
2506
2507 spin_lock_irqsave(&iucv_irq_queue_lock, flags);
2508 list_add(&head, &iucv_irq_queue);
2509 list_del_init(&iucv_irq_queue);
2510 spin_unlock_irqrestore (&iucv_irq_queue_lock, flags);
2511
2512 next = head.next;
2513 while (next != &head) {
2514 iucv_irqdata *p = list_entry(next, iucv_irqdata, queue);
2515
2516 next = next->next;
2517 iucv_do_int(&p->data);
2518 kfree(p);
2519 }
2520
2521 return;
2522 }
2523
2524 subsys_initcall(iucv_init);
2525 module_exit(iucv_exit);
2526
2527 /**
2528 * Export all public stuff
2529 */
2530 EXPORT_SYMBOL (iucv_bus);
2531 EXPORT_SYMBOL (iucv_root);
2532 EXPORT_SYMBOL (iucv_accept);
2533 EXPORT_SYMBOL (iucv_connect);
2534 #if 0
2535 EXPORT_SYMBOL (iucv_purge);
2536 EXPORT_SYMBOL (iucv_query_maxconn);
2537 EXPORT_SYMBOL (iucv_query_bufsize);
2538 EXPORT_SYMBOL (iucv_quiesce);
2539 #endif
2540 EXPORT_SYMBOL (iucv_receive);
2541 #if 0
2542 EXPORT_SYMBOL (iucv_receive_array);
2543 #endif
2544 EXPORT_SYMBOL (iucv_reject);
2545 #if 0
2546 EXPORT_SYMBOL (iucv_reply);
2547 EXPORT_SYMBOL (iucv_reply_array);
2548 EXPORT_SYMBOL (iucv_resume);
2549 #endif
2550 EXPORT_SYMBOL (iucv_reply_prmmsg);
2551 EXPORT_SYMBOL (iucv_send);
2552 EXPORT_SYMBOL (iucv_send2way);
2553 EXPORT_SYMBOL (iucv_send2way_array);
2554 EXPORT_SYMBOL (iucv_send2way_prmmsg);
2555 EXPORT_SYMBOL (iucv_send2way_prmmsg_array);
2556 #if 0
2557 EXPORT_SYMBOL (iucv_send_array);
2558 EXPORT_SYMBOL (iucv_send_prmmsg);
2559 EXPORT_SYMBOL (iucv_setmask);
2560 #endif
2561 EXPORT_SYMBOL (iucv_sever);
2562 EXPORT_SYMBOL (iucv_register_program);
2563 EXPORT_SYMBOL (iucv_unregister_program);
Linux kernel - Deliverables
This page took 0.087696 seconds and 5 git commands to generate.