blob: 8f156bd86be784584dbb03fcdfaa697d2bb569be [file] [log] [blame]
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001/*
2 * IUCV base infrastructure.
3 *
Ursula Braun6c005962009-06-16 10:30:41 +02004 * Copyright IBM Corp. 2001, 2009
5 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08006 * Author(s):
7 * Original source:
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>
Ursula Braun672e4052009-06-16 10:30:42 +020014 * PM functions:
15 * Ursula Braun (ursula.braun@de.ibm.com)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080016 *
17 * Documentation used:
18 * The original source
19 * CP Programming Service, IBM document # SC24-5760
20 *
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)
24 * any later version.
25 *
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.
30 *
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.
34 */
35
Ursula Braun8f7c5022008-12-25 13:39:47 +010036#define KMSG_COMPONENT "iucv"
37#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
38
Heiko Carstens052ff462011-01-05 12:47:28 +010039#include <linux/kernel_stat.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080040#include <linux/module.h>
41#include <linux/moduleparam.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080042#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 <linux/cpu.h>
Ursula Braun6c005962009-06-16 10:30:41 +020052#include <linux/reboot.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080053#include <net/iucv/iucv.h>
54#include <asm/atomic.h>
55#include <asm/ebcdic.h>
56#include <asm/io.h>
57#include <asm/s390_ext.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080058#include <asm/smp.h>
59
60/*
61 * FLAGS:
62 * All flags are defined in the field IPFLAGS1 of each function
63 * and can be found in CP Programming Services.
64 * IPSRCCLS - Indicates you have specified a source class.
65 * IPTRGCLS - Indicates you have specified a target class.
66 * IPFGPID - Indicates you have specified a pathid.
67 * IPFGMID - Indicates you have specified a message ID.
68 * IPNORPY - Indicates a one-way message. No reply expected.
69 * IPALL - Indicates that all paths are affected.
70 */
71#define IUCV_IPSRCCLS 0x01
72#define IUCV_IPTRGCLS 0x01
73#define IUCV_IPFGPID 0x02
74#define IUCV_IPFGMID 0x04
75#define IUCV_IPNORPY 0x10
76#define IUCV_IPALL 0x80
77
Heiko Carstensda99f052007-05-04 12:23:27 -070078static int iucv_bus_match(struct device *dev, struct device_driver *drv)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080079{
80 return 0;
81}
82
Ursula Braun4c89d862009-09-16 04:37:22 +000083enum iucv_pm_states {
84 IUCV_PM_INITIAL = 0,
85 IUCV_PM_FREEZING = 1,
86 IUCV_PM_THAWING = 2,
87 IUCV_PM_RESTORING = 3,
88};
89static enum iucv_pm_states iucv_pm_state;
90
Ursula Braun672e4052009-06-16 10:30:42 +020091static int iucv_pm_prepare(struct device *);
92static void iucv_pm_complete(struct device *);
93static int iucv_pm_freeze(struct device *);
94static int iucv_pm_thaw(struct device *);
95static int iucv_pm_restore(struct device *);
96
Alexey Dobriyan47145212009-12-14 18:00:08 -080097static const struct dev_pm_ops iucv_pm_ops = {
Ursula Braun672e4052009-06-16 10:30:42 +020098 .prepare = iucv_pm_prepare,
99 .complete = iucv_pm_complete,
100 .freeze = iucv_pm_freeze,
101 .thaw = iucv_pm_thaw,
102 .restore = iucv_pm_restore,
103};
104
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800105struct bus_type iucv_bus = {
106 .name = "iucv",
107 .match = iucv_bus_match,
Ursula Braun672e4052009-06-16 10:30:42 +0200108 .pm = &iucv_pm_ops,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800109};
Heiko Carstensda99f052007-05-04 12:23:27 -0700110EXPORT_SYMBOL(iucv_bus);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800111
112struct device *iucv_root;
Heiko Carstensda99f052007-05-04 12:23:27 -0700113EXPORT_SYMBOL(iucv_root);
114
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800115static int iucv_available;
116
117/* General IUCV interrupt structure */
118struct iucv_irq_data {
119 u16 ippathid;
120 u8 ipflags1;
121 u8 iptype;
122 u32 res2[8];
123};
124
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700125struct iucv_irq_list {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800126 struct list_head list;
127 struct iucv_irq_data data;
128};
129
Christoph Lameter70cf50352007-11-20 11:13:38 +0100130static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800131static cpumask_t iucv_buffer_cpumask = CPU_MASK_NONE;
132static cpumask_t iucv_irq_cpumask = CPU_MASK_NONE;
133
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700134/*
135 * Queue of interrupt buffers lock for delivery via the tasklet
136 * (fast but can't call smp_call_function).
137 */
138static LIST_HEAD(iucv_task_queue);
139
140/*
141 * The tasklet for fast delivery of iucv interrupts.
142 */
143static void iucv_tasklet_fn(unsigned long);
144static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0);
145
146/*
147 * Queue of interrupt buffers for delivery via a work queue
148 * (slower but can call smp_call_function).
149 */
150static LIST_HEAD(iucv_work_queue);
151
152/*
153 * The work element to deliver path pending interrupts.
154 */
155static void iucv_work_fn(struct work_struct *work);
156static DECLARE_WORK(iucv_work, iucv_work_fn);
157
158/*
159 * Spinlock protecting task and work queue.
160 */
161static DEFINE_SPINLOCK(iucv_queue_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800162
163enum iucv_command_codes {
164 IUCV_QUERY = 0,
165 IUCV_RETRIEVE_BUFFER = 2,
166 IUCV_SEND = 4,
167 IUCV_RECEIVE = 5,
168 IUCV_REPLY = 6,
169 IUCV_REJECT = 8,
170 IUCV_PURGE = 9,
171 IUCV_ACCEPT = 10,
172 IUCV_CONNECT = 11,
173 IUCV_DECLARE_BUFFER = 12,
174 IUCV_QUIESCE = 13,
175 IUCV_RESUME = 14,
176 IUCV_SEVER = 15,
177 IUCV_SETMASK = 16,
Ursula Braun672e4052009-06-16 10:30:42 +0200178 IUCV_SETCONTROLMASK = 17,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800179};
180
181/*
182 * Error messages that are used with the iucv_sever function. They get
183 * converted to EBCDIC.
184 */
185static char iucv_error_no_listener[16] = "NO LISTENER";
186static char iucv_error_no_memory[16] = "NO MEMORY";
187static char iucv_error_pathid[16] = "INVALID PATHID";
188
189/*
190 * iucv_handler_list: List of registered handlers.
191 */
192static LIST_HEAD(iucv_handler_list);
193
194/*
195 * iucv_path_table: an array of iucv_path structures.
196 */
197static struct iucv_path **iucv_path_table;
198static unsigned long iucv_max_pathid;
199
200/*
201 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table
202 */
203static DEFINE_SPINLOCK(iucv_table_lock);
204
205/*
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700206 * iucv_active_cpu: contains the number of the cpu executing the tasklet
207 * or the work handler. Needed for iucv_path_sever called from tasklet.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800208 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700209static int iucv_active_cpu = -1;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800210
211/*
212 * Mutex and wait queue for iucv_register/iucv_unregister.
213 */
214static DEFINE_MUTEX(iucv_register_mutex);
215
216/*
217 * Counter for number of non-smp capable handlers.
218 */
219static int iucv_nonsmp_handler;
220
221/*
222 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,
223 * iucv_path_quiesce and iucv_path_sever.
224 */
225struct iucv_cmd_control {
226 u16 ippathid;
227 u8 ipflags1;
228 u8 iprcode;
229 u16 ipmsglim;
230 u16 res1;
231 u8 ipvmid[8];
232 u8 ipuser[16];
233 u8 iptarget[8];
234} __attribute__ ((packed,aligned(8)));
235
236/*
237 * Data in parameter list iucv structure. Used by iucv_message_send,
238 * iucv_message_send2way and iucv_message_reply.
239 */
240struct iucv_cmd_dpl {
241 u16 ippathid;
242 u8 ipflags1;
243 u8 iprcode;
244 u32 ipmsgid;
245 u32 iptrgcls;
246 u8 iprmmsg[8];
247 u32 ipsrccls;
248 u32 ipmsgtag;
249 u32 ipbfadr2;
250 u32 ipbfln2f;
251 u32 res;
252} __attribute__ ((packed,aligned(8)));
253
254/*
255 * Data in buffer iucv structure. Used by iucv_message_receive,
256 * iucv_message_reject, iucv_message_send, iucv_message_send2way
257 * and iucv_declare_cpu.
258 */
259struct iucv_cmd_db {
260 u16 ippathid;
261 u8 ipflags1;
262 u8 iprcode;
263 u32 ipmsgid;
264 u32 iptrgcls;
265 u32 ipbfadr1;
266 u32 ipbfln1f;
267 u32 ipsrccls;
268 u32 ipmsgtag;
269 u32 ipbfadr2;
270 u32 ipbfln2f;
271 u32 res;
272} __attribute__ ((packed,aligned(8)));
273
274/*
275 * Purge message iucv structure. Used by iucv_message_purge.
276 */
277struct iucv_cmd_purge {
278 u16 ippathid;
279 u8 ipflags1;
280 u8 iprcode;
281 u32 ipmsgid;
282 u8 ipaudit[3];
283 u8 res1[5];
284 u32 res2;
285 u32 ipsrccls;
286 u32 ipmsgtag;
287 u32 res3[3];
288} __attribute__ ((packed,aligned(8)));
289
290/*
291 * Set mask iucv structure. Used by iucv_enable_cpu.
292 */
293struct iucv_cmd_set_mask {
294 u8 ipmask;
295 u8 res1[2];
296 u8 iprcode;
297 u32 res2[9];
298} __attribute__ ((packed,aligned(8)));
299
300union iucv_param {
301 struct iucv_cmd_control ctrl;
302 struct iucv_cmd_dpl dpl;
303 struct iucv_cmd_db db;
304 struct iucv_cmd_purge purge;
305 struct iucv_cmd_set_mask set_mask;
306};
307
308/*
309 * Anchor for per-cpu IUCV command parameter block.
310 */
Christoph Lameter70cf50352007-11-20 11:13:38 +0100311static union iucv_param *iucv_param[NR_CPUS];
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000312static union iucv_param *iucv_param_irq[NR_CPUS];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800313
314/**
315 * iucv_call_b2f0
316 * @code: identifier of IUCV call to CP.
317 * @parm: pointer to a struct iucv_parm block
318 *
319 * Calls CP to execute IUCV commands.
320 *
321 * Returns the result of the CP IUCV call.
322 */
323static inline int iucv_call_b2f0(int command, union iucv_param *parm)
324{
325 register unsigned long reg0 asm ("0");
326 register unsigned long reg1 asm ("1");
327 int ccode;
328
329 reg0 = command;
330 reg1 = virt_to_phys(parm);
331 asm volatile(
332 " .long 0xb2f01000\n"
333 " ipm %0\n"
334 " srl %0,28\n"
335 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)
336 : "m" (*parm) : "cc");
337 return (ccode == 1) ? parm->ctrl.iprcode : ccode;
338}
339
340/**
341 * iucv_query_maxconn
342 *
343 * Determines the maximum number of connections that may be established.
344 *
345 * Returns the maximum number of connections or -EPERM is IUCV is not
346 * available.
347 */
348static int iucv_query_maxconn(void)
349{
350 register unsigned long reg0 asm ("0");
351 register unsigned long reg1 asm ("1");
352 void *param;
353 int ccode;
354
355 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA);
356 if (!param)
357 return -ENOMEM;
358 reg0 = IUCV_QUERY;
359 reg1 = (unsigned long) param;
360 asm volatile (
361 " .long 0xb2f01000\n"
362 " ipm %0\n"
363 " srl %0,28\n"
364 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
365 if (ccode == 0)
Hendrik Bruecknerb29e4da2009-09-16 04:37:24 +0000366 iucv_max_pathid = reg1;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800367 kfree(param);
368 return ccode ? -EPERM : 0;
369}
370
371/**
372 * iucv_allow_cpu
373 * @data: unused
374 *
375 * Allow iucv interrupts on this cpu.
376 */
377static void iucv_allow_cpu(void *data)
378{
379 int cpu = smp_processor_id();
380 union iucv_param *parm;
381
382 /*
383 * Enable all iucv interrupts.
384 * ipmask contains bits for the different interrupts
385 * 0x80 - Flag to allow nonpriority message pending interrupts
386 * 0x40 - Flag to allow priority message pending interrupts
387 * 0x20 - Flag to allow nonpriority message completion interrupts
388 * 0x10 - Flag to allow priority message completion interrupts
389 * 0x08 - Flag to allow IUCV control interrupts
390 */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000391 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800392 memset(parm, 0, sizeof(union iucv_param));
393 parm->set_mask.ipmask = 0xf8;
394 iucv_call_b2f0(IUCV_SETMASK, parm);
395
Ursula Braun672e4052009-06-16 10:30:42 +0200396 /*
397 * Enable all iucv control interrupts.
398 * ipmask contains bits for the different interrupts
399 * 0x80 - Flag to allow pending connections interrupts
400 * 0x40 - Flag to allow connection complete interrupts
401 * 0x20 - Flag to allow connection severed interrupts
402 * 0x10 - Flag to allow connection quiesced interrupts
403 * 0x08 - Flag to allow connection resumed interrupts
404 */
405 memset(parm, 0, sizeof(union iucv_param));
406 parm->set_mask.ipmask = 0xf8;
407 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800408 /* Set indication that iucv interrupts are allowed for this cpu. */
409 cpu_set(cpu, iucv_irq_cpumask);
410}
411
412/**
413 * iucv_block_cpu
414 * @data: unused
415 *
416 * Block iucv interrupts on this cpu.
417 */
418static void iucv_block_cpu(void *data)
419{
420 int cpu = smp_processor_id();
421 union iucv_param *parm;
422
423 /* Disable all iucv interrupts. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000424 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800425 memset(parm, 0, sizeof(union iucv_param));
426 iucv_call_b2f0(IUCV_SETMASK, parm);
427
428 /* Clear indication that iucv interrupts are allowed for this cpu. */
429 cpu_clear(cpu, iucv_irq_cpumask);
430}
431
432/**
Ursula Braun672e4052009-06-16 10:30:42 +0200433 * iucv_block_cpu_almost
434 * @data: unused
435 *
436 * Allow connection-severed interrupts only on this cpu.
437 */
438static void iucv_block_cpu_almost(void *data)
439{
440 int cpu = smp_processor_id();
441 union iucv_param *parm;
442
443 /* Allow iucv control interrupts only */
444 parm = iucv_param_irq[cpu];
445 memset(parm, 0, sizeof(union iucv_param));
446 parm->set_mask.ipmask = 0x08;
447 iucv_call_b2f0(IUCV_SETMASK, parm);
448 /* Allow iucv-severed interrupt only */
449 memset(parm, 0, sizeof(union iucv_param));
450 parm->set_mask.ipmask = 0x20;
451 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
452
453 /* Clear indication that iucv interrupts are allowed for this cpu. */
454 cpu_clear(cpu, iucv_irq_cpumask);
455}
456
457/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800458 * iucv_declare_cpu
459 * @data: unused
460 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200461 * Declare a interrupt buffer on this cpu.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800462 */
463static void iucv_declare_cpu(void *data)
464{
465 int cpu = smp_processor_id();
466 union iucv_param *parm;
467 int rc;
468
469 if (cpu_isset(cpu, iucv_buffer_cpumask))
470 return;
471
472 /* Declare interrupt buffer. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000473 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800474 memset(parm, 0, sizeof(union iucv_param));
Christoph Lameter70cf50352007-11-20 11:13:38 +0100475 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800476 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
477 if (rc) {
478 char *err = "Unknown";
Heiko Carstensda99f052007-05-04 12:23:27 -0700479 switch (rc) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800480 case 0x03:
481 err = "Directory error";
482 break;
483 case 0x0a:
484 err = "Invalid length";
485 break;
486 case 0x13:
487 err = "Buffer already exists";
488 break;
489 case 0x3e:
490 err = "Buffer overlap";
491 break;
492 case 0x5c:
493 err = "Paging or storage error";
494 break;
495 }
Ursula Braun8f7c5022008-12-25 13:39:47 +0100496 pr_warning("Defining an interrupt buffer on CPU %i"
497 " failed with 0x%02x (%s)\n", cpu, rc, err);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800498 return;
499 }
500
501 /* Set indication that an iucv buffer exists for this cpu. */
502 cpu_set(cpu, iucv_buffer_cpumask);
503
504 if (iucv_nonsmp_handler == 0 || cpus_empty(iucv_irq_cpumask))
505 /* Enable iucv interrupts on this cpu. */
506 iucv_allow_cpu(NULL);
507 else
508 /* Disable iucv interrupts on this cpu. */
509 iucv_block_cpu(NULL);
510}
511
512/**
513 * iucv_retrieve_cpu
514 * @data: unused
515 *
516 * Retrieve interrupt buffer on this cpu.
517 */
518static void iucv_retrieve_cpu(void *data)
519{
520 int cpu = smp_processor_id();
521 union iucv_param *parm;
522
523 if (!cpu_isset(cpu, iucv_buffer_cpumask))
524 return;
525
526 /* Block iucv interrupts. */
527 iucv_block_cpu(NULL);
528
529 /* Retrieve interrupt buffer. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000530 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800531 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
532
533 /* Clear indication that an iucv buffer exists for this cpu. */
534 cpu_clear(cpu, iucv_buffer_cpumask);
535}
536
537/**
538 * iucv_setmask_smp
539 *
540 * Allow iucv interrupts on all cpus.
541 */
542static void iucv_setmask_mp(void)
543{
544 int cpu;
545
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700546 get_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800547 for_each_online_cpu(cpu)
548 /* Enable all cpus with a declared buffer. */
549 if (cpu_isset(cpu, iucv_buffer_cpumask) &&
550 !cpu_isset(cpu, iucv_irq_cpumask))
Heiko Carstens3bb447f2007-07-27 12:29:08 +0200551 smp_call_function_single(cpu, iucv_allow_cpu,
Jens Axboe8691e5a2008-06-06 11:18:06 +0200552 NULL, 1);
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700553 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800554}
555
556/**
557 * iucv_setmask_up
558 *
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700559 * Allow iucv interrupts on a single cpu.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800560 */
561static void iucv_setmask_up(void)
562{
563 cpumask_t cpumask;
564 int cpu;
565
566 /* Disable all cpu but the first in cpu_irq_cpumask. */
567 cpumask = iucv_irq_cpumask;
568 cpu_clear(first_cpu(iucv_irq_cpumask), cpumask);
Mike Travis0e12f842008-05-12 21:21:13 +0200569 for_each_cpu_mask_nr(cpu, cpumask)
Jens Axboe8691e5a2008-06-06 11:18:06 +0200570 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800571}
572
573/**
574 * iucv_enable
575 *
576 * This function makes iucv ready for use. It allocates the pathid
577 * table, declares an iucv interrupt buffer and enables the iucv
578 * interrupts. Called when the first user has registered an iucv
579 * handler.
580 */
581static int iucv_enable(void)
582{
583 size_t alloc_size;
584 int cpu, rc;
585
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800586 get_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800587 rc = -ENOMEM;
588 alloc_size = iucv_max_pathid * sizeof(struct iucv_path);
589 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
590 if (!iucv_path_table)
591 goto out;
592 /* Declare per cpu buffers. */
593 rc = -EIO;
594 for_each_online_cpu(cpu)
Jens Axboe8691e5a2008-06-06 11:18:06 +0200595 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800596 if (cpus_empty(iucv_buffer_cpumask))
597 /* No cpu could declare an iucv buffer. */
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800598 goto out;
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700599 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800600 return 0;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800601out:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800602 kfree(iucv_path_table);
603 iucv_path_table = NULL;
604 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800605 return rc;
606}
607
608/**
609 * iucv_disable
610 *
611 * This function shuts down iucv. It disables iucv interrupts, retrieves
612 * the iucv interrupt buffer and frees the pathid table. Called after the
613 * last user unregister its iucv handler.
614 */
615static void iucv_disable(void)
616{
Heiko Carstens8b122ef2008-09-30 03:03:35 -0700617 get_online_cpus();
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200618 on_each_cpu(iucv_retrieve_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800619 kfree(iucv_path_table);
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800620 iucv_path_table = NULL;
621 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800622}
623
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800624static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
625 unsigned long action, void *hcpu)
626{
627 cpumask_t cpumask;
628 long cpu = (long) hcpu;
629
630 switch (action) {
631 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700632 case CPU_UP_PREPARE_FROZEN:
Christoph Lameter70cf50352007-11-20 11:13:38 +0100633 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
634 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
635 if (!iucv_irq_data[cpu])
Akinobu Mita92e99a92010-05-26 14:43:33 -0700636 return notifier_from_errno(-ENOMEM);
637
Christoph Lameter70cf50352007-11-20 11:13:38 +0100638 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
639 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
Akinobu Mitad0236f82008-07-15 02:09:53 -0700640 if (!iucv_param[cpu]) {
641 kfree(iucv_irq_data[cpu]);
642 iucv_irq_data[cpu] = NULL;
Akinobu Mita92e99a92010-05-26 14:43:33 -0700643 return notifier_from_errno(-ENOMEM);
Akinobu Mitad0236f82008-07-15 02:09:53 -0700644 }
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000645 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
646 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
647 if (!iucv_param_irq[cpu]) {
648 kfree(iucv_param[cpu]);
649 iucv_param[cpu] = NULL;
650 kfree(iucv_irq_data[cpu]);
651 iucv_irq_data[cpu] = NULL;
Akinobu Mita92e99a92010-05-26 14:43:33 -0700652 return notifier_from_errno(-ENOMEM);
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000653 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800654 break;
655 case CPU_UP_CANCELED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700656 case CPU_UP_CANCELED_FROZEN:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800657 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700658 case CPU_DEAD_FROZEN:
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000659 kfree(iucv_param_irq[cpu]);
660 iucv_param_irq[cpu] = NULL;
Christoph Lameter70cf50352007-11-20 11:13:38 +0100661 kfree(iucv_param[cpu]);
662 iucv_param[cpu] = NULL;
663 kfree(iucv_irq_data[cpu]);
664 iucv_irq_data[cpu] = NULL;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800665 break;
666 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700667 case CPU_ONLINE_FROZEN:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800668 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700669 case CPU_DOWN_FAILED_FROZEN:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800670 if (!iucv_path_table)
671 break;
Jens Axboe8691e5a2008-06-06 11:18:06 +0200672 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800673 break;
674 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700675 case CPU_DOWN_PREPARE_FROZEN:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800676 if (!iucv_path_table)
677 break;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800678 cpumask = iucv_buffer_cpumask;
679 cpu_clear(cpu, cpumask);
680 if (cpus_empty(cpumask))
681 /* Can't offline last IUCV enabled cpu. */
Akinobu Mita92e99a92010-05-26 14:43:33 -0700682 return notifier_from_errno(-EINVAL);
Jens Axboe8691e5a2008-06-06 11:18:06 +0200683 smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800684 if (cpus_empty(iucv_irq_cpumask))
Heiko Carstens3bb447f2007-07-27 12:29:08 +0200685 smp_call_function_single(first_cpu(iucv_buffer_cpumask),
Jens Axboe8691e5a2008-06-06 11:18:06 +0200686 iucv_allow_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800687 break;
688 }
689 return NOTIFY_OK;
690}
691
Heiko Carstensf1494ed2008-06-09 15:49:57 -0700692static struct notifier_block __refdata iucv_cpu_notifier = {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800693 .notifier_call = iucv_cpu_notify,
694};
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800695
696/**
697 * iucv_sever_pathid
698 * @pathid: path identification number.
699 * @userdata: 16-bytes of user data.
700 *
701 * Sever an iucv path to free up the pathid. Used internally.
702 */
703static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
704{
705 union iucv_param *parm;
706
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000707 parm = iucv_param_irq[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800708 memset(parm, 0, sizeof(union iucv_param));
709 if (userdata)
710 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
711 parm->ctrl.ippathid = pathid;
712 return iucv_call_b2f0(IUCV_SEVER, parm);
713}
714
715/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700716 * __iucv_cleanup_queue
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800717 * @dummy: unused dummy argument
718 *
719 * Nop function called via smp_call_function to force work items from
720 * pending external iucv interrupts to the work queue.
721 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700722static void __iucv_cleanup_queue(void *dummy)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800723{
724}
725
726/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700727 * iucv_cleanup_queue
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800728 *
729 * Function called after a path has been severed to find all remaining
730 * work items for the now stale pathid. The caller needs to hold the
731 * iucv_table_lock.
732 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700733static void iucv_cleanup_queue(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800734{
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700735 struct iucv_irq_list *p, *n;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800736
737 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300738 * When a path is severed, the pathid can be reused immediately
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700739 * on a iucv connect or a connection pending interrupt. Remove
740 * all entries from the task queue that refer to a stale pathid
741 * (iucv_path_table[ix] == NULL). Only then do the iucv connect
742 * or deliver the connection pending interrupt. To get all the
743 * pending interrupts force them to the work queue by calling
744 * an empty function on all cpus.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800745 */
Jens Axboe8691e5a2008-06-06 11:18:06 +0200746 smp_call_function(__iucv_cleanup_queue, NULL, 1);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700747 spin_lock_irq(&iucv_queue_lock);
748 list_for_each_entry_safe(p, n, &iucv_task_queue, list) {
749 /* Remove stale work items from the task queue. */
750 if (iucv_path_table[p->data.ippathid] == NULL) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800751 list_del(&p->list);
752 kfree(p);
753 }
754 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700755 spin_unlock_irq(&iucv_queue_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800756}
757
758/**
759 * iucv_register:
760 * @handler: address of iucv handler structure
761 * @smp: != 0 indicates that the handler can deal with out of order messages
762 *
763 * Registers a driver with IUCV.
764 *
765 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid
766 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
767 */
768int iucv_register(struct iucv_handler *handler, int smp)
769{
770 int rc;
771
772 if (!iucv_available)
773 return -ENOSYS;
774 mutex_lock(&iucv_register_mutex);
775 if (!smp)
776 iucv_nonsmp_handler++;
777 if (list_empty(&iucv_handler_list)) {
778 rc = iucv_enable();
779 if (rc)
780 goto out_mutex;
781 } else if (!smp && iucv_nonsmp_handler == 1)
782 iucv_setmask_up();
783 INIT_LIST_HEAD(&handler->paths);
784
Ursula Braun435bc9d2008-02-07 18:06:52 -0800785 spin_lock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800786 list_add_tail(&handler->list, &iucv_handler_list);
Ursula Braun435bc9d2008-02-07 18:06:52 -0800787 spin_unlock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800788 rc = 0;
789out_mutex:
790 mutex_unlock(&iucv_register_mutex);
791 return rc;
792}
Heiko Carstensda99f052007-05-04 12:23:27 -0700793EXPORT_SYMBOL(iucv_register);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800794
795/**
796 * iucv_unregister
797 * @handler: address of iucv handler structure
798 * @smp: != 0 indicates that the handler can deal with out of order messages
799 *
800 * Unregister driver from IUCV.
801 */
802void iucv_unregister(struct iucv_handler *handler, int smp)
803{
804 struct iucv_path *p, *n;
805
806 mutex_lock(&iucv_register_mutex);
807 spin_lock_bh(&iucv_table_lock);
808 /* Remove handler from the iucv_handler_list. */
809 list_del_init(&handler->list);
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300810 /* Sever all pathids still referring to the handler. */
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800811 list_for_each_entry_safe(p, n, &handler->paths, list) {
812 iucv_sever_pathid(p->pathid, NULL);
813 iucv_path_table[p->pathid] = NULL;
814 list_del(&p->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800815 iucv_path_free(p);
816 }
817 spin_unlock_bh(&iucv_table_lock);
818 if (!smp)
819 iucv_nonsmp_handler--;
820 if (list_empty(&iucv_handler_list))
821 iucv_disable();
822 else if (!smp && iucv_nonsmp_handler == 0)
823 iucv_setmask_mp();
824 mutex_unlock(&iucv_register_mutex);
825}
Heiko Carstensda99f052007-05-04 12:23:27 -0700826EXPORT_SYMBOL(iucv_unregister);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800827
Ursula Braun6c005962009-06-16 10:30:41 +0200828static int iucv_reboot_event(struct notifier_block *this,
829 unsigned long event, void *ptr)
830{
831 int i, rc;
832
833 get_online_cpus();
834 on_each_cpu(iucv_block_cpu, NULL, 1);
835 preempt_disable();
836 for (i = 0; i < iucv_max_pathid; i++) {
837 if (iucv_path_table[i])
838 rc = iucv_sever_pathid(i, NULL);
839 }
840 preempt_enable();
841 put_online_cpus();
842 iucv_disable();
843 return NOTIFY_DONE;
844}
845
846static struct notifier_block iucv_reboot_notifier = {
847 .notifier_call = iucv_reboot_event,
848};
849
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800850/**
851 * iucv_path_accept
852 * @path: address of iucv path structure
853 * @handler: address of iucv handler structure
854 * @userdata: 16 bytes of data reflected to the communication partner
855 * @private: private data passed to interrupt handlers for this path
856 *
857 * This function is issued after the user received a connection pending
858 * external interrupt and now wishes to complete the IUCV communication path.
859 *
860 * Returns the result of the CP IUCV call.
861 */
862int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
863 u8 userdata[16], void *private)
864{
865 union iucv_param *parm;
866 int rc;
867
868 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +0000869 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +0200870 rc = -EIO;
871 goto out;
872 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800873 /* Prepare parameter block. */
Christoph Lameter70cf50352007-11-20 11:13:38 +0100874 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800875 memset(parm, 0, sizeof(union iucv_param));
876 parm->ctrl.ippathid = path->pathid;
877 parm->ctrl.ipmsglim = path->msglim;
878 if (userdata)
879 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
880 parm->ctrl.ipflags1 = path->flags;
881
882 rc = iucv_call_b2f0(IUCV_ACCEPT, parm);
883 if (!rc) {
884 path->private = private;
885 path->msglim = parm->ctrl.ipmsglim;
886 path->flags = parm->ctrl.ipflags1;
887 }
Ursula Braun6c005962009-06-16 10:30:41 +0200888out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800889 local_bh_enable();
890 return rc;
891}
Heiko Carstensda99f052007-05-04 12:23:27 -0700892EXPORT_SYMBOL(iucv_path_accept);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800893
894/**
895 * iucv_path_connect
896 * @path: address of iucv path structure
897 * @handler: address of iucv handler structure
898 * @userid: 8-byte user identification
899 * @system: 8-byte target system identification
900 * @userdata: 16 bytes of data reflected to the communication partner
901 * @private: private data passed to interrupt handlers for this path
902 *
903 * This function establishes an IUCV path. Although the connect may complete
904 * successfully, you are not able to use the path until you receive an IUCV
905 * Connection Complete external interrupt.
906 *
907 * Returns the result of the CP IUCV call.
908 */
909int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
910 u8 userid[8], u8 system[8], u8 userdata[16],
911 void *private)
912{
913 union iucv_param *parm;
914 int rc;
915
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700916 spin_lock_bh(&iucv_table_lock);
917 iucv_cleanup_queue();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +0000918 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +0200919 rc = -EIO;
920 goto out;
921 }
Christoph Lameter70cf50352007-11-20 11:13:38 +0100922 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800923 memset(parm, 0, sizeof(union iucv_param));
924 parm->ctrl.ipmsglim = path->msglim;
925 parm->ctrl.ipflags1 = path->flags;
926 if (userid) {
927 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));
928 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
929 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
930 }
931 if (system) {
932 memcpy(parm->ctrl.iptarget, system,
933 sizeof(parm->ctrl.iptarget));
934 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
935 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
936 }
937 if (userdata)
938 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
939
940 rc = iucv_call_b2f0(IUCV_CONNECT, parm);
941 if (!rc) {
942 if (parm->ctrl.ippathid < iucv_max_pathid) {
943 path->pathid = parm->ctrl.ippathid;
944 path->msglim = parm->ctrl.ipmsglim;
945 path->flags = parm->ctrl.ipflags1;
946 path->handler = handler;
947 path->private = private;
948 list_add_tail(&path->list, &handler->paths);
949 iucv_path_table[path->pathid] = path;
950 } else {
951 iucv_sever_pathid(parm->ctrl.ippathid,
952 iucv_error_pathid);
953 rc = -EIO;
954 }
955 }
Ursula Braun6c005962009-06-16 10:30:41 +0200956out:
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700957 spin_unlock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800958 return rc;
959}
Heiko Carstensda99f052007-05-04 12:23:27 -0700960EXPORT_SYMBOL(iucv_path_connect);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800961
962/**
963 * iucv_path_quiesce:
964 * @path: address of iucv path structure
965 * @userdata: 16 bytes of data reflected to the communication partner
966 *
967 * This function temporarily suspends incoming messages on an IUCV path.
968 * You can later reactivate the path by invoking the iucv_resume function.
969 *
970 * Returns the result from the CP IUCV call.
971 */
972int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])
973{
974 union iucv_param *parm;
975 int rc;
976
977 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +0000978 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +0200979 rc = -EIO;
980 goto out;
981 }
Christoph Lameter70cf50352007-11-20 11:13:38 +0100982 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800983 memset(parm, 0, sizeof(union iucv_param));
984 if (userdata)
985 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
986 parm->ctrl.ippathid = path->pathid;
987 rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
Ursula Braun6c005962009-06-16 10:30:41 +0200988out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800989 local_bh_enable();
990 return rc;
991}
Heiko Carstensda99f052007-05-04 12:23:27 -0700992EXPORT_SYMBOL(iucv_path_quiesce);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800993
994/**
995 * iucv_path_resume:
996 * @path: address of iucv path structure
997 * @userdata: 16 bytes of data reflected to the communication partner
998 *
999 * This function resumes incoming messages on an IUCV path that has
1000 * been stopped with iucv_path_quiesce.
1001 *
1002 * Returns the result from the CP IUCV call.
1003 */
1004int iucv_path_resume(struct iucv_path *path, u8 userdata[16])
1005{
1006 union iucv_param *parm;
1007 int rc;
1008
1009 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001010 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001011 rc = -EIO;
1012 goto out;
1013 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001014 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001015 memset(parm, 0, sizeof(union iucv_param));
1016 if (userdata)
1017 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
1018 parm->ctrl.ippathid = path->pathid;
1019 rc = iucv_call_b2f0(IUCV_RESUME, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001020out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001021 local_bh_enable();
1022 return rc;
1023}
1024
1025/**
1026 * iucv_path_sever
1027 * @path: address of iucv path structure
1028 * @userdata: 16 bytes of data reflected to the communication partner
1029 *
1030 * This function terminates an IUCV path.
1031 *
1032 * Returns the result from the CP IUCV call.
1033 */
1034int iucv_path_sever(struct iucv_path *path, u8 userdata[16])
1035{
1036 int rc;
1037
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001038 preempt_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001039 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001040 rc = -EIO;
1041 goto out;
1042 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001043 if (iucv_active_cpu != smp_processor_id())
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001044 spin_lock_bh(&iucv_table_lock);
1045 rc = iucv_sever_pathid(path->pathid, userdata);
Ursula Braun42e1b4c2009-04-21 23:26:20 +00001046 iucv_path_table[path->pathid] = NULL;
1047 list_del_init(&path->list);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001048 if (iucv_active_cpu != smp_processor_id())
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001049 spin_unlock_bh(&iucv_table_lock);
Ursula Braun6c005962009-06-16 10:30:41 +02001050out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001051 preempt_enable();
1052 return rc;
1053}
Heiko Carstensda99f052007-05-04 12:23:27 -07001054EXPORT_SYMBOL(iucv_path_sever);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001055
1056/**
1057 * iucv_message_purge
1058 * @path: address of iucv path structure
1059 * @msg: address of iucv msg structure
1060 * @srccls: source class of message
1061 *
1062 * Cancels a message you have sent.
1063 *
1064 * Returns the result from the CP IUCV call.
1065 */
1066int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
1067 u32 srccls)
1068{
1069 union iucv_param *parm;
1070 int rc;
1071
1072 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001073 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001074 rc = -EIO;
1075 goto out;
1076 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001077 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001078 memset(parm, 0, sizeof(union iucv_param));
1079 parm->purge.ippathid = path->pathid;
1080 parm->purge.ipmsgid = msg->id;
1081 parm->purge.ipsrccls = srccls;
1082 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID;
1083 rc = iucv_call_b2f0(IUCV_PURGE, parm);
1084 if (!rc) {
1085 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8;
1086 msg->tag = parm->purge.ipmsgtag;
1087 }
Ursula Braun6c005962009-06-16 10:30:41 +02001088out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001089 local_bh_enable();
1090 return rc;
1091}
Heiko Carstensda99f052007-05-04 12:23:27 -07001092EXPORT_SYMBOL(iucv_message_purge);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001093
1094/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001095 * iucv_message_receive_iprmdata
1096 * @path: address of iucv path structure
1097 * @msg: address of iucv msg structure
1098 * @flags: how the message is received (IUCV_IPBUFLST)
1099 * @buffer: address of data buffer or address of struct iucv_array
1100 * @size: length of data buffer
1101 * @residual:
1102 *
1103 * Internal function used by iucv_message_receive and __iucv_message_receive
1104 * to receive RMDATA data stored in struct iucv_message.
1105 */
1106static int iucv_message_receive_iprmdata(struct iucv_path *path,
1107 struct iucv_message *msg,
1108 u8 flags, void *buffer,
1109 size_t size, size_t *residual)
1110{
1111 struct iucv_array *array;
1112 u8 *rmmsg;
1113 size_t copy;
1114
1115 /*
1116 * Message is 8 bytes long and has been stored to the
1117 * message descriptor itself.
1118 */
1119 if (residual)
1120 *residual = abs(size - 8);
1121 rmmsg = msg->rmmsg;
1122 if (flags & IUCV_IPBUFLST) {
1123 /* Copy to struct iucv_array. */
1124 size = (size < 8) ? size : 8;
1125 for (array = buffer; size > 0; array++) {
1126 copy = min_t(size_t, size, array->length);
1127 memcpy((u8 *)(addr_t) array->address,
1128 rmmsg, copy);
1129 rmmsg += copy;
1130 size -= copy;
1131 }
1132 } else {
1133 /* Copy to direct buffer. */
1134 memcpy(buffer, rmmsg, min_t(size_t, size, 8));
1135 }
1136 return 0;
1137}
1138
1139/**
1140 * __iucv_message_receive
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001141 * @path: address of iucv path structure
1142 * @msg: address of iucv msg structure
1143 * @flags: how the message is received (IUCV_IPBUFLST)
1144 * @buffer: address of data buffer or address of struct iucv_array
1145 * @size: length of data buffer
1146 * @residual:
1147 *
1148 * This function receives messages that are being sent to you over
1149 * established paths. This function will deal with RMDATA messages
1150 * embedded in struct iucv_message as well.
1151 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001152 * Locking: no locking
1153 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001154 * Returns the result from the CP IUCV call.
1155 */
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001156int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1157 u8 flags, void *buffer, size_t size, size_t *residual)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001158{
1159 union iucv_param *parm;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001160 int rc;
1161
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001162 if (msg->flags & IUCV_IPRMDATA)
1163 return iucv_message_receive_iprmdata(path, msg, flags,
1164 buffer, size, residual);
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001165 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001166 rc = -EIO;
1167 goto out;
1168 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001169 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001170 memset(parm, 0, sizeof(union iucv_param));
1171 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1172 parm->db.ipbfln1f = (u32) size;
1173 parm->db.ipmsgid = msg->id;
1174 parm->db.ippathid = path->pathid;
1175 parm->db.iptrgcls = msg->class;
1176 parm->db.ipflags1 = (flags | IUCV_IPFGPID |
1177 IUCV_IPFGMID | IUCV_IPTRGCLS);
1178 rc = iucv_call_b2f0(IUCV_RECEIVE, parm);
1179 if (!rc || rc == 5) {
1180 msg->flags = parm->db.ipflags1;
1181 if (residual)
1182 *residual = parm->db.ipbfln1f;
1183 }
Ursula Braun6c005962009-06-16 10:30:41 +02001184out:
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001185 return rc;
1186}
1187EXPORT_SYMBOL(__iucv_message_receive);
1188
1189/**
1190 * iucv_message_receive
1191 * @path: address of iucv path structure
1192 * @msg: address of iucv msg structure
1193 * @flags: how the message is received (IUCV_IPBUFLST)
1194 * @buffer: address of data buffer or address of struct iucv_array
1195 * @size: length of data buffer
1196 * @residual:
1197 *
1198 * This function receives messages that are being sent to you over
1199 * established paths. This function will deal with RMDATA messages
1200 * embedded in struct iucv_message as well.
1201 *
1202 * Locking: local_bh_enable/local_bh_disable
1203 *
1204 * Returns the result from the CP IUCV call.
1205 */
1206int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1207 u8 flags, void *buffer, size_t size, size_t *residual)
1208{
1209 int rc;
1210
1211 if (msg->flags & IUCV_IPRMDATA)
1212 return iucv_message_receive_iprmdata(path, msg, flags,
1213 buffer, size, residual);
1214 local_bh_disable();
1215 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001216 local_bh_enable();
1217 return rc;
1218}
Heiko Carstensda99f052007-05-04 12:23:27 -07001219EXPORT_SYMBOL(iucv_message_receive);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001220
1221/**
1222 * iucv_message_reject
1223 * @path: address of iucv path structure
1224 * @msg: address of iucv msg structure
1225 *
1226 * The reject function refuses a specified message. Between the time you
1227 * are notified of a message and the time that you complete the message,
1228 * the message may be rejected.
1229 *
1230 * Returns the result from the CP IUCV call.
1231 */
1232int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
1233{
1234 union iucv_param *parm;
1235 int rc;
1236
1237 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001238 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001239 rc = -EIO;
1240 goto out;
1241 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001242 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001243 memset(parm, 0, sizeof(union iucv_param));
1244 parm->db.ippathid = path->pathid;
1245 parm->db.ipmsgid = msg->id;
1246 parm->db.iptrgcls = msg->class;
1247 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID);
1248 rc = iucv_call_b2f0(IUCV_REJECT, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001249out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001250 local_bh_enable();
1251 return rc;
1252}
Heiko Carstensda99f052007-05-04 12:23:27 -07001253EXPORT_SYMBOL(iucv_message_reject);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001254
1255/**
1256 * iucv_message_reply
1257 * @path: address of iucv path structure
1258 * @msg: address of iucv msg structure
1259 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1260 * @reply: address of reply data buffer or address of struct iucv_array
1261 * @size: length of reply data buffer
1262 *
1263 * This function responds to the two-way messages that you receive. You
1264 * must identify completely the message to which you wish to reply. ie,
1265 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
1266 * the parameter list.
1267 *
1268 * Returns the result from the CP IUCV call.
1269 */
1270int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
1271 u8 flags, void *reply, size_t size)
1272{
1273 union iucv_param *parm;
1274 int rc;
1275
1276 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001277 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001278 rc = -EIO;
1279 goto out;
1280 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001281 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001282 memset(parm, 0, sizeof(union iucv_param));
1283 if (flags & IUCV_IPRMDATA) {
1284 parm->dpl.ippathid = path->pathid;
1285 parm->dpl.ipflags1 = flags;
1286 parm->dpl.ipmsgid = msg->id;
1287 parm->dpl.iptrgcls = msg->class;
1288 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));
1289 } else {
1290 parm->db.ipbfadr1 = (u32)(addr_t) reply;
1291 parm->db.ipbfln1f = (u32) size;
1292 parm->db.ippathid = path->pathid;
1293 parm->db.ipflags1 = flags;
1294 parm->db.ipmsgid = msg->id;
1295 parm->db.iptrgcls = msg->class;
1296 }
1297 rc = iucv_call_b2f0(IUCV_REPLY, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001298out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001299 local_bh_enable();
1300 return rc;
1301}
Heiko Carstensda99f052007-05-04 12:23:27 -07001302EXPORT_SYMBOL(iucv_message_reply);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001303
1304/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001305 * __iucv_message_send
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001306 * @path: address of iucv path structure
1307 * @msg: address of iucv msg structure
1308 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1309 * @srccls: source class of message
1310 * @buffer: address of send buffer or address of struct iucv_array
1311 * @size: length of send buffer
1312 *
1313 * This function transmits data to another application. Data to be
1314 * transmitted is in a buffer and this is a one-way message and the
1315 * receiver will not reply to the message.
1316 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001317 * Locking: no locking
1318 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001319 * Returns the result from the CP IUCV call.
1320 */
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001321int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001322 u8 flags, u32 srccls, void *buffer, size_t size)
1323{
1324 union iucv_param *parm;
1325 int rc;
1326
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001327 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001328 rc = -EIO;
1329 goto out;
1330 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001331 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001332 memset(parm, 0, sizeof(union iucv_param));
1333 if (flags & IUCV_IPRMDATA) {
1334 /* Message of 8 bytes can be placed into the parameter list. */
1335 parm->dpl.ippathid = path->pathid;
1336 parm->dpl.ipflags1 = flags | IUCV_IPNORPY;
1337 parm->dpl.iptrgcls = msg->class;
1338 parm->dpl.ipsrccls = srccls;
1339 parm->dpl.ipmsgtag = msg->tag;
1340 memcpy(parm->dpl.iprmmsg, buffer, 8);
1341 } else {
1342 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1343 parm->db.ipbfln1f = (u32) size;
1344 parm->db.ippathid = path->pathid;
1345 parm->db.ipflags1 = flags | IUCV_IPNORPY;
1346 parm->db.iptrgcls = msg->class;
1347 parm->db.ipsrccls = srccls;
1348 parm->db.ipmsgtag = msg->tag;
1349 }
1350 rc = iucv_call_b2f0(IUCV_SEND, parm);
1351 if (!rc)
1352 msg->id = parm->db.ipmsgid;
Ursula Braun6c005962009-06-16 10:30:41 +02001353out:
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001354 return rc;
1355}
1356EXPORT_SYMBOL(__iucv_message_send);
1357
1358/**
1359 * iucv_message_send
1360 * @path: address of iucv path structure
1361 * @msg: address of iucv msg structure
1362 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1363 * @srccls: source class of message
1364 * @buffer: address of send buffer or address of struct iucv_array
1365 * @size: length of send buffer
1366 *
1367 * This function transmits data to another application. Data to be
1368 * transmitted is in a buffer and this is a one-way message and the
1369 * receiver will not reply to the message.
1370 *
1371 * Locking: local_bh_enable/local_bh_disable
1372 *
1373 * Returns the result from the CP IUCV call.
1374 */
1375int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1376 u8 flags, u32 srccls, void *buffer, size_t size)
1377{
1378 int rc;
1379
1380 local_bh_disable();
1381 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001382 local_bh_enable();
1383 return rc;
1384}
Heiko Carstensda99f052007-05-04 12:23:27 -07001385EXPORT_SYMBOL(iucv_message_send);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001386
1387/**
1388 * iucv_message_send2way
1389 * @path: address of iucv path structure
1390 * @msg: address of iucv msg structure
1391 * @flags: how the message is sent and the reply is received
1392 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
1393 * @srccls: source class of message
1394 * @buffer: address of send buffer or address of struct iucv_array
1395 * @size: length of send buffer
1396 * @ansbuf: address of answer buffer or address of struct iucv_array
1397 * @asize: size of reply buffer
1398 *
1399 * This function transmits data to another application. Data to be
1400 * transmitted is in a buffer. The receiver of the send is expected to
1401 * reply to the message and a buffer is provided into which IUCV moves
1402 * the reply to this message.
1403 *
1404 * Returns the result from the CP IUCV call.
1405 */
1406int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
1407 u8 flags, u32 srccls, void *buffer, size_t size,
1408 void *answer, size_t asize, size_t *residual)
1409{
1410 union iucv_param *parm;
1411 int rc;
1412
1413 local_bh_disable();
Hendrik Bruecknerd28ecab2009-09-16 04:37:23 +00001414 if (cpus_empty(iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001415 rc = -EIO;
1416 goto out;
1417 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001418 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001419 memset(parm, 0, sizeof(union iucv_param));
1420 if (flags & IUCV_IPRMDATA) {
1421 parm->dpl.ippathid = path->pathid;
1422 parm->dpl.ipflags1 = path->flags; /* priority message */
1423 parm->dpl.iptrgcls = msg->class;
1424 parm->dpl.ipsrccls = srccls;
1425 parm->dpl.ipmsgtag = msg->tag;
1426 parm->dpl.ipbfadr2 = (u32)(addr_t) answer;
1427 parm->dpl.ipbfln2f = (u32) asize;
1428 memcpy(parm->dpl.iprmmsg, buffer, 8);
1429 } else {
1430 parm->db.ippathid = path->pathid;
1431 parm->db.ipflags1 = path->flags; /* priority message */
1432 parm->db.iptrgcls = msg->class;
1433 parm->db.ipsrccls = srccls;
1434 parm->db.ipmsgtag = msg->tag;
1435 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1436 parm->db.ipbfln1f = (u32) size;
1437 parm->db.ipbfadr2 = (u32)(addr_t) answer;
1438 parm->db.ipbfln2f = (u32) asize;
1439 }
1440 rc = iucv_call_b2f0(IUCV_SEND, parm);
1441 if (!rc)
1442 msg->id = parm->db.ipmsgid;
Ursula Braun6c005962009-06-16 10:30:41 +02001443out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001444 local_bh_enable();
1445 return rc;
1446}
Heiko Carstensda99f052007-05-04 12:23:27 -07001447EXPORT_SYMBOL(iucv_message_send2way);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001448
1449/**
1450 * iucv_path_pending
1451 * @data: Pointer to external interrupt buffer
1452 *
1453 * Process connection pending work item. Called from tasklet while holding
1454 * iucv_table_lock.
1455 */
1456struct iucv_path_pending {
1457 u16 ippathid;
1458 u8 ipflags1;
1459 u8 iptype;
1460 u16 ipmsglim;
1461 u16 res1;
1462 u8 ipvmid[8];
1463 u8 ipuser[16];
1464 u32 res3;
1465 u8 ippollfg;
1466 u8 res4[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001467} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001468
1469static void iucv_path_pending(struct iucv_irq_data *data)
1470{
1471 struct iucv_path_pending *ipp = (void *) data;
1472 struct iucv_handler *handler;
1473 struct iucv_path *path;
1474 char *error;
1475
1476 BUG_ON(iucv_path_table[ipp->ippathid]);
1477 /* New pathid, handler found. Create a new path struct. */
1478 error = iucv_error_no_memory;
1479 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);
1480 if (!path)
1481 goto out_sever;
1482 path->pathid = ipp->ippathid;
1483 iucv_path_table[path->pathid] = path;
1484 EBCASC(ipp->ipvmid, 8);
1485
1486 /* Call registered handler until one is found that wants the path. */
1487 list_for_each_entry(handler, &iucv_handler_list, list) {
1488 if (!handler->path_pending)
1489 continue;
1490 /*
1491 * Add path to handler to allow a call to iucv_path_sever
1492 * inside the path_pending function. If the handler returns
1493 * an error remove the path from the handler again.
1494 */
1495 list_add(&path->list, &handler->paths);
1496 path->handler = handler;
1497 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))
1498 return;
1499 list_del(&path->list);
1500 path->handler = NULL;
1501 }
1502 /* No handler wanted the path. */
1503 iucv_path_table[path->pathid] = NULL;
1504 iucv_path_free(path);
1505 error = iucv_error_no_listener;
1506out_sever:
1507 iucv_sever_pathid(ipp->ippathid, error);
1508}
1509
1510/**
1511 * iucv_path_complete
1512 * @data: Pointer to external interrupt buffer
1513 *
1514 * Process connection complete work item. Called from tasklet while holding
1515 * iucv_table_lock.
1516 */
1517struct iucv_path_complete {
1518 u16 ippathid;
1519 u8 ipflags1;
1520 u8 iptype;
1521 u16 ipmsglim;
1522 u16 res1;
1523 u8 res2[8];
1524 u8 ipuser[16];
1525 u32 res3;
1526 u8 ippollfg;
1527 u8 res4[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001528} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001529
1530static void iucv_path_complete(struct iucv_irq_data *data)
1531{
1532 struct iucv_path_complete *ipc = (void *) data;
1533 struct iucv_path *path = iucv_path_table[ipc->ippathid];
1534
Hendrik Bruecknerb8942e32009-04-21 23:26:23 +00001535 if (path)
1536 path->flags = ipc->ipflags1;
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001537 if (path && path->handler && path->handler->path_complete)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001538 path->handler->path_complete(path, ipc->ipuser);
1539}
1540
1541/**
1542 * iucv_path_severed
1543 * @data: Pointer to external interrupt buffer
1544 *
1545 * Process connection severed work item. Called from tasklet while holding
1546 * iucv_table_lock.
1547 */
1548struct iucv_path_severed {
1549 u16 ippathid;
1550 u8 res1;
1551 u8 iptype;
1552 u32 res2;
1553 u8 res3[8];
1554 u8 ipuser[16];
1555 u32 res4;
1556 u8 ippollfg;
1557 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001558} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001559
1560static void iucv_path_severed(struct iucv_irq_data *data)
1561{
1562 struct iucv_path_severed *ips = (void *) data;
1563 struct iucv_path *path = iucv_path_table[ips->ippathid];
1564
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001565 if (!path || !path->handler) /* Already severed */
1566 return;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001567 if (path->handler->path_severed)
1568 path->handler->path_severed(path, ips->ipuser);
1569 else {
1570 iucv_sever_pathid(path->pathid, NULL);
1571 iucv_path_table[path->pathid] = NULL;
Ursula Braun42e1b4c2009-04-21 23:26:20 +00001572 list_del(&path->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001573 iucv_path_free(path);
1574 }
1575}
1576
1577/**
1578 * iucv_path_quiesced
1579 * @data: Pointer to external interrupt buffer
1580 *
1581 * Process connection quiesced work item. Called from tasklet while holding
1582 * iucv_table_lock.
1583 */
1584struct iucv_path_quiesced {
1585 u16 ippathid;
1586 u8 res1;
1587 u8 iptype;
1588 u32 res2;
1589 u8 res3[8];
1590 u8 ipuser[16];
1591 u32 res4;
1592 u8 ippollfg;
1593 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001594} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001595
1596static void iucv_path_quiesced(struct iucv_irq_data *data)
1597{
1598 struct iucv_path_quiesced *ipq = (void *) data;
1599 struct iucv_path *path = iucv_path_table[ipq->ippathid];
1600
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001601 if (path && path->handler && path->handler->path_quiesced)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001602 path->handler->path_quiesced(path, ipq->ipuser);
1603}
1604
1605/**
1606 * iucv_path_resumed
1607 * @data: Pointer to external interrupt buffer
1608 *
1609 * Process connection resumed work item. Called from tasklet while holding
1610 * iucv_table_lock.
1611 */
1612struct iucv_path_resumed {
1613 u16 ippathid;
1614 u8 res1;
1615 u8 iptype;
1616 u32 res2;
1617 u8 res3[8];
1618 u8 ipuser[16];
1619 u32 res4;
1620 u8 ippollfg;
1621 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001622} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001623
1624static void iucv_path_resumed(struct iucv_irq_data *data)
1625{
1626 struct iucv_path_resumed *ipr = (void *) data;
1627 struct iucv_path *path = iucv_path_table[ipr->ippathid];
1628
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001629 if (path && path->handler && path->handler->path_resumed)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001630 path->handler->path_resumed(path, ipr->ipuser);
1631}
1632
1633/**
1634 * iucv_message_complete
1635 * @data: Pointer to external interrupt buffer
1636 *
1637 * Process message complete work item. Called from tasklet while holding
1638 * iucv_table_lock.
1639 */
1640struct iucv_message_complete {
1641 u16 ippathid;
1642 u8 ipflags1;
1643 u8 iptype;
1644 u32 ipmsgid;
1645 u32 ipaudit;
1646 u8 iprmmsg[8];
1647 u32 ipsrccls;
1648 u32 ipmsgtag;
1649 u32 res;
1650 u32 ipbfln2f;
1651 u8 ippollfg;
1652 u8 res2[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001653} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001654
1655static void iucv_message_complete(struct iucv_irq_data *data)
1656{
1657 struct iucv_message_complete *imc = (void *) data;
1658 struct iucv_path *path = iucv_path_table[imc->ippathid];
1659 struct iucv_message msg;
1660
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001661 if (path && path->handler && path->handler->message_complete) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001662 msg.flags = imc->ipflags1;
1663 msg.id = imc->ipmsgid;
1664 msg.audit = imc->ipaudit;
1665 memcpy(msg.rmmsg, imc->iprmmsg, 8);
1666 msg.class = imc->ipsrccls;
1667 msg.tag = imc->ipmsgtag;
1668 msg.length = imc->ipbfln2f;
1669 path->handler->message_complete(path, &msg);
1670 }
1671}
1672
1673/**
1674 * iucv_message_pending
1675 * @data: Pointer to external interrupt buffer
1676 *
1677 * Process message pending work item. Called from tasklet while holding
1678 * iucv_table_lock.
1679 */
1680struct iucv_message_pending {
1681 u16 ippathid;
1682 u8 ipflags1;
1683 u8 iptype;
1684 u32 ipmsgid;
1685 u32 iptrgcls;
1686 union {
1687 u32 iprmmsg1_u32;
1688 u8 iprmmsg1[4];
1689 } ln1msg1;
1690 union {
1691 u32 ipbfln1f;
1692 u8 iprmmsg2[4];
1693 } ln1msg2;
1694 u32 res1[3];
1695 u32 ipbfln2f;
1696 u8 ippollfg;
1697 u8 res2[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001698} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001699
1700static void iucv_message_pending(struct iucv_irq_data *data)
1701{
1702 struct iucv_message_pending *imp = (void *) data;
1703 struct iucv_path *path = iucv_path_table[imp->ippathid];
1704 struct iucv_message msg;
1705
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001706 if (path && path->handler && path->handler->message_pending) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001707 msg.flags = imp->ipflags1;
1708 msg.id = imp->ipmsgid;
1709 msg.class = imp->iptrgcls;
1710 if (imp->ipflags1 & IUCV_IPRMDATA) {
1711 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8);
1712 msg.length = 8;
1713 } else
1714 msg.length = imp->ln1msg2.ipbfln1f;
1715 msg.reply_size = imp->ipbfln2f;
1716 path->handler->message_pending(path, &msg);
1717 }
1718}
1719
1720/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001721 * iucv_tasklet_fn:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001722 *
1723 * This tasklet loops over the queue of irq buffers created by
1724 * iucv_external_interrupt, calls the appropriate action handler
1725 * and then frees the buffer.
1726 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001727static void iucv_tasklet_fn(unsigned long ignored)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001728{
1729 typedef void iucv_irq_fn(struct iucv_irq_data *);
1730 static iucv_irq_fn *irq_fn[] = {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001731 [0x02] = iucv_path_complete,
1732 [0x03] = iucv_path_severed,
1733 [0x04] = iucv_path_quiesced,
1734 [0x05] = iucv_path_resumed,
1735 [0x06] = iucv_message_complete,
1736 [0x07] = iucv_message_complete,
1737 [0x08] = iucv_message_pending,
1738 [0x09] = iucv_message_pending,
1739 };
Denis Chengb5e78332007-12-07 00:51:45 -08001740 LIST_HEAD(task_queue);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001741 struct iucv_irq_list *p, *n;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001742
1743 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
Ursula Braun13fdc9a2007-07-14 19:03:41 -07001744 if (!spin_trylock(&iucv_table_lock)) {
1745 tasklet_schedule(&iucv_tasklet);
1746 return;
1747 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001748 iucv_active_cpu = smp_processor_id();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001749
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001750 spin_lock_irq(&iucv_queue_lock);
1751 list_splice_init(&iucv_task_queue, &task_queue);
1752 spin_unlock_irq(&iucv_queue_lock);
1753
1754 list_for_each_entry_safe(p, n, &task_queue, list) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001755 list_del_init(&p->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001756 irq_fn[p->data.iptype](&p->data);
1757 kfree(p);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001758 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001759
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001760 iucv_active_cpu = -1;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001761 spin_unlock(&iucv_table_lock);
1762}
1763
1764/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001765 * iucv_work_fn:
1766 *
1767 * This work function loops over the queue of path pending irq blocks
1768 * created by iucv_external_interrupt, calls the appropriate action
1769 * handler and then frees the buffer.
1770 */
1771static void iucv_work_fn(struct work_struct *work)
1772{
Denis Chengb5e78332007-12-07 00:51:45 -08001773 LIST_HEAD(work_queue);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001774 struct iucv_irq_list *p, *n;
1775
1776 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1777 spin_lock_bh(&iucv_table_lock);
1778 iucv_active_cpu = smp_processor_id();
1779
1780 spin_lock_irq(&iucv_queue_lock);
1781 list_splice_init(&iucv_work_queue, &work_queue);
1782 spin_unlock_irq(&iucv_queue_lock);
1783
1784 iucv_cleanup_queue();
1785 list_for_each_entry_safe(p, n, &work_queue, list) {
1786 list_del_init(&p->list);
1787 iucv_path_pending(&p->data);
1788 kfree(p);
1789 }
1790
1791 iucv_active_cpu = -1;
1792 spin_unlock_bh(&iucv_table_lock);
1793}
1794
1795/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001796 * iucv_external_interrupt
1797 * @code: irq code
1798 *
1799 * Handles external interrupts coming in from CP.
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001800 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001801 */
Martin Schwidefskyf6649a72010-10-25 16:10:38 +02001802static void iucv_external_interrupt(unsigned int ext_int_code,
1803 unsigned int param32, unsigned long param64)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001804{
1805 struct iucv_irq_data *p;
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001806 struct iucv_irq_list *work;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001807
Heiko Carstens052ff462011-01-05 12:47:28 +01001808 kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++;
Christoph Lameter70cf50352007-11-20 11:13:38 +01001809 p = iucv_irq_data[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001810 if (p->ippathid >= iucv_max_pathid) {
Ursula Braunc2b4afd2008-07-14 09:59:29 +02001811 WARN_ON(p->ippathid >= iucv_max_pathid);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001812 iucv_sever_pathid(p->ippathid, iucv_error_no_listener);
1813 return;
1814 }
Ursula Braunc2b4afd2008-07-14 09:59:29 +02001815 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001816 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001817 if (!work) {
Ursula Braun8f7c5022008-12-25 13:39:47 +01001818 pr_warning("iucv_external_interrupt: out of memory\n");
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001819 return;
1820 }
1821 memcpy(&work->data, p, sizeof(work->data));
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001822 spin_lock(&iucv_queue_lock);
1823 if (p->iptype == 0x01) {
1824 /* Path pending interrupt. */
1825 list_add_tail(&work->list, &iucv_work_queue);
1826 schedule_work(&iucv_work);
1827 } else {
1828 /* The other interrupts. */
1829 list_add_tail(&work->list, &iucv_task_queue);
1830 tasklet_schedule(&iucv_tasklet);
1831 }
1832 spin_unlock(&iucv_queue_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001833}
1834
Ursula Braun672e4052009-06-16 10:30:42 +02001835static int iucv_pm_prepare(struct device *dev)
1836{
1837 int rc = 0;
1838
1839#ifdef CONFIG_PM_DEBUG
1840 printk(KERN_INFO "iucv_pm_prepare\n");
1841#endif
1842 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)
1843 rc = dev->driver->pm->prepare(dev);
1844 return rc;
1845}
1846
1847static void iucv_pm_complete(struct device *dev)
1848{
1849#ifdef CONFIG_PM_DEBUG
1850 printk(KERN_INFO "iucv_pm_complete\n");
1851#endif
1852 if (dev->driver && dev->driver->pm && dev->driver->pm->complete)
1853 dev->driver->pm->complete(dev);
1854}
1855
1856/**
1857 * iucv_path_table_empty() - determine if iucv path table is empty
1858 *
1859 * Returns 0 if there are still iucv pathes defined
1860 * 1 if there are no iucv pathes defined
1861 */
1862int iucv_path_table_empty(void)
1863{
1864 int i;
1865
1866 for (i = 0; i < iucv_max_pathid; i++) {
1867 if (iucv_path_table[i])
1868 return 0;
1869 }
1870 return 1;
1871}
1872
1873/**
1874 * iucv_pm_freeze() - Freeze PM callback
1875 * @dev: iucv-based device
1876 *
1877 * disable iucv interrupts
1878 * invoke callback function of the iucv-based driver
1879 * shut down iucv, if no iucv-pathes are established anymore
1880 */
1881static int iucv_pm_freeze(struct device *dev)
1882{
1883 int cpu;
Ursula Braunb7c2aec2009-11-12 21:46:27 +00001884 struct iucv_irq_list *p, *n;
Ursula Braun672e4052009-06-16 10:30:42 +02001885 int rc = 0;
1886
1887#ifdef CONFIG_PM_DEBUG
1888 printk(KERN_WARNING "iucv_pm_freeze\n");
1889#endif
Ursula Braunb7c2aec2009-11-12 21:46:27 +00001890 if (iucv_pm_state != IUCV_PM_FREEZING) {
1891 for_each_cpu_mask_nr(cpu, iucv_irq_cpumask)
1892 smp_call_function_single(cpu, iucv_block_cpu_almost,
1893 NULL, 1);
1894 cancel_work_sync(&iucv_work);
1895 list_for_each_entry_safe(p, n, &iucv_work_queue, list) {
1896 list_del_init(&p->list);
1897 iucv_sever_pathid(p->data.ippathid,
1898 iucv_error_no_listener);
1899 kfree(p);
1900 }
1901 }
Ursula Braun4c89d862009-09-16 04:37:22 +00001902 iucv_pm_state = IUCV_PM_FREEZING;
Ursula Braun672e4052009-06-16 10:30:42 +02001903 if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)
1904 rc = dev->driver->pm->freeze(dev);
1905 if (iucv_path_table_empty())
1906 iucv_disable();
1907 return rc;
1908}
1909
1910/**
1911 * iucv_pm_thaw() - Thaw PM callback
1912 * @dev: iucv-based device
1913 *
1914 * make iucv ready for use again: allocate path table, declare interrupt buffers
1915 * and enable iucv interrupts
1916 * invoke callback function of the iucv-based driver
1917 */
1918static int iucv_pm_thaw(struct device *dev)
1919{
1920 int rc = 0;
1921
1922#ifdef CONFIG_PM_DEBUG
1923 printk(KERN_WARNING "iucv_pm_thaw\n");
1924#endif
Ursula Braun4c89d862009-09-16 04:37:22 +00001925 iucv_pm_state = IUCV_PM_THAWING;
Ursula Braun672e4052009-06-16 10:30:42 +02001926 if (!iucv_path_table) {
1927 rc = iucv_enable();
1928 if (rc)
1929 goto out;
1930 }
1931 if (cpus_empty(iucv_irq_cpumask)) {
1932 if (iucv_nonsmp_handler)
1933 /* enable interrupts on one cpu */
1934 iucv_allow_cpu(NULL);
1935 else
1936 /* enable interrupts on all cpus */
1937 iucv_setmask_mp();
1938 }
1939 if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)
1940 rc = dev->driver->pm->thaw(dev);
1941out:
1942 return rc;
1943}
1944
1945/**
1946 * iucv_pm_restore() - Restore PM callback
1947 * @dev: iucv-based device
1948 *
1949 * make iucv ready for use again: allocate path table, declare interrupt buffers
1950 * and enable iucv interrupts
1951 * invoke callback function of the iucv-based driver
1952 */
1953static int iucv_pm_restore(struct device *dev)
1954{
1955 int rc = 0;
1956
1957#ifdef CONFIG_PM_DEBUG
1958 printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);
1959#endif
Ursula Braun4c89d862009-09-16 04:37:22 +00001960 if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)
1961 pr_warning("Suspending Linux did not completely close all IUCV "
1962 "connections\n");
1963 iucv_pm_state = IUCV_PM_RESTORING;
Ursula Braun672e4052009-06-16 10:30:42 +02001964 if (cpus_empty(iucv_irq_cpumask)) {
1965 rc = iucv_query_maxconn();
1966 rc = iucv_enable();
1967 if (rc)
1968 goto out;
1969 }
1970 if (dev->driver && dev->driver->pm && dev->driver->pm->restore)
1971 rc = dev->driver->pm->restore(dev);
1972out:
1973 return rc;
1974}
1975
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001976/**
1977 * iucv_init
1978 *
1979 * Allocates and initializes various data structures.
1980 */
Heiko Carstensda99f052007-05-04 12:23:27 -07001981static int __init iucv_init(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001982{
1983 int rc;
Christoph Lameter70cf50352007-11-20 11:13:38 +01001984 int cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001985
1986 if (!MACHINE_IS_VM) {
1987 rc = -EPROTONOSUPPORT;
1988 goto out;
1989 }
1990 rc = iucv_query_maxconn();
1991 if (rc)
1992 goto out;
Heiko Carstensda99f052007-05-04 12:23:27 -07001993 rc = register_external_interrupt(0x4000, iucv_external_interrupt);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001994 if (rc)
1995 goto out;
Mark McLoughlin035da162008-12-15 12:58:29 +00001996 iucv_root = root_device_register("iucv");
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001997 if (IS_ERR(iucv_root)) {
1998 rc = PTR_ERR(iucv_root);
Cornelia Huck2d7bf362008-04-10 02:12:45 -07001999 goto out_int;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002000 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01002001
2002 for_each_online_cpu(cpu) {
2003 /* Note: GFP_DMA used to get memory below 2G */
2004 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
2005 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2006 if (!iucv_irq_data[cpu]) {
2007 rc = -ENOMEM;
2008 goto out_free;
2009 }
2010
2011 /* Allocate parameter blocks. */
2012 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
2013 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2014 if (!iucv_param[cpu]) {
2015 rc = -ENOMEM;
2016 goto out_free;
2017 }
Ursula Braun42e1b4c2009-04-21 23:26:20 +00002018 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
2019 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2020 if (!iucv_param_irq[cpu]) {
2021 rc = -ENOMEM;
2022 goto out_free;
2023 }
2024
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002025 }
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002026 rc = register_hotcpu_notifier(&iucv_cpu_notifier);
2027 if (rc)
2028 goto out_free;
Ursula Braun6c005962009-06-16 10:30:41 +02002029 rc = register_reboot_notifier(&iucv_reboot_notifier);
2030 if (rc)
2031 goto out_cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002032 ASCEBC(iucv_error_no_listener, 16);
2033 ASCEBC(iucv_error_no_memory, 16);
2034 ASCEBC(iucv_error_pathid, 16);
2035 iucv_available = 1;
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002036 rc = bus_register(&iucv_bus);
2037 if (rc)
Ursula Braun6c005962009-06-16 10:30:41 +02002038 goto out_reboot;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002039 return 0;
2040
Ursula Braun6c005962009-06-16 10:30:41 +02002041out_reboot:
2042 unregister_reboot_notifier(&iucv_reboot_notifier);
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002043out_cpu:
2044 unregister_hotcpu_notifier(&iucv_cpu_notifier);
Christoph Lameter70cf50352007-11-20 11:13:38 +01002045out_free:
2046 for_each_possible_cpu(cpu) {
Ursula Braun42e1b4c2009-04-21 23:26:20 +00002047 kfree(iucv_param_irq[cpu]);
2048 iucv_param_irq[cpu] = NULL;
Christoph Lameter70cf50352007-11-20 11:13:38 +01002049 kfree(iucv_param[cpu]);
2050 iucv_param[cpu] = NULL;
2051 kfree(iucv_irq_data[cpu]);
2052 iucv_irq_data[cpu] = NULL;
2053 }
Mark McLoughlin035da162008-12-15 12:58:29 +00002054 root_device_unregister(iucv_root);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002055out_int:
2056 unregister_external_interrupt(0x4000, iucv_external_interrupt);
2057out:
2058 return rc;
2059}
2060
2061/**
2062 * iucv_exit
2063 *
2064 * Frees everything allocated from iucv_init.
2065 */
Heiko Carstensda99f052007-05-04 12:23:27 -07002066static void __exit iucv_exit(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002067{
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002068 struct iucv_irq_list *p, *n;
Christoph Lameter70cf50352007-11-20 11:13:38 +01002069 int cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002070
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002071 spin_lock_irq(&iucv_queue_lock);
2072 list_for_each_entry_safe(p, n, &iucv_task_queue, list)
2073 kfree(p);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002074 list_for_each_entry_safe(p, n, &iucv_work_queue, list)
2075 kfree(p);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002076 spin_unlock_irq(&iucv_queue_lock);
Ursula Braun6c005962009-06-16 10:30:41 +02002077 unregister_reboot_notifier(&iucv_reboot_notifier);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002078 unregister_hotcpu_notifier(&iucv_cpu_notifier);
Christoph Lameter70cf50352007-11-20 11:13:38 +01002079 for_each_possible_cpu(cpu) {
Ursula Braun42e1b4c2009-04-21 23:26:20 +00002080 kfree(iucv_param_irq[cpu]);
2081 iucv_param_irq[cpu] = NULL;
Christoph Lameter70cf50352007-11-20 11:13:38 +01002082 kfree(iucv_param[cpu]);
2083 iucv_param[cpu] = NULL;
2084 kfree(iucv_irq_data[cpu]);
2085 iucv_irq_data[cpu] = NULL;
2086 }
Mark McLoughlin035da162008-12-15 12:58:29 +00002087 root_device_unregister(iucv_root);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002088 bus_unregister(&iucv_bus);
2089 unregister_external_interrupt(0x4000, iucv_external_interrupt);
2090}
2091
2092subsys_initcall(iucv_init);
2093module_exit(iucv_exit);
2094
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002095MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2096MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2097MODULE_LICENSE("GPL");