2 * IUCV base infrastructure.
4 * Copyright IBM Corp. 2001, 2009
8 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
9 * Xenia Tkatschow (xenia@us.ibm.com)
10 * 2Gb awareness and general cleanup:
11 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
12 * Rewritten for af_iucv:
13 * Martin Schwidefsky <schwidefsky@de.ibm.com>
15 * Ursula Braun (ursula.braun@de.ibm.com)
19 * CP Programming Service, IBM document # SC24-5760
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 2, or (at your option)
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
36 #define KMSG_COMPONENT "iucv"
37 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
39 #include <linux/module.h>
40 #include <linux/moduleparam.h>
41 #include <linux/spinlock.h>
42 #include <linux/kernel.h>
43 #include <linux/slab.h>
44 #include <linux/init.h>
45 #include <linux/interrupt.h>
46 #include <linux/list.h>
47 #include <linux/errno.h>
48 #include <linux/err.h>
49 #include <linux/device.h>
50 #include <linux/cpu.h>
51 #include <linux/reboot.h>
52 #include <net/iucv/iucv.h>
53 #include <asm/atomic.h>
54 #include <asm/ebcdic.h>
56 #include <asm/s390_ext.h>
61 * All flags are defined in the field IPFLAGS1 of each function
62 * and can be found in CP Programming Services.
63 * IPSRCCLS - Indicates you have specified a source class.
64 * IPTRGCLS - Indicates you have specified a target class.
65 * IPFGPID - Indicates you have specified a pathid.
66 * IPFGMID - Indicates you have specified a message ID.
67 * IPNORPY - Indicates a one-way message. No reply expected.
68 * IPALL - Indicates that all paths are affected.
70 #define IUCV_IPSRCCLS 0x01
71 #define IUCV_IPTRGCLS 0x01
72 #define IUCV_IPFGPID 0x02
73 #define IUCV_IPFGMID 0x04
74 #define IUCV_IPNORPY 0x10
75 #define IUCV_IPALL 0x80
77 static int iucv_bus_match(struct device
*dev
, struct device_driver
*drv
)
86 IUCV_PM_RESTORING
= 3,
88 static enum iucv_pm_states iucv_pm_state
;
90 static int iucv_pm_prepare(struct device
*);
91 static void iucv_pm_complete(struct device
*);
92 static int iucv_pm_freeze(struct device
*);
93 static int iucv_pm_thaw(struct device
*);
94 static int iucv_pm_restore(struct device
*);
96 static struct dev_pm_ops iucv_pm_ops
= {
97 .prepare
= iucv_pm_prepare
,
98 .complete
= iucv_pm_complete
,
99 .freeze
= iucv_pm_freeze
,
100 .thaw
= iucv_pm_thaw
,
101 .restore
= iucv_pm_restore
,
104 struct bus_type iucv_bus
= {
106 .match
= iucv_bus_match
,
109 EXPORT_SYMBOL(iucv_bus
);
111 struct device
*iucv_root
;
112 EXPORT_SYMBOL(iucv_root
);
114 static int iucv_available
;
116 /* General IUCV interrupt structure */
117 struct iucv_irq_data
{
124 struct iucv_irq_list
{
125 struct list_head list
;
126 struct iucv_irq_data data
;
129 static struct iucv_irq_data
*iucv_irq_data
[NR_CPUS
];
130 static cpumask_t iucv_buffer_cpumask
= CPU_MASK_NONE
;
131 static cpumask_t iucv_irq_cpumask
= CPU_MASK_NONE
;
134 * Queue of interrupt buffers lock for delivery via the tasklet
135 * (fast but can't call smp_call_function).
137 static LIST_HEAD(iucv_task_queue
);
140 * The tasklet for fast delivery of iucv interrupts.
142 static void iucv_tasklet_fn(unsigned long);
143 static DECLARE_TASKLET(iucv_tasklet
, iucv_tasklet_fn
,0);
146 * Queue of interrupt buffers for delivery via a work queue
147 * (slower but can call smp_call_function).
149 static LIST_HEAD(iucv_work_queue
);
152 * The work element to deliver path pending interrupts.
154 static void iucv_work_fn(struct work_struct
*work
);
155 static DECLARE_WORK(iucv_work
, iucv_work_fn
);
158 * Spinlock protecting task and work queue.
160 static DEFINE_SPINLOCK(iucv_queue_lock
);
162 enum iucv_command_codes
{
164 IUCV_RETRIEVE_BUFFER
= 2,
172 IUCV_DECLARE_BUFFER
= 12,
177 IUCV_SETCONTROLMASK
= 17,
181 * Error messages that are used with the iucv_sever function. They get
182 * converted to EBCDIC.
184 static char iucv_error_no_listener
[16] = "NO LISTENER";
185 static char iucv_error_no_memory
[16] = "NO MEMORY";
186 static char iucv_error_pathid
[16] = "INVALID PATHID";
189 * iucv_handler_list: List of registered handlers.
191 static LIST_HEAD(iucv_handler_list
);
194 * iucv_path_table: an array of iucv_path structures.
196 static struct iucv_path
**iucv_path_table
;
197 static unsigned long iucv_max_pathid
;
200 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table
202 static DEFINE_SPINLOCK(iucv_table_lock
);
205 * iucv_active_cpu: contains the number of the cpu executing the tasklet
206 * or the work handler. Needed for iucv_path_sever called from tasklet.
208 static int iucv_active_cpu
= -1;
211 * Mutex and wait queue for iucv_register/iucv_unregister.
213 static DEFINE_MUTEX(iucv_register_mutex
);
216 * Counter for number of non-smp capable handlers.
218 static int iucv_nonsmp_handler
;
221 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,
222 * iucv_path_quiesce and iucv_path_sever.
224 struct iucv_cmd_control
{
233 } __attribute__ ((packed
,aligned(8)));
236 * Data in parameter list iucv structure. Used by iucv_message_send,
237 * iucv_message_send2way and iucv_message_reply.
239 struct iucv_cmd_dpl
{
251 } __attribute__ ((packed
,aligned(8)));
254 * Data in buffer iucv structure. Used by iucv_message_receive,
255 * iucv_message_reject, iucv_message_send, iucv_message_send2way
256 * and iucv_declare_cpu.
271 } __attribute__ ((packed
,aligned(8)));
274 * Purge message iucv structure. Used by iucv_message_purge.
276 struct iucv_cmd_purge
{
287 } __attribute__ ((packed
,aligned(8)));
290 * Set mask iucv structure. Used by iucv_enable_cpu.
292 struct iucv_cmd_set_mask
{
297 } __attribute__ ((packed
,aligned(8)));
300 struct iucv_cmd_control ctrl
;
301 struct iucv_cmd_dpl dpl
;
302 struct iucv_cmd_db db
;
303 struct iucv_cmd_purge purge
;
304 struct iucv_cmd_set_mask set_mask
;
308 * Anchor for per-cpu IUCV command parameter block.
310 static union iucv_param
*iucv_param
[NR_CPUS
];
311 static union iucv_param
*iucv_param_irq
[NR_CPUS
];
315 * @code: identifier of IUCV call to CP.
316 * @parm: pointer to a struct iucv_parm block
318 * Calls CP to execute IUCV commands.
320 * Returns the result of the CP IUCV call.
322 static inline int iucv_call_b2f0(int command
, union iucv_param
*parm
)
324 register unsigned long reg0
asm ("0");
325 register unsigned long reg1
asm ("1");
329 reg1
= virt_to_phys(parm
);
331 " .long 0xb2f01000\n"
334 : "=d" (ccode
), "=m" (*parm
), "+d" (reg0
), "+a" (reg1
)
335 : "m" (*parm
) : "cc");
336 return (ccode
== 1) ? parm
->ctrl
.iprcode
: ccode
;
342 * Determines the maximum number of connections that may be established.
344 * Returns the maximum number of connections or -EPERM is IUCV is not
347 static int iucv_query_maxconn(void)
349 register unsigned long reg0
asm ("0");
350 register unsigned long reg1
asm ("1");
354 param
= kzalloc(sizeof(union iucv_param
), GFP_KERNEL
|GFP_DMA
);
358 reg1
= (unsigned long) param
;
360 " .long 0xb2f01000\n"
363 : "=d" (ccode
), "+d" (reg0
), "+d" (reg1
) : : "cc");
365 iucv_max_pathid
= reg1
;
367 return ccode
? -EPERM
: 0;
374 * Allow iucv interrupts on this cpu.
376 static void iucv_allow_cpu(void *data
)
378 int cpu
= smp_processor_id();
379 union iucv_param
*parm
;
382 * Enable all iucv interrupts.
383 * ipmask contains bits for the different interrupts
384 * 0x80 - Flag to allow nonpriority message pending interrupts
385 * 0x40 - Flag to allow priority message pending interrupts
386 * 0x20 - Flag to allow nonpriority message completion interrupts
387 * 0x10 - Flag to allow priority message completion interrupts
388 * 0x08 - Flag to allow IUCV control interrupts
390 parm
= iucv_param_irq
[cpu
];
391 memset(parm
, 0, sizeof(union iucv_param
));
392 parm
->set_mask
.ipmask
= 0xf8;
393 iucv_call_b2f0(IUCV_SETMASK
, parm
);
396 * Enable all iucv control interrupts.
397 * ipmask contains bits for the different interrupts
398 * 0x80 - Flag to allow pending connections interrupts
399 * 0x40 - Flag to allow connection complete interrupts
400 * 0x20 - Flag to allow connection severed interrupts
401 * 0x10 - Flag to allow connection quiesced interrupts
402 * 0x08 - Flag to allow connection resumed interrupts
404 memset(parm
, 0, sizeof(union iucv_param
));
405 parm
->set_mask
.ipmask
= 0xf8;
406 iucv_call_b2f0(IUCV_SETCONTROLMASK
, parm
);
407 /* Set indication that iucv interrupts are allowed for this cpu. */
408 cpu_set(cpu
, iucv_irq_cpumask
);
415 * Block iucv interrupts on this cpu.
417 static void iucv_block_cpu(void *data
)
419 int cpu
= smp_processor_id();
420 union iucv_param
*parm
;
422 /* Disable all iucv interrupts. */
423 parm
= iucv_param_irq
[cpu
];
424 memset(parm
, 0, sizeof(union iucv_param
));
425 iucv_call_b2f0(IUCV_SETMASK
, parm
);
427 /* Clear indication that iucv interrupts are allowed for this cpu. */
428 cpu_clear(cpu
, iucv_irq_cpumask
);
432 * iucv_block_cpu_almost
435 * Allow connection-severed interrupts only on this cpu.
437 static void iucv_block_cpu_almost(void *data
)
439 int cpu
= smp_processor_id();
440 union iucv_param
*parm
;
442 /* Allow iucv control interrupts only */
443 parm
= iucv_param_irq
[cpu
];
444 memset(parm
, 0, sizeof(union iucv_param
));
445 parm
->set_mask
.ipmask
= 0x08;
446 iucv_call_b2f0(IUCV_SETMASK
, parm
);
447 /* Allow iucv-severed interrupt only */
448 memset(parm
, 0, sizeof(union iucv_param
));
449 parm
->set_mask
.ipmask
= 0x20;
450 iucv_call_b2f0(IUCV_SETCONTROLMASK
, parm
);
452 /* Clear indication that iucv interrupts are allowed for this cpu. */
453 cpu_clear(cpu
, iucv_irq_cpumask
);
460 * Declare a interrupt buffer on this cpu.
462 static void iucv_declare_cpu(void *data
)
464 int cpu
= smp_processor_id();
465 union iucv_param
*parm
;
468 if (cpu_isset(cpu
, iucv_buffer_cpumask
))
471 /* Declare interrupt buffer. */
472 parm
= iucv_param_irq
[cpu
];
473 memset(parm
, 0, sizeof(union iucv_param
));
474 parm
->db
.ipbfadr1
= virt_to_phys(iucv_irq_data
[cpu
]);
475 rc
= iucv_call_b2f0(IUCV_DECLARE_BUFFER
, parm
);
477 char *err
= "Unknown";
480 err
= "Directory error";
483 err
= "Invalid length";
486 err
= "Buffer already exists";
489 err
= "Buffer overlap";
492 err
= "Paging or storage error";
495 pr_warning("Defining an interrupt buffer on CPU %i"
496 " failed with 0x%02x (%s)\n", cpu
, rc
, err
);
500 /* Set indication that an iucv buffer exists for this cpu. */
501 cpu_set(cpu
, iucv_buffer_cpumask
);
503 if (iucv_nonsmp_handler
== 0 || cpus_empty(iucv_irq_cpumask
))
504 /* Enable iucv interrupts on this cpu. */
505 iucv_allow_cpu(NULL
);
507 /* Disable iucv interrupts on this cpu. */
508 iucv_block_cpu(NULL
);
515 * Retrieve interrupt buffer on this cpu.
517 static void iucv_retrieve_cpu(void *data
)
519 int cpu
= smp_processor_id();
520 union iucv_param
*parm
;
522 if (!cpu_isset(cpu
, iucv_buffer_cpumask
))
525 /* Block iucv interrupts. */
526 iucv_block_cpu(NULL
);
528 /* Retrieve interrupt buffer. */
529 parm
= iucv_param_irq
[cpu
];
530 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER
, parm
);
532 /* Clear indication that an iucv buffer exists for this cpu. */
533 cpu_clear(cpu
, iucv_buffer_cpumask
);
539 * Allow iucv interrupts on all cpus.
541 static void iucv_setmask_mp(void)
546 for_each_online_cpu(cpu
)
547 /* Enable all cpus with a declared buffer. */
548 if (cpu_isset(cpu
, iucv_buffer_cpumask
) &&
549 !cpu_isset(cpu
, iucv_irq_cpumask
))
550 smp_call_function_single(cpu
, iucv_allow_cpu
,
558 * Allow iucv interrupts on a single cpu.
560 static void iucv_setmask_up(void)
565 /* Disable all cpu but the first in cpu_irq_cpumask. */
566 cpumask
= iucv_irq_cpumask
;
567 cpu_clear(first_cpu(iucv_irq_cpumask
), cpumask
);
568 for_each_cpu_mask_nr(cpu
, cpumask
)
569 smp_call_function_single(cpu
, iucv_block_cpu
, NULL
, 1);
575 * This function makes iucv ready for use. It allocates the pathid
576 * table, declares an iucv interrupt buffer and enables the iucv
577 * interrupts. Called when the first user has registered an iucv
580 static int iucv_enable(void)
587 alloc_size
= iucv_max_pathid
* sizeof(struct iucv_path
);
588 iucv_path_table
= kzalloc(alloc_size
, GFP_KERNEL
);
589 if (!iucv_path_table
)
591 /* Declare per cpu buffers. */
593 for_each_online_cpu(cpu
)
594 smp_call_function_single(cpu
, iucv_declare_cpu
, NULL
, 1);
595 if (cpus_empty(iucv_buffer_cpumask
))
596 /* No cpu could declare an iucv buffer. */
601 kfree(iucv_path_table
);
602 iucv_path_table
= NULL
;
610 * This function shuts down iucv. It disables iucv interrupts, retrieves
611 * the iucv interrupt buffer and frees the pathid table. Called after the
612 * last user unregister its iucv handler.
614 static void iucv_disable(void)
617 on_each_cpu(iucv_retrieve_cpu
, NULL
, 1);
618 kfree(iucv_path_table
);
619 iucv_path_table
= NULL
;
623 static int __cpuinit
iucv_cpu_notify(struct notifier_block
*self
,
624 unsigned long action
, void *hcpu
)
627 long cpu
= (long) hcpu
;
631 case CPU_UP_PREPARE_FROZEN
:
632 iucv_irq_data
[cpu
] = kmalloc_node(sizeof(struct iucv_irq_data
),
633 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
634 if (!iucv_irq_data
[cpu
])
636 iucv_param
[cpu
] = kmalloc_node(sizeof(union iucv_param
),
637 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
638 if (!iucv_param
[cpu
]) {
639 kfree(iucv_irq_data
[cpu
]);
640 iucv_irq_data
[cpu
] = NULL
;
643 iucv_param_irq
[cpu
] = kmalloc_node(sizeof(union iucv_param
),
644 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
645 if (!iucv_param_irq
[cpu
]) {
646 kfree(iucv_param
[cpu
]);
647 iucv_param
[cpu
] = NULL
;
648 kfree(iucv_irq_data
[cpu
]);
649 iucv_irq_data
[cpu
] = NULL
;
653 case CPU_UP_CANCELED
:
654 case CPU_UP_CANCELED_FROZEN
:
656 case CPU_DEAD_FROZEN
:
657 kfree(iucv_param_irq
[cpu
]);
658 iucv_param_irq
[cpu
] = NULL
;
659 kfree(iucv_param
[cpu
]);
660 iucv_param
[cpu
] = NULL
;
661 kfree(iucv_irq_data
[cpu
]);
662 iucv_irq_data
[cpu
] = NULL
;
665 case CPU_ONLINE_FROZEN
:
666 case CPU_DOWN_FAILED
:
667 case CPU_DOWN_FAILED_FROZEN
:
668 if (!iucv_path_table
)
670 smp_call_function_single(cpu
, iucv_declare_cpu
, NULL
, 1);
672 case CPU_DOWN_PREPARE
:
673 case CPU_DOWN_PREPARE_FROZEN
:
674 if (!iucv_path_table
)
676 cpumask
= iucv_buffer_cpumask
;
677 cpu_clear(cpu
, cpumask
);
678 if (cpus_empty(cpumask
))
679 /* Can't offline last IUCV enabled cpu. */
681 smp_call_function_single(cpu
, iucv_retrieve_cpu
, NULL
, 1);
682 if (cpus_empty(iucv_irq_cpumask
))
683 smp_call_function_single(first_cpu(iucv_buffer_cpumask
),
684 iucv_allow_cpu
, NULL
, 1);
690 static struct notifier_block __refdata iucv_cpu_notifier
= {
691 .notifier_call
= iucv_cpu_notify
,
696 * @pathid: path identification number.
697 * @userdata: 16-bytes of user data.
699 * Sever an iucv path to free up the pathid. Used internally.
701 static int iucv_sever_pathid(u16 pathid
, u8 userdata
[16])
703 union iucv_param
*parm
;
705 parm
= iucv_param_irq
[smp_processor_id()];
706 memset(parm
, 0, sizeof(union iucv_param
));
708 memcpy(parm
->ctrl
.ipuser
, userdata
, sizeof(parm
->ctrl
.ipuser
));
709 parm
->ctrl
.ippathid
= pathid
;
710 return iucv_call_b2f0(IUCV_SEVER
, parm
);
714 * __iucv_cleanup_queue
715 * @dummy: unused dummy argument
717 * Nop function called via smp_call_function to force work items from
718 * pending external iucv interrupts to the work queue.
720 static void __iucv_cleanup_queue(void *dummy
)
727 * Function called after a path has been severed to find all remaining
728 * work items for the now stale pathid. The caller needs to hold the
731 static void iucv_cleanup_queue(void)
733 struct iucv_irq_list
*p
, *n
;
736 * When a path is severed, the pathid can be reused immediatly
737 * on a iucv connect or a connection pending interrupt. Remove
738 * all entries from the task queue that refer to a stale pathid
739 * (iucv_path_table[ix] == NULL). Only then do the iucv connect
740 * or deliver the connection pending interrupt. To get all the
741 * pending interrupts force them to the work queue by calling
742 * an empty function on all cpus.
744 smp_call_function(__iucv_cleanup_queue
, NULL
, 1);
745 spin_lock_irq(&iucv_queue_lock
);
746 list_for_each_entry_safe(p
, n
, &iucv_task_queue
, list
) {
747 /* Remove stale work items from the task queue. */
748 if (iucv_path_table
[p
->data
.ippathid
] == NULL
) {
753 spin_unlock_irq(&iucv_queue_lock
);
758 * @handler: address of iucv handler structure
759 * @smp: != 0 indicates that the handler can deal with out of order messages
761 * Registers a driver with IUCV.
763 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid
764 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
766 int iucv_register(struct iucv_handler
*handler
, int smp
)
772 mutex_lock(&iucv_register_mutex
);
774 iucv_nonsmp_handler
++;
775 if (list_empty(&iucv_handler_list
)) {
779 } else if (!smp
&& iucv_nonsmp_handler
== 1)
781 INIT_LIST_HEAD(&handler
->paths
);
783 spin_lock_bh(&iucv_table_lock
);
784 list_add_tail(&handler
->list
, &iucv_handler_list
);
785 spin_unlock_bh(&iucv_table_lock
);
788 mutex_unlock(&iucv_register_mutex
);
791 EXPORT_SYMBOL(iucv_register
);
795 * @handler: address of iucv handler structure
796 * @smp: != 0 indicates that the handler can deal with out of order messages
798 * Unregister driver from IUCV.
800 void iucv_unregister(struct iucv_handler
*handler
, int smp
)
802 struct iucv_path
*p
, *n
;
804 mutex_lock(&iucv_register_mutex
);
805 spin_lock_bh(&iucv_table_lock
);
806 /* Remove handler from the iucv_handler_list. */
807 list_del_init(&handler
->list
);
808 /* Sever all pathids still refering to the handler. */
809 list_for_each_entry_safe(p
, n
, &handler
->paths
, list
) {
810 iucv_sever_pathid(p
->pathid
, NULL
);
811 iucv_path_table
[p
->pathid
] = NULL
;
815 spin_unlock_bh(&iucv_table_lock
);
817 iucv_nonsmp_handler
--;
818 if (list_empty(&iucv_handler_list
))
820 else if (!smp
&& iucv_nonsmp_handler
== 0)
822 mutex_unlock(&iucv_register_mutex
);
824 EXPORT_SYMBOL(iucv_unregister
);
826 static int iucv_reboot_event(struct notifier_block
*this,
827 unsigned long event
, void *ptr
)
832 on_each_cpu(iucv_block_cpu
, NULL
, 1);
834 for (i
= 0; i
< iucv_max_pathid
; i
++) {
835 if (iucv_path_table
[i
])
836 rc
= iucv_sever_pathid(i
, NULL
);
844 static struct notifier_block iucv_reboot_notifier
= {
845 .notifier_call
= iucv_reboot_event
,
850 * @path: address of iucv path structure
851 * @handler: address of iucv handler structure
852 * @userdata: 16 bytes of data reflected to the communication partner
853 * @private: private data passed to interrupt handlers for this path
855 * This function is issued after the user received a connection pending
856 * external interrupt and now wishes to complete the IUCV communication path.
858 * Returns the result of the CP IUCV call.
860 int iucv_path_accept(struct iucv_path
*path
, struct iucv_handler
*handler
,
861 u8 userdata
[16], void *private)
863 union iucv_param
*parm
;
867 if (cpus_empty(iucv_buffer_cpumask
)) {
871 /* Prepare parameter block. */
872 parm
= iucv_param
[smp_processor_id()];
873 memset(parm
, 0, sizeof(union iucv_param
));
874 parm
->ctrl
.ippathid
= path
->pathid
;
875 parm
->ctrl
.ipmsglim
= path
->msglim
;
877 memcpy(parm
->ctrl
.ipuser
, userdata
, sizeof(parm
->ctrl
.ipuser
));
878 parm
->ctrl
.ipflags1
= path
->flags
;
880 rc
= iucv_call_b2f0(IUCV_ACCEPT
, parm
);
882 path
->private = private;
883 path
->msglim
= parm
->ctrl
.ipmsglim
;
884 path
->flags
= parm
->ctrl
.ipflags1
;
890 EXPORT_SYMBOL(iucv_path_accept
);
894 * @path: address of iucv path structure
895 * @handler: address of iucv handler structure
896 * @userid: 8-byte user identification
897 * @system: 8-byte target system identification
898 * @userdata: 16 bytes of data reflected to the communication partner
899 * @private: private data passed to interrupt handlers for this path
901 * This function establishes an IUCV path. Although the connect may complete
902 * successfully, you are not able to use the path until you receive an IUCV
903 * Connection Complete external interrupt.
905 * Returns the result of the CP IUCV call.
907 int iucv_path_connect(struct iucv_path
*path
, struct iucv_handler
*handler
,
908 u8 userid
[8], u8 system
[8], u8 userdata
[16],
911 union iucv_param
*parm
;
914 spin_lock_bh(&iucv_table_lock
);
915 iucv_cleanup_queue();
916 if (cpus_empty(iucv_buffer_cpumask
)) {
920 parm
= iucv_param
[smp_processor_id()];
921 memset(parm
, 0, sizeof(union iucv_param
));
922 parm
->ctrl
.ipmsglim
= path
->msglim
;
923 parm
->ctrl
.ipflags1
= path
->flags
;
925 memcpy(parm
->ctrl
.ipvmid
, userid
, sizeof(parm
->ctrl
.ipvmid
));
926 ASCEBC(parm
->ctrl
.ipvmid
, sizeof(parm
->ctrl
.ipvmid
));
927 EBC_TOUPPER(parm
->ctrl
.ipvmid
, sizeof(parm
->ctrl
.ipvmid
));
930 memcpy(parm
->ctrl
.iptarget
, system
,
931 sizeof(parm
->ctrl
.iptarget
));
932 ASCEBC(parm
->ctrl
.iptarget
, sizeof(parm
->ctrl
.iptarget
));
933 EBC_TOUPPER(parm
->ctrl
.iptarget
, sizeof(parm
->ctrl
.iptarget
));
936 memcpy(parm
->ctrl
.ipuser
, userdata
, sizeof(parm
->ctrl
.ipuser
));
938 rc
= iucv_call_b2f0(IUCV_CONNECT
, parm
);
940 if (parm
->ctrl
.ippathid
< iucv_max_pathid
) {
941 path
->pathid
= parm
->ctrl
.ippathid
;
942 path
->msglim
= parm
->ctrl
.ipmsglim
;
943 path
->flags
= parm
->ctrl
.ipflags1
;
944 path
->handler
= handler
;
945 path
->private = private;
946 list_add_tail(&path
->list
, &handler
->paths
);
947 iucv_path_table
[path
->pathid
] = path
;
949 iucv_sever_pathid(parm
->ctrl
.ippathid
,
955 spin_unlock_bh(&iucv_table_lock
);
958 EXPORT_SYMBOL(iucv_path_connect
);
962 * @path: address of iucv path structure
963 * @userdata: 16 bytes of data reflected to the communication partner
965 * This function temporarily suspends incoming messages on an IUCV path.
966 * You can later reactivate the path by invoking the iucv_resume function.
968 * Returns the result from the CP IUCV call.
970 int iucv_path_quiesce(struct iucv_path
*path
, u8 userdata
[16])
972 union iucv_param
*parm
;
976 if (cpus_empty(iucv_buffer_cpumask
)) {
980 parm
= iucv_param
[smp_processor_id()];
981 memset(parm
, 0, sizeof(union iucv_param
));
983 memcpy(parm
->ctrl
.ipuser
, userdata
, sizeof(parm
->ctrl
.ipuser
));
984 parm
->ctrl
.ippathid
= path
->pathid
;
985 rc
= iucv_call_b2f0(IUCV_QUIESCE
, parm
);
990 EXPORT_SYMBOL(iucv_path_quiesce
);
994 * @path: address of iucv path structure
995 * @userdata: 16 bytes of data reflected to the communication partner
997 * This function resumes incoming messages on an IUCV path that has
998 * been stopped with iucv_path_quiesce.
1000 * Returns the result from the CP IUCV call.
1002 int iucv_path_resume(struct iucv_path
*path
, u8 userdata
[16])
1004 union iucv_param
*parm
;
1008 if (cpus_empty(iucv_buffer_cpumask
)) {
1012 parm
= iucv_param
[smp_processor_id()];
1013 memset(parm
, 0, sizeof(union iucv_param
));
1015 memcpy(parm
->ctrl
.ipuser
, userdata
, sizeof(parm
->ctrl
.ipuser
));
1016 parm
->ctrl
.ippathid
= path
->pathid
;
1017 rc
= iucv_call_b2f0(IUCV_RESUME
, parm
);
1025 * @path: address of iucv path structure
1026 * @userdata: 16 bytes of data reflected to the communication partner
1028 * This function terminates an IUCV path.
1030 * Returns the result from the CP IUCV call.
1032 int iucv_path_sever(struct iucv_path
*path
, u8 userdata
[16])
1037 if (cpus_empty(iucv_buffer_cpumask
)) {
1041 if (iucv_active_cpu
!= smp_processor_id())
1042 spin_lock_bh(&iucv_table_lock
);
1043 rc
= iucv_sever_pathid(path
->pathid
, userdata
);
1044 iucv_path_table
[path
->pathid
] = NULL
;
1045 list_del_init(&path
->list
);
1046 if (iucv_active_cpu
!= smp_processor_id())
1047 spin_unlock_bh(&iucv_table_lock
);
1052 EXPORT_SYMBOL(iucv_path_sever
);
1055 * iucv_message_purge
1056 * @path: address of iucv path structure
1057 * @msg: address of iucv msg structure
1058 * @srccls: source class of message
1060 * Cancels a message you have sent.
1062 * Returns the result from the CP IUCV call.
1064 int iucv_message_purge(struct iucv_path
*path
, struct iucv_message
*msg
,
1067 union iucv_param
*parm
;
1071 if (cpus_empty(iucv_buffer_cpumask
)) {
1075 parm
= iucv_param
[smp_processor_id()];
1076 memset(parm
, 0, sizeof(union iucv_param
));
1077 parm
->purge
.ippathid
= path
->pathid
;
1078 parm
->purge
.ipmsgid
= msg
->id
;
1079 parm
->purge
.ipsrccls
= srccls
;
1080 parm
->purge
.ipflags1
= IUCV_IPSRCCLS
| IUCV_IPFGMID
| IUCV_IPFGPID
;
1081 rc
= iucv_call_b2f0(IUCV_PURGE
, parm
);
1083 msg
->audit
= (*(u32
*) &parm
->purge
.ipaudit
) >> 8;
1084 msg
->tag
= parm
->purge
.ipmsgtag
;
1090 EXPORT_SYMBOL(iucv_message_purge
);
1093 * iucv_message_receive_iprmdata
1094 * @path: address of iucv path structure
1095 * @msg: address of iucv msg structure
1096 * @flags: how the message is received (IUCV_IPBUFLST)
1097 * @buffer: address of data buffer or address of struct iucv_array
1098 * @size: length of data buffer
1101 * Internal function used by iucv_message_receive and __iucv_message_receive
1102 * to receive RMDATA data stored in struct iucv_message.
1104 static int iucv_message_receive_iprmdata(struct iucv_path
*path
,
1105 struct iucv_message
*msg
,
1106 u8 flags
, void *buffer
,
1107 size_t size
, size_t *residual
)
1109 struct iucv_array
*array
;
1114 * Message is 8 bytes long and has been stored to the
1115 * message descriptor itself.
1118 *residual
= abs(size
- 8);
1120 if (flags
& IUCV_IPBUFLST
) {
1121 /* Copy to struct iucv_array. */
1122 size
= (size
< 8) ? size
: 8;
1123 for (array
= buffer
; size
> 0; array
++) {
1124 copy
= min_t(size_t, size
, array
->length
);
1125 memcpy((u8
*)(addr_t
) array
->address
,
1131 /* Copy to direct buffer. */
1132 memcpy(buffer
, rmmsg
, min_t(size_t, size
, 8));
1138 * __iucv_message_receive
1139 * @path: address of iucv path structure
1140 * @msg: address of iucv msg structure
1141 * @flags: how the message is received (IUCV_IPBUFLST)
1142 * @buffer: address of data buffer or address of struct iucv_array
1143 * @size: length of data buffer
1146 * This function receives messages that are being sent to you over
1147 * established paths. This function will deal with RMDATA messages
1148 * embedded in struct iucv_message as well.
1150 * Locking: no locking
1152 * Returns the result from the CP IUCV call.
1154 int __iucv_message_receive(struct iucv_path
*path
, struct iucv_message
*msg
,
1155 u8 flags
, void *buffer
, size_t size
, size_t *residual
)
1157 union iucv_param
*parm
;
1160 if (msg
->flags
& IUCV_IPRMDATA
)
1161 return iucv_message_receive_iprmdata(path
, msg
, flags
,
1162 buffer
, size
, residual
);
1163 if (cpus_empty(iucv_buffer_cpumask
)) {
1167 parm
= iucv_param
[smp_processor_id()];
1168 memset(parm
, 0, sizeof(union iucv_param
));
1169 parm
->db
.ipbfadr1
= (u32
)(addr_t
) buffer
;
1170 parm
->db
.ipbfln1f
= (u32
) size
;
1171 parm
->db
.ipmsgid
= msg
->id
;
1172 parm
->db
.ippathid
= path
->pathid
;
1173 parm
->db
.iptrgcls
= msg
->class;
1174 parm
->db
.ipflags1
= (flags
| IUCV_IPFGPID
|
1175 IUCV_IPFGMID
| IUCV_IPTRGCLS
);
1176 rc
= iucv_call_b2f0(IUCV_RECEIVE
, parm
);
1177 if (!rc
|| rc
== 5) {
1178 msg
->flags
= parm
->db
.ipflags1
;
1180 *residual
= parm
->db
.ipbfln1f
;
1185 EXPORT_SYMBOL(__iucv_message_receive
);
1188 * iucv_message_receive
1189 * @path: address of iucv path structure
1190 * @msg: address of iucv msg structure
1191 * @flags: how the message is received (IUCV_IPBUFLST)
1192 * @buffer: address of data buffer or address of struct iucv_array
1193 * @size: length of data buffer
1196 * This function receives messages that are being sent to you over
1197 * established paths. This function will deal with RMDATA messages
1198 * embedded in struct iucv_message as well.
1200 * Locking: local_bh_enable/local_bh_disable
1202 * Returns the result from the CP IUCV call.
1204 int iucv_message_receive(struct iucv_path
*path
, struct iucv_message
*msg
,
1205 u8 flags
, void *buffer
, size_t size
, size_t *residual
)
1209 if (msg
->flags
& IUCV_IPRMDATA
)
1210 return iucv_message_receive_iprmdata(path
, msg
, flags
,
1211 buffer
, size
, residual
);
1213 rc
= __iucv_message_receive(path
, msg
, flags
, buffer
, size
, residual
);
1217 EXPORT_SYMBOL(iucv_message_receive
);
1220 * iucv_message_reject
1221 * @path: address of iucv path structure
1222 * @msg: address of iucv msg structure
1224 * The reject function refuses a specified message. Between the time you
1225 * are notified of a message and the time that you complete the message,
1226 * the message may be rejected.
1228 * Returns the result from the CP IUCV call.
1230 int iucv_message_reject(struct iucv_path
*path
, struct iucv_message
*msg
)
1232 union iucv_param
*parm
;
1236 if (cpus_empty(iucv_buffer_cpumask
)) {
1240 parm
= iucv_param
[smp_processor_id()];
1241 memset(parm
, 0, sizeof(union iucv_param
));
1242 parm
->db
.ippathid
= path
->pathid
;
1243 parm
->db
.ipmsgid
= msg
->id
;
1244 parm
->db
.iptrgcls
= msg
->class;
1245 parm
->db
.ipflags1
= (IUCV_IPTRGCLS
| IUCV_IPFGMID
| IUCV_IPFGPID
);
1246 rc
= iucv_call_b2f0(IUCV_REJECT
, parm
);
1251 EXPORT_SYMBOL(iucv_message_reject
);
1254 * iucv_message_reply
1255 * @path: address of iucv path structure
1256 * @msg: address of iucv msg structure
1257 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1258 * @reply: address of reply data buffer or address of struct iucv_array
1259 * @size: length of reply data buffer
1261 * This function responds to the two-way messages that you receive. You
1262 * must identify completely the message to which you wish to reply. ie,
1263 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
1264 * the parameter list.
1266 * Returns the result from the CP IUCV call.
1268 int iucv_message_reply(struct iucv_path
*path
, struct iucv_message
*msg
,
1269 u8 flags
, void *reply
, size_t size
)
1271 union iucv_param
*parm
;
1275 if (cpus_empty(iucv_buffer_cpumask
)) {
1279 parm
= iucv_param
[smp_processor_id()];
1280 memset(parm
, 0, sizeof(union iucv_param
));
1281 if (flags
& IUCV_IPRMDATA
) {
1282 parm
->dpl
.ippathid
= path
->pathid
;
1283 parm
->dpl
.ipflags1
= flags
;
1284 parm
->dpl
.ipmsgid
= msg
->id
;
1285 parm
->dpl
.iptrgcls
= msg
->class;
1286 memcpy(parm
->dpl
.iprmmsg
, reply
, min_t(size_t, size
, 8));
1288 parm
->db
.ipbfadr1
= (u32
)(addr_t
) reply
;
1289 parm
->db
.ipbfln1f
= (u32
) size
;
1290 parm
->db
.ippathid
= path
->pathid
;
1291 parm
->db
.ipflags1
= flags
;
1292 parm
->db
.ipmsgid
= msg
->id
;
1293 parm
->db
.iptrgcls
= msg
->class;
1295 rc
= iucv_call_b2f0(IUCV_REPLY
, parm
);
1300 EXPORT_SYMBOL(iucv_message_reply
);
1303 * __iucv_message_send
1304 * @path: address of iucv path structure
1305 * @msg: address of iucv msg structure
1306 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1307 * @srccls: source class of message
1308 * @buffer: address of send buffer or address of struct iucv_array
1309 * @size: length of send buffer
1311 * This function transmits data to another application. Data to be
1312 * transmitted is in a buffer and this is a one-way message and the
1313 * receiver will not reply to the message.
1315 * Locking: no locking
1317 * Returns the result from the CP IUCV call.
1319 int __iucv_message_send(struct iucv_path
*path
, struct iucv_message
*msg
,
1320 u8 flags
, u32 srccls
, void *buffer
, size_t size
)
1322 union iucv_param
*parm
;
1325 if (cpus_empty(iucv_buffer_cpumask
)) {
1329 parm
= iucv_param
[smp_processor_id()];
1330 memset(parm
, 0, sizeof(union iucv_param
));
1331 if (flags
& IUCV_IPRMDATA
) {
1332 /* Message of 8 bytes can be placed into the parameter list. */
1333 parm
->dpl
.ippathid
= path
->pathid
;
1334 parm
->dpl
.ipflags1
= flags
| IUCV_IPNORPY
;
1335 parm
->dpl
.iptrgcls
= msg
->class;
1336 parm
->dpl
.ipsrccls
= srccls
;
1337 parm
->dpl
.ipmsgtag
= msg
->tag
;
1338 memcpy(parm
->dpl
.iprmmsg
, buffer
, 8);
1340 parm
->db
.ipbfadr1
= (u32
)(addr_t
) buffer
;
1341 parm
->db
.ipbfln1f
= (u32
) size
;
1342 parm
->db
.ippathid
= path
->pathid
;
1343 parm
->db
.ipflags1
= flags
| IUCV_IPNORPY
;
1344 parm
->db
.iptrgcls
= msg
->class;
1345 parm
->db
.ipsrccls
= srccls
;
1346 parm
->db
.ipmsgtag
= msg
->tag
;
1348 rc
= iucv_call_b2f0(IUCV_SEND
, parm
);
1350 msg
->id
= parm
->db
.ipmsgid
;
1354 EXPORT_SYMBOL(__iucv_message_send
);
1358 * @path: address of iucv path structure
1359 * @msg: address of iucv msg structure
1360 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1361 * @srccls: source class of message
1362 * @buffer: address of send buffer or address of struct iucv_array
1363 * @size: length of send buffer
1365 * This function transmits data to another application. Data to be
1366 * transmitted is in a buffer and this is a one-way message and the
1367 * receiver will not reply to the message.
1369 * Locking: local_bh_enable/local_bh_disable
1371 * Returns the result from the CP IUCV call.
1373 int iucv_message_send(struct iucv_path
*path
, struct iucv_message
*msg
,
1374 u8 flags
, u32 srccls
, void *buffer
, size_t size
)
1379 rc
= __iucv_message_send(path
, msg
, flags
, srccls
, buffer
, size
);
1383 EXPORT_SYMBOL(iucv_message_send
);
1386 * iucv_message_send2way
1387 * @path: address of iucv path structure
1388 * @msg: address of iucv msg structure
1389 * @flags: how the message is sent and the reply is received
1390 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
1391 * @srccls: source class of message
1392 * @buffer: address of send buffer or address of struct iucv_array
1393 * @size: length of send buffer
1394 * @ansbuf: address of answer buffer or address of struct iucv_array
1395 * @asize: size of reply buffer
1397 * This function transmits data to another application. Data to be
1398 * transmitted is in a buffer. The receiver of the send is expected to
1399 * reply to the message and a buffer is provided into which IUCV moves
1400 * the reply to this message.
1402 * Returns the result from the CP IUCV call.
1404 int iucv_message_send2way(struct iucv_path
*path
, struct iucv_message
*msg
,
1405 u8 flags
, u32 srccls
, void *buffer
, size_t size
,
1406 void *answer
, size_t asize
, size_t *residual
)
1408 union iucv_param
*parm
;
1412 if (cpus_empty(iucv_buffer_cpumask
)) {
1416 parm
= iucv_param
[smp_processor_id()];
1417 memset(parm
, 0, sizeof(union iucv_param
));
1418 if (flags
& IUCV_IPRMDATA
) {
1419 parm
->dpl
.ippathid
= path
->pathid
;
1420 parm
->dpl
.ipflags1
= path
->flags
; /* priority message */
1421 parm
->dpl
.iptrgcls
= msg
->class;
1422 parm
->dpl
.ipsrccls
= srccls
;
1423 parm
->dpl
.ipmsgtag
= msg
->tag
;
1424 parm
->dpl
.ipbfadr2
= (u32
)(addr_t
) answer
;
1425 parm
->dpl
.ipbfln2f
= (u32
) asize
;
1426 memcpy(parm
->dpl
.iprmmsg
, buffer
, 8);
1428 parm
->db
.ippathid
= path
->pathid
;
1429 parm
->db
.ipflags1
= path
->flags
; /* priority message */
1430 parm
->db
.iptrgcls
= msg
->class;
1431 parm
->db
.ipsrccls
= srccls
;
1432 parm
->db
.ipmsgtag
= msg
->tag
;
1433 parm
->db
.ipbfadr1
= (u32
)(addr_t
) buffer
;
1434 parm
->db
.ipbfln1f
= (u32
) size
;
1435 parm
->db
.ipbfadr2
= (u32
)(addr_t
) answer
;
1436 parm
->db
.ipbfln2f
= (u32
) asize
;
1438 rc
= iucv_call_b2f0(IUCV_SEND
, parm
);
1440 msg
->id
= parm
->db
.ipmsgid
;
1445 EXPORT_SYMBOL(iucv_message_send2way
);
1449 * @data: Pointer to external interrupt buffer
1451 * Process connection pending work item. Called from tasklet while holding
1454 struct iucv_path_pending
{
1465 } __attribute__ ((packed
));
1467 static void iucv_path_pending(struct iucv_irq_data
*data
)
1469 struct iucv_path_pending
*ipp
= (void *) data
;
1470 struct iucv_handler
*handler
;
1471 struct iucv_path
*path
;
1474 BUG_ON(iucv_path_table
[ipp
->ippathid
]);
1475 /* New pathid, handler found. Create a new path struct. */
1476 error
= iucv_error_no_memory
;
1477 path
= iucv_path_alloc(ipp
->ipmsglim
, ipp
->ipflags1
, GFP_ATOMIC
);
1480 path
->pathid
= ipp
->ippathid
;
1481 iucv_path_table
[path
->pathid
] = path
;
1482 EBCASC(ipp
->ipvmid
, 8);
1484 /* Call registered handler until one is found that wants the path. */
1485 list_for_each_entry(handler
, &iucv_handler_list
, list
) {
1486 if (!handler
->path_pending
)
1489 * Add path to handler to allow a call to iucv_path_sever
1490 * inside the path_pending function. If the handler returns
1491 * an error remove the path from the handler again.
1493 list_add(&path
->list
, &handler
->paths
);
1494 path
->handler
= handler
;
1495 if (!handler
->path_pending(path
, ipp
->ipvmid
, ipp
->ipuser
))
1497 list_del(&path
->list
);
1498 path
->handler
= NULL
;
1500 /* No handler wanted the path. */
1501 iucv_path_table
[path
->pathid
] = NULL
;
1502 iucv_path_free(path
);
1503 error
= iucv_error_no_listener
;
1505 iucv_sever_pathid(ipp
->ippathid
, error
);
1509 * iucv_path_complete
1510 * @data: Pointer to external interrupt buffer
1512 * Process connection complete work item. Called from tasklet while holding
1515 struct iucv_path_complete
{
1526 } __attribute__ ((packed
));
1528 static void iucv_path_complete(struct iucv_irq_data
*data
)
1530 struct iucv_path_complete
*ipc
= (void *) data
;
1531 struct iucv_path
*path
= iucv_path_table
[ipc
->ippathid
];
1534 path
->flags
= ipc
->ipflags1
;
1535 if (path
&& path
->handler
&& path
->handler
->path_complete
)
1536 path
->handler
->path_complete(path
, ipc
->ipuser
);
1541 * @data: Pointer to external interrupt buffer
1543 * Process connection severed work item. Called from tasklet while holding
1546 struct iucv_path_severed
{
1556 } __attribute__ ((packed
));
1558 static void iucv_path_severed(struct iucv_irq_data
*data
)
1560 struct iucv_path_severed
*ips
= (void *) data
;
1561 struct iucv_path
*path
= iucv_path_table
[ips
->ippathid
];
1563 if (!path
|| !path
->handler
) /* Already severed */
1565 if (path
->handler
->path_severed
)
1566 path
->handler
->path_severed(path
, ips
->ipuser
);
1568 iucv_sever_pathid(path
->pathid
, NULL
);
1569 iucv_path_table
[path
->pathid
] = NULL
;
1570 list_del(&path
->list
);
1571 iucv_path_free(path
);
1576 * iucv_path_quiesced
1577 * @data: Pointer to external interrupt buffer
1579 * Process connection quiesced work item. Called from tasklet while holding
1582 struct iucv_path_quiesced
{
1592 } __attribute__ ((packed
));
1594 static void iucv_path_quiesced(struct iucv_irq_data
*data
)
1596 struct iucv_path_quiesced
*ipq
= (void *) data
;
1597 struct iucv_path
*path
= iucv_path_table
[ipq
->ippathid
];
1599 if (path
&& path
->handler
&& path
->handler
->path_quiesced
)
1600 path
->handler
->path_quiesced(path
, ipq
->ipuser
);
1605 * @data: Pointer to external interrupt buffer
1607 * Process connection resumed work item. Called from tasklet while holding
1610 struct iucv_path_resumed
{
1620 } __attribute__ ((packed
));
1622 static void iucv_path_resumed(struct iucv_irq_data
*data
)
1624 struct iucv_path_resumed
*ipr
= (void *) data
;
1625 struct iucv_path
*path
= iucv_path_table
[ipr
->ippathid
];
1627 if (path
&& path
->handler
&& path
->handler
->path_resumed
)
1628 path
->handler
->path_resumed(path
, ipr
->ipuser
);
1632 * iucv_message_complete
1633 * @data: Pointer to external interrupt buffer
1635 * Process message complete work item. Called from tasklet while holding
1638 struct iucv_message_complete
{
1651 } __attribute__ ((packed
));
1653 static void iucv_message_complete(struct iucv_irq_data
*data
)
1655 struct iucv_message_complete
*imc
= (void *) data
;
1656 struct iucv_path
*path
= iucv_path_table
[imc
->ippathid
];
1657 struct iucv_message msg
;
1659 if (path
&& path
->handler
&& path
->handler
->message_complete
) {
1660 msg
.flags
= imc
->ipflags1
;
1661 msg
.id
= imc
->ipmsgid
;
1662 msg
.audit
= imc
->ipaudit
;
1663 memcpy(msg
.rmmsg
, imc
->iprmmsg
, 8);
1664 msg
.class = imc
->ipsrccls
;
1665 msg
.tag
= imc
->ipmsgtag
;
1666 msg
.length
= imc
->ipbfln2f
;
1667 path
->handler
->message_complete(path
, &msg
);
1672 * iucv_message_pending
1673 * @data: Pointer to external interrupt buffer
1675 * Process message pending work item. Called from tasklet while holding
1678 struct iucv_message_pending
{
1696 } __attribute__ ((packed
));
1698 static void iucv_message_pending(struct iucv_irq_data
*data
)
1700 struct iucv_message_pending
*imp
= (void *) data
;
1701 struct iucv_path
*path
= iucv_path_table
[imp
->ippathid
];
1702 struct iucv_message msg
;
1704 if (path
&& path
->handler
&& path
->handler
->message_pending
) {
1705 msg
.flags
= imp
->ipflags1
;
1706 msg
.id
= imp
->ipmsgid
;
1707 msg
.class = imp
->iptrgcls
;
1708 if (imp
->ipflags1
& IUCV_IPRMDATA
) {
1709 memcpy(msg
.rmmsg
, imp
->ln1msg1
.iprmmsg1
, 8);
1712 msg
.length
= imp
->ln1msg2
.ipbfln1f
;
1713 msg
.reply_size
= imp
->ipbfln2f
;
1714 path
->handler
->message_pending(path
, &msg
);
1721 * This tasklet loops over the queue of irq buffers created by
1722 * iucv_external_interrupt, calls the appropriate action handler
1723 * and then frees the buffer.
1725 static void iucv_tasklet_fn(unsigned long ignored
)
1727 typedef void iucv_irq_fn(struct iucv_irq_data
*);
1728 static iucv_irq_fn
*irq_fn
[] = {
1729 [0x02] = iucv_path_complete
,
1730 [0x03] = iucv_path_severed
,
1731 [0x04] = iucv_path_quiesced
,
1732 [0x05] = iucv_path_resumed
,
1733 [0x06] = iucv_message_complete
,
1734 [0x07] = iucv_message_complete
,
1735 [0x08] = iucv_message_pending
,
1736 [0x09] = iucv_message_pending
,
1738 LIST_HEAD(task_queue
);
1739 struct iucv_irq_list
*p
, *n
;
1741 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1742 if (!spin_trylock(&iucv_table_lock
)) {
1743 tasklet_schedule(&iucv_tasklet
);
1746 iucv_active_cpu
= smp_processor_id();
1748 spin_lock_irq(&iucv_queue_lock
);
1749 list_splice_init(&iucv_task_queue
, &task_queue
);
1750 spin_unlock_irq(&iucv_queue_lock
);
1752 list_for_each_entry_safe(p
, n
, &task_queue
, list
) {
1753 list_del_init(&p
->list
);
1754 irq_fn
[p
->data
.iptype
](&p
->data
);
1758 iucv_active_cpu
= -1;
1759 spin_unlock(&iucv_table_lock
);
1765 * This work function loops over the queue of path pending irq blocks
1766 * created by iucv_external_interrupt, calls the appropriate action
1767 * handler and then frees the buffer.
1769 static void iucv_work_fn(struct work_struct
*work
)
1771 LIST_HEAD(work_queue
);
1772 struct iucv_irq_list
*p
, *n
;
1774 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1775 spin_lock_bh(&iucv_table_lock
);
1776 iucv_active_cpu
= smp_processor_id();
1778 spin_lock_irq(&iucv_queue_lock
);
1779 list_splice_init(&iucv_work_queue
, &work_queue
);
1780 spin_unlock_irq(&iucv_queue_lock
);
1782 iucv_cleanup_queue();
1783 list_for_each_entry_safe(p
, n
, &work_queue
, list
) {
1784 list_del_init(&p
->list
);
1785 iucv_path_pending(&p
->data
);
1789 iucv_active_cpu
= -1;
1790 spin_unlock_bh(&iucv_table_lock
);
1794 * iucv_external_interrupt
1797 * Handles external interrupts coming in from CP.
1798 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().
1800 static void iucv_external_interrupt(u16 code
)
1802 struct iucv_irq_data
*p
;
1803 struct iucv_irq_list
*work
;
1805 p
= iucv_irq_data
[smp_processor_id()];
1806 if (p
->ippathid
>= iucv_max_pathid
) {
1807 WARN_ON(p
->ippathid
>= iucv_max_pathid
);
1808 iucv_sever_pathid(p
->ippathid
, iucv_error_no_listener
);
1811 BUG_ON(p
->iptype
< 0x01 || p
->iptype
> 0x09);
1812 work
= kmalloc(sizeof(struct iucv_irq_list
), GFP_ATOMIC
);
1814 pr_warning("iucv_external_interrupt: out of memory\n");
1817 memcpy(&work
->data
, p
, sizeof(work
->data
));
1818 spin_lock(&iucv_queue_lock
);
1819 if (p
->iptype
== 0x01) {
1820 /* Path pending interrupt. */
1821 list_add_tail(&work
->list
, &iucv_work_queue
);
1822 schedule_work(&iucv_work
);
1824 /* The other interrupts. */
1825 list_add_tail(&work
->list
, &iucv_task_queue
);
1826 tasklet_schedule(&iucv_tasklet
);
1828 spin_unlock(&iucv_queue_lock
);
1831 static int iucv_pm_prepare(struct device
*dev
)
1835 #ifdef CONFIG_PM_DEBUG
1836 printk(KERN_INFO
"iucv_pm_prepare\n");
1838 if (dev
->driver
&& dev
->driver
->pm
&& dev
->driver
->pm
->prepare
)
1839 rc
= dev
->driver
->pm
->prepare(dev
);
1843 static void iucv_pm_complete(struct device
*dev
)
1845 #ifdef CONFIG_PM_DEBUG
1846 printk(KERN_INFO
"iucv_pm_complete\n");
1848 if (dev
->driver
&& dev
->driver
->pm
&& dev
->driver
->pm
->complete
)
1849 dev
->driver
->pm
->complete(dev
);
1853 * iucv_path_table_empty() - determine if iucv path table is empty
1855 * Returns 0 if there are still iucv pathes defined
1856 * 1 if there are no iucv pathes defined
1858 int iucv_path_table_empty(void)
1862 for (i
= 0; i
< iucv_max_pathid
; i
++) {
1863 if (iucv_path_table
[i
])
1870 * iucv_pm_freeze() - Freeze PM callback
1871 * @dev: iucv-based device
1873 * disable iucv interrupts
1874 * invoke callback function of the iucv-based driver
1875 * shut down iucv, if no iucv-pathes are established anymore
1877 static int iucv_pm_freeze(struct device
*dev
)
1880 struct iucv_irq_list
*p
, *n
;
1883 #ifdef CONFIG_PM_DEBUG
1884 printk(KERN_WARNING
"iucv_pm_freeze\n");
1886 if (iucv_pm_state
!= IUCV_PM_FREEZING
) {
1887 for_each_cpu_mask_nr(cpu
, iucv_irq_cpumask
)
1888 smp_call_function_single(cpu
, iucv_block_cpu_almost
,
1890 cancel_work_sync(&iucv_work
);
1891 list_for_each_entry_safe(p
, n
, &iucv_work_queue
, list
) {
1892 list_del_init(&p
->list
);
1893 iucv_sever_pathid(p
->data
.ippathid
,
1894 iucv_error_no_listener
);
1898 iucv_pm_state
= IUCV_PM_FREEZING
;
1899 if (dev
->driver
&& dev
->driver
->pm
&& dev
->driver
->pm
->freeze
)
1900 rc
= dev
->driver
->pm
->freeze(dev
);
1901 if (iucv_path_table_empty())
1907 * iucv_pm_thaw() - Thaw PM callback
1908 * @dev: iucv-based device
1910 * make iucv ready for use again: allocate path table, declare interrupt buffers
1911 * and enable iucv interrupts
1912 * invoke callback function of the iucv-based driver
1914 static int iucv_pm_thaw(struct device
*dev
)
1918 #ifdef CONFIG_PM_DEBUG
1919 printk(KERN_WARNING
"iucv_pm_thaw\n");
1921 iucv_pm_state
= IUCV_PM_THAWING
;
1922 if (!iucv_path_table
) {
1927 if (cpus_empty(iucv_irq_cpumask
)) {
1928 if (iucv_nonsmp_handler
)
1929 /* enable interrupts on one cpu */
1930 iucv_allow_cpu(NULL
);
1932 /* enable interrupts on all cpus */
1935 if (dev
->driver
&& dev
->driver
->pm
&& dev
->driver
->pm
->thaw
)
1936 rc
= dev
->driver
->pm
->thaw(dev
);
1942 * iucv_pm_restore() - Restore PM callback
1943 * @dev: iucv-based device
1945 * make iucv ready for use again: allocate path table, declare interrupt buffers
1946 * and enable iucv interrupts
1947 * invoke callback function of the iucv-based driver
1949 static int iucv_pm_restore(struct device
*dev
)
1953 #ifdef CONFIG_PM_DEBUG
1954 printk(KERN_WARNING
"iucv_pm_restore %p\n", iucv_path_table
);
1956 if ((iucv_pm_state
!= IUCV_PM_RESTORING
) && iucv_path_table
)
1957 pr_warning("Suspending Linux did not completely close all IUCV "
1959 iucv_pm_state
= IUCV_PM_RESTORING
;
1960 if (cpus_empty(iucv_irq_cpumask
)) {
1961 rc
= iucv_query_maxconn();
1966 if (dev
->driver
&& dev
->driver
->pm
&& dev
->driver
->pm
->restore
)
1967 rc
= dev
->driver
->pm
->restore(dev
);
1975 * Allocates and initializes various data structures.
1977 static int __init
iucv_init(void)
1982 if (!MACHINE_IS_VM
) {
1983 rc
= -EPROTONOSUPPORT
;
1986 rc
= iucv_query_maxconn();
1989 rc
= register_external_interrupt(0x4000, iucv_external_interrupt
);
1992 iucv_root
= root_device_register("iucv");
1993 if (IS_ERR(iucv_root
)) {
1994 rc
= PTR_ERR(iucv_root
);
1998 for_each_online_cpu(cpu
) {
1999 /* Note: GFP_DMA used to get memory below 2G */
2000 iucv_irq_data
[cpu
] = kmalloc_node(sizeof(struct iucv_irq_data
),
2001 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
2002 if (!iucv_irq_data
[cpu
]) {
2007 /* Allocate parameter blocks. */
2008 iucv_param
[cpu
] = kmalloc_node(sizeof(union iucv_param
),
2009 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
2010 if (!iucv_param
[cpu
]) {
2014 iucv_param_irq
[cpu
] = kmalloc_node(sizeof(union iucv_param
),
2015 GFP_KERNEL
|GFP_DMA
, cpu_to_node(cpu
));
2016 if (!iucv_param_irq
[cpu
]) {
2022 rc
= register_hotcpu_notifier(&iucv_cpu_notifier
);
2025 rc
= register_reboot_notifier(&iucv_reboot_notifier
);
2028 ASCEBC(iucv_error_no_listener
, 16);
2029 ASCEBC(iucv_error_no_memory
, 16);
2030 ASCEBC(iucv_error_pathid
, 16);
2032 rc
= bus_register(&iucv_bus
);
2038 unregister_reboot_notifier(&iucv_reboot_notifier
);
2040 unregister_hotcpu_notifier(&iucv_cpu_notifier
);
2042 for_each_possible_cpu(cpu
) {
2043 kfree(iucv_param_irq
[cpu
]);
2044 iucv_param_irq
[cpu
] = NULL
;
2045 kfree(iucv_param
[cpu
]);
2046 iucv_param
[cpu
] = NULL
;
2047 kfree(iucv_irq_data
[cpu
]);
2048 iucv_irq_data
[cpu
] = NULL
;
2050 root_device_unregister(iucv_root
);
2052 unregister_external_interrupt(0x4000, iucv_external_interrupt
);
2060 * Frees everything allocated from iucv_init.
2062 static void __exit
iucv_exit(void)
2064 struct iucv_irq_list
*p
, *n
;
2067 spin_lock_irq(&iucv_queue_lock
);
2068 list_for_each_entry_safe(p
, n
, &iucv_task_queue
, list
)
2070 list_for_each_entry_safe(p
, n
, &iucv_work_queue
, list
)
2072 spin_unlock_irq(&iucv_queue_lock
);
2073 unregister_reboot_notifier(&iucv_reboot_notifier
);
2074 unregister_hotcpu_notifier(&iucv_cpu_notifier
);
2075 for_each_possible_cpu(cpu
) {
2076 kfree(iucv_param_irq
[cpu
]);
2077 iucv_param_irq
[cpu
] = NULL
;
2078 kfree(iucv_param
[cpu
]);
2079 iucv_param
[cpu
] = NULL
;
2080 kfree(iucv_irq_data
[cpu
]);
2081 iucv_irq_data
[cpu
] = NULL
;
2083 root_device_unregister(iucv_root
);
2084 bus_unregister(&iucv_bus
);
2085 unregister_external_interrupt(0x4000, iucv_external_interrupt
);
2088 subsys_initcall(iucv_init
);
2089 module_exit(iucv_exit
);
2091 MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2092 MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2093 MODULE_LICENSE("GPL");