blob: 88a2a3ba421227e3d355074e0bd639cf040d06d5 [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>
Arun Sharma600634972011-07-26 16:09:06 -070054#include <linux/atomic.h>
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -080055#include <asm/ebcdic.h>
56#include <asm/io.h>
Heiko Carstensd7b250e2011-05-26 09:48:24 +020057#include <asm/irq.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];
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000131static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE };
132static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE };
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800133
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 */
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200323static inline int __iucv_call_b2f0(int command, union iucv_param *parm)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800324{
325 register unsigned long reg0 asm ("0");
326 register unsigned long reg1 asm ("1");
327 int ccode;
328
329 reg0 = command;
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200330 reg1 = (unsigned long)parm;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800331 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");
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200337 return ccode;
338}
339
340static inline int iucv_call_b2f0(int command, union iucv_param *parm)
341{
342 int ccode;
343
344 ccode = __iucv_call_b2f0(command, parm);
345 return ccode == 1 ? parm->ctrl.iprcode : ccode;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800346}
347
348/**
349 * iucv_query_maxconn
350 *
351 * Determines the maximum number of connections that may be established.
352 *
353 * Returns the maximum number of connections or -EPERM is IUCV is not
354 * available.
355 */
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200356static int __iucv_query_maxconn(void *param, unsigned long *max_pathid)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800357{
358 register unsigned long reg0 asm ("0");
359 register unsigned long reg1 asm ("1");
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800360 int ccode;
361
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800362 reg0 = IUCV_QUERY;
363 reg1 = (unsigned long) param;
364 asm volatile (
365 " .long 0xb2f01000\n"
366 " ipm %0\n"
367 " srl %0,28\n"
368 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200369 *max_pathid = reg1;
370 return ccode;
371}
372
373static int iucv_query_maxconn(void)
374{
375 unsigned long max_pathid;
376 void *param;
377 int ccode;
378
379 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL | GFP_DMA);
380 if (!param)
381 return -ENOMEM;
382 ccode = __iucv_query_maxconn(param, &max_pathid);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800383 if (ccode == 0)
Heiko Carstenseb090ad2016-06-20 14:03:00 +0200384 iucv_max_pathid = max_pathid;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800385 kfree(param);
386 return ccode ? -EPERM : 0;
387}
388
389/**
390 * iucv_allow_cpu
391 * @data: unused
392 *
393 * Allow iucv interrupts on this cpu.
394 */
395static void iucv_allow_cpu(void *data)
396{
397 int cpu = smp_processor_id();
398 union iucv_param *parm;
399
400 /*
401 * Enable all iucv interrupts.
402 * ipmask contains bits for the different interrupts
403 * 0x80 - Flag to allow nonpriority message pending interrupts
404 * 0x40 - Flag to allow priority message pending interrupts
405 * 0x20 - Flag to allow nonpriority message completion interrupts
406 * 0x10 - Flag to allow priority message completion interrupts
407 * 0x08 - Flag to allow IUCV control interrupts
408 */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000409 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800410 memset(parm, 0, sizeof(union iucv_param));
411 parm->set_mask.ipmask = 0xf8;
412 iucv_call_b2f0(IUCV_SETMASK, parm);
413
Ursula Braun672e4052009-06-16 10:30:42 +0200414 /*
415 * Enable all iucv control interrupts.
416 * ipmask contains bits for the different interrupts
417 * 0x80 - Flag to allow pending connections interrupts
418 * 0x40 - Flag to allow connection complete interrupts
419 * 0x20 - Flag to allow connection severed interrupts
420 * 0x10 - Flag to allow connection quiesced interrupts
421 * 0x08 - Flag to allow connection resumed interrupts
422 */
423 memset(parm, 0, sizeof(union iucv_param));
424 parm->set_mask.ipmask = 0xf8;
425 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800426 /* Set indication that iucv interrupts are allowed for this cpu. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000427 cpumask_set_cpu(cpu, &iucv_irq_cpumask);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800428}
429
430/**
431 * iucv_block_cpu
432 * @data: unused
433 *
434 * Block iucv interrupts on this cpu.
435 */
436static void iucv_block_cpu(void *data)
437{
438 int cpu = smp_processor_id();
439 union iucv_param *parm;
440
441 /* Disable all iucv interrupts. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000442 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800443 memset(parm, 0, sizeof(union iucv_param));
444 iucv_call_b2f0(IUCV_SETMASK, parm);
445
446 /* Clear indication that iucv interrupts are allowed for this cpu. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000447 cpumask_clear_cpu(cpu, &iucv_irq_cpumask);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800448}
449
450/**
Ursula Braun672e4052009-06-16 10:30:42 +0200451 * iucv_block_cpu_almost
452 * @data: unused
453 *
454 * Allow connection-severed interrupts only on this cpu.
455 */
456static void iucv_block_cpu_almost(void *data)
457{
458 int cpu = smp_processor_id();
459 union iucv_param *parm;
460
461 /* Allow iucv control interrupts only */
462 parm = iucv_param_irq[cpu];
463 memset(parm, 0, sizeof(union iucv_param));
464 parm->set_mask.ipmask = 0x08;
465 iucv_call_b2f0(IUCV_SETMASK, parm);
466 /* Allow iucv-severed interrupt only */
467 memset(parm, 0, sizeof(union iucv_param));
468 parm->set_mask.ipmask = 0x20;
469 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
470
471 /* Clear indication that iucv interrupts are allowed for this cpu. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000472 cpumask_clear_cpu(cpu, &iucv_irq_cpumask);
Ursula Braun672e4052009-06-16 10:30:42 +0200473}
474
475/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800476 * iucv_declare_cpu
477 * @data: unused
478 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200479 * Declare a interrupt buffer on this cpu.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800480 */
481static void iucv_declare_cpu(void *data)
482{
483 int cpu = smp_processor_id();
484 union iucv_param *parm;
485 int rc;
486
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000487 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800488 return;
489
490 /* Declare interrupt buffer. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000491 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800492 memset(parm, 0, sizeof(union iucv_param));
Christoph Lameter70cf50352007-11-20 11:13:38 +0100493 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800494 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
495 if (rc) {
496 char *err = "Unknown";
Heiko Carstensda99f052007-05-04 12:23:27 -0700497 switch (rc) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800498 case 0x03:
499 err = "Directory error";
500 break;
501 case 0x0a:
502 err = "Invalid length";
503 break;
504 case 0x13:
505 err = "Buffer already exists";
506 break;
507 case 0x3e:
508 err = "Buffer overlap";
509 break;
510 case 0x5c:
511 err = "Paging or storage error";
512 break;
513 }
Joe Perches47c4cfc2014-09-09 21:17:31 -0700514 pr_warn("Defining an interrupt buffer on CPU %i failed with 0x%02x (%s)\n",
515 cpu, rc, err);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800516 return;
517 }
518
519 /* Set indication that an iucv buffer exists for this cpu. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000520 cpumask_set_cpu(cpu, &iucv_buffer_cpumask);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800521
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000522 if (iucv_nonsmp_handler == 0 || cpumask_empty(&iucv_irq_cpumask))
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800523 /* Enable iucv interrupts on this cpu. */
524 iucv_allow_cpu(NULL);
525 else
526 /* Disable iucv interrupts on this cpu. */
527 iucv_block_cpu(NULL);
528}
529
530/**
531 * iucv_retrieve_cpu
532 * @data: unused
533 *
534 * Retrieve interrupt buffer on this cpu.
535 */
536static void iucv_retrieve_cpu(void *data)
537{
538 int cpu = smp_processor_id();
539 union iucv_param *parm;
540
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000541 if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800542 return;
543
544 /* Block iucv interrupts. */
545 iucv_block_cpu(NULL);
546
547 /* Retrieve interrupt buffer. */
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000548 parm = iucv_param_irq[cpu];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800549 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
550
551 /* Clear indication that an iucv buffer exists for this cpu. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000552 cpumask_clear_cpu(cpu, &iucv_buffer_cpumask);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800553}
554
555/**
556 * iucv_setmask_smp
557 *
558 * Allow iucv interrupts on all cpus.
559 */
560static void iucv_setmask_mp(void)
561{
562 int cpu;
563
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700564 get_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800565 for_each_online_cpu(cpu)
566 /* Enable all cpus with a declared buffer. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000567 if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) &&
568 !cpumask_test_cpu(cpu, &iucv_irq_cpumask))
Heiko Carstens3bb447f2007-07-27 12:29:08 +0200569 smp_call_function_single(cpu, iucv_allow_cpu,
Jens Axboe8691e5a2008-06-06 11:18:06 +0200570 NULL, 1);
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700571 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800572}
573
574/**
575 * iucv_setmask_up
576 *
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700577 * Allow iucv interrupts on a single cpu.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800578 */
579static void iucv_setmask_up(void)
580{
581 cpumask_t cpumask;
582 int cpu;
583
584 /* Disable all cpu but the first in cpu_irq_cpumask. */
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000585 cpumask_copy(&cpumask, &iucv_irq_cpumask);
586 cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask);
587 for_each_cpu(cpu, &cpumask)
Jens Axboe8691e5a2008-06-06 11:18:06 +0200588 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800589}
590
591/**
592 * iucv_enable
593 *
594 * This function makes iucv ready for use. It allocates the pathid
595 * table, declares an iucv interrupt buffer and enables the iucv
596 * interrupts. Called when the first user has registered an iucv
597 * handler.
598 */
599static int iucv_enable(void)
600{
601 size_t alloc_size;
602 int cpu, rc;
603
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800604 get_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800605 rc = -ENOMEM;
606 alloc_size = iucv_max_pathid * sizeof(struct iucv_path);
607 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
608 if (!iucv_path_table)
609 goto out;
610 /* Declare per cpu buffers. */
611 rc = -EIO;
612 for_each_online_cpu(cpu)
Jens Axboe8691e5a2008-06-06 11:18:06 +0200613 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000614 if (cpumask_empty(&iucv_buffer_cpumask))
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800615 /* No cpu could declare an iucv buffer. */
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800616 goto out;
Heiko Carstens7b9d1b22008-06-09 15:50:30 -0700617 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800618 return 0;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800619out:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800620 kfree(iucv_path_table);
621 iucv_path_table = NULL;
622 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800623 return rc;
624}
625
626/**
627 * iucv_disable
628 *
629 * This function shuts down iucv. It disables iucv interrupts, retrieves
630 * the iucv interrupt buffer and frees the pathid table. Called after the
631 * last user unregister its iucv handler.
632 */
633static void iucv_disable(void)
634{
Heiko Carstens8b122ef2008-09-30 03:03:35 -0700635 get_online_cpus();
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200636 on_each_cpu(iucv_retrieve_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800637 kfree(iucv_path_table);
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800638 iucv_path_table = NULL;
639 put_online_cpus();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800640}
641
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +0530642static void free_iucv_data(int cpu)
643{
644 kfree(iucv_param_irq[cpu]);
645 iucv_param_irq[cpu] = NULL;
646 kfree(iucv_param[cpu]);
647 iucv_param[cpu] = NULL;
648 kfree(iucv_irq_data[cpu]);
649 iucv_irq_data[cpu] = NULL;
650}
651
652static int alloc_iucv_data(int cpu)
653{
654 /* Note: GFP_DMA used to get memory below 2G */
655 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
656 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
657 if (!iucv_irq_data[cpu])
658 goto out_free;
659
660 /* Allocate parameter blocks. */
661 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
662 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
663 if (!iucv_param[cpu])
664 goto out_free;
665
666 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
667 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
668 if (!iucv_param_irq[cpu])
669 goto out_free;
670
671 return 0;
672
673out_free:
674 free_iucv_data(cpu);
675 return -ENOMEM;
676}
677
Paul Gortmaker013dbb32013-06-19 14:32:33 -0400678static int iucv_cpu_notify(struct notifier_block *self,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800679 unsigned long action, void *hcpu)
680{
681 cpumask_t cpumask;
682 long cpu = (long) hcpu;
683
684 switch (action) {
685 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700686 case CPU_UP_PREPARE_FROZEN:
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +0530687 if (alloc_iucv_data(cpu))
Akinobu Mita92e99a92010-05-26 14:43:33 -0700688 return notifier_from_errno(-ENOMEM);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800689 break;
690 case CPU_UP_CANCELED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700691 case CPU_UP_CANCELED_FROZEN:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800692 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700693 case CPU_DEAD_FROZEN:
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +0530694 free_iucv_data(cpu);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800695 break;
696 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700697 case CPU_ONLINE_FROZEN:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800698 case CPU_DOWN_FAILED:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700699 case CPU_DOWN_FAILED_FROZEN:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800700 if (!iucv_path_table)
701 break;
Jens Axboe8691e5a2008-06-06 11:18:06 +0200702 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800703 break;
704 case CPU_DOWN_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700705 case CPU_DOWN_PREPARE_FROZEN:
Heiko Carstensf1d3e4d2009-01-05 18:09:02 -0800706 if (!iucv_path_table)
707 break;
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000708 cpumask_copy(&cpumask, &iucv_buffer_cpumask);
709 cpumask_clear_cpu(cpu, &cpumask);
710 if (cpumask_empty(&cpumask))
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800711 /* Can't offline last IUCV enabled cpu. */
Akinobu Mita92e99a92010-05-26 14:43:33 -0700712 return notifier_from_errno(-EINVAL);
Jens Axboe8691e5a2008-06-06 11:18:06 +0200713 smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1);
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000714 if (cpumask_empty(&iucv_irq_cpumask))
715 smp_call_function_single(
716 cpumask_first(&iucv_buffer_cpumask),
717 iucv_allow_cpu, NULL, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800718 break;
719 }
720 return NOTIFY_OK;
721}
722
Heiko Carstensf1494ed2008-06-09 15:49:57 -0700723static struct notifier_block __refdata iucv_cpu_notifier = {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800724 .notifier_call = iucv_cpu_notify,
725};
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800726
727/**
728 * iucv_sever_pathid
729 * @pathid: path identification number.
730 * @userdata: 16-bytes of user data.
731 *
732 * Sever an iucv path to free up the pathid. Used internally.
733 */
Ursula Braun91e60eb2015-09-18 16:06:52 +0200734static int iucv_sever_pathid(u16 pathid, u8 *userdata)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800735{
736 union iucv_param *parm;
737
Ursula Braun42e1b4c2009-04-21 23:26:20 +0000738 parm = iucv_param_irq[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800739 memset(parm, 0, sizeof(union iucv_param));
740 if (userdata)
741 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
742 parm->ctrl.ippathid = pathid;
743 return iucv_call_b2f0(IUCV_SEVER, parm);
744}
745
746/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700747 * __iucv_cleanup_queue
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800748 * @dummy: unused dummy argument
749 *
750 * Nop function called via smp_call_function to force work items from
751 * pending external iucv interrupts to the work queue.
752 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700753static void __iucv_cleanup_queue(void *dummy)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800754{
755}
756
757/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700758 * iucv_cleanup_queue
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800759 *
760 * Function called after a path has been severed to find all remaining
761 * work items for the now stale pathid. The caller needs to hold the
762 * iucv_table_lock.
763 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700764static void iucv_cleanup_queue(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800765{
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700766 struct iucv_irq_list *p, *n;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800767
768 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300769 * When a path is severed, the pathid can be reused immediately
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700770 * on a iucv connect or a connection pending interrupt. Remove
771 * all entries from the task queue that refer to a stale pathid
772 * (iucv_path_table[ix] == NULL). Only then do the iucv connect
773 * or deliver the connection pending interrupt. To get all the
774 * pending interrupts force them to the work queue by calling
775 * an empty function on all cpus.
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800776 */
Jens Axboe8691e5a2008-06-06 11:18:06 +0200777 smp_call_function(__iucv_cleanup_queue, NULL, 1);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700778 spin_lock_irq(&iucv_queue_lock);
779 list_for_each_entry_safe(p, n, &iucv_task_queue, list) {
780 /* Remove stale work items from the task queue. */
781 if (iucv_path_table[p->data.ippathid] == NULL) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800782 list_del(&p->list);
783 kfree(p);
784 }
785 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700786 spin_unlock_irq(&iucv_queue_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800787}
788
789/**
790 * iucv_register:
791 * @handler: address of iucv handler structure
792 * @smp: != 0 indicates that the handler can deal with out of order messages
793 *
794 * Registers a driver with IUCV.
795 *
796 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid
797 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
798 */
799int iucv_register(struct iucv_handler *handler, int smp)
800{
801 int rc;
802
803 if (!iucv_available)
804 return -ENOSYS;
805 mutex_lock(&iucv_register_mutex);
806 if (!smp)
807 iucv_nonsmp_handler++;
808 if (list_empty(&iucv_handler_list)) {
809 rc = iucv_enable();
810 if (rc)
811 goto out_mutex;
812 } else if (!smp && iucv_nonsmp_handler == 1)
813 iucv_setmask_up();
814 INIT_LIST_HEAD(&handler->paths);
815
Ursula Braun435bc9d2008-02-07 18:06:52 -0800816 spin_lock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800817 list_add_tail(&handler->list, &iucv_handler_list);
Ursula Braun435bc9d2008-02-07 18:06:52 -0800818 spin_unlock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800819 rc = 0;
820out_mutex:
821 mutex_unlock(&iucv_register_mutex);
822 return rc;
823}
Heiko Carstensda99f052007-05-04 12:23:27 -0700824EXPORT_SYMBOL(iucv_register);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800825
826/**
827 * iucv_unregister
828 * @handler: address of iucv handler structure
829 * @smp: != 0 indicates that the handler can deal with out of order messages
830 *
831 * Unregister driver from IUCV.
832 */
833void iucv_unregister(struct iucv_handler *handler, int smp)
834{
835 struct iucv_path *p, *n;
836
837 mutex_lock(&iucv_register_mutex);
838 spin_lock_bh(&iucv_table_lock);
839 /* Remove handler from the iucv_handler_list. */
840 list_del_init(&handler->list);
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300841 /* Sever all pathids still referring to the handler. */
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800842 list_for_each_entry_safe(p, n, &handler->paths, list) {
843 iucv_sever_pathid(p->pathid, NULL);
844 iucv_path_table[p->pathid] = NULL;
845 list_del(&p->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800846 iucv_path_free(p);
847 }
848 spin_unlock_bh(&iucv_table_lock);
849 if (!smp)
850 iucv_nonsmp_handler--;
851 if (list_empty(&iucv_handler_list))
852 iucv_disable();
853 else if (!smp && iucv_nonsmp_handler == 0)
854 iucv_setmask_mp();
855 mutex_unlock(&iucv_register_mutex);
856}
Heiko Carstensda99f052007-05-04 12:23:27 -0700857EXPORT_SYMBOL(iucv_unregister);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800858
Ursula Braun6c005962009-06-16 10:30:41 +0200859static int iucv_reboot_event(struct notifier_block *this,
860 unsigned long event, void *ptr)
861{
Ursula Braun5db79c02011-05-12 18:45:07 +0000862 int i;
Ursula Braun6c005962009-06-16 10:30:41 +0200863
Hendrik Bruecknerc0048de2013-02-06 16:12:03 +0100864 if (cpumask_empty(&iucv_irq_cpumask))
865 return NOTIFY_DONE;
866
Ursula Braun6c005962009-06-16 10:30:41 +0200867 get_online_cpus();
Hendrik Bruecknerc0048de2013-02-06 16:12:03 +0100868 on_each_cpu_mask(&iucv_irq_cpumask, iucv_block_cpu, NULL, 1);
Ursula Braun6c005962009-06-16 10:30:41 +0200869 preempt_disable();
870 for (i = 0; i < iucv_max_pathid; i++) {
871 if (iucv_path_table[i])
Ursula Braun5db79c02011-05-12 18:45:07 +0000872 iucv_sever_pathid(i, NULL);
Ursula Braun6c005962009-06-16 10:30:41 +0200873 }
874 preempt_enable();
875 put_online_cpus();
876 iucv_disable();
877 return NOTIFY_DONE;
878}
879
880static struct notifier_block iucv_reboot_notifier = {
881 .notifier_call = iucv_reboot_event,
882};
883
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800884/**
885 * iucv_path_accept
886 * @path: address of iucv path structure
887 * @handler: address of iucv handler structure
888 * @userdata: 16 bytes of data reflected to the communication partner
889 * @private: private data passed to interrupt handlers for this path
890 *
891 * This function is issued after the user received a connection pending
892 * external interrupt and now wishes to complete the IUCV communication path.
893 *
894 * Returns the result of the CP IUCV call.
895 */
896int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
Ursula Braun91e60eb2015-09-18 16:06:52 +0200897 u8 *userdata, void *private)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800898{
899 union iucv_param *parm;
900 int rc;
901
902 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000903 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +0200904 rc = -EIO;
905 goto out;
906 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800907 /* Prepare parameter block. */
Christoph Lameter70cf50352007-11-20 11:13:38 +0100908 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800909 memset(parm, 0, sizeof(union iucv_param));
910 parm->ctrl.ippathid = path->pathid;
911 parm->ctrl.ipmsglim = path->msglim;
912 if (userdata)
913 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
914 parm->ctrl.ipflags1 = path->flags;
915
916 rc = iucv_call_b2f0(IUCV_ACCEPT, parm);
917 if (!rc) {
918 path->private = private;
919 path->msglim = parm->ctrl.ipmsglim;
920 path->flags = parm->ctrl.ipflags1;
921 }
Ursula Braun6c005962009-06-16 10:30:41 +0200922out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800923 local_bh_enable();
924 return rc;
925}
Heiko Carstensda99f052007-05-04 12:23:27 -0700926EXPORT_SYMBOL(iucv_path_accept);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800927
928/**
929 * iucv_path_connect
930 * @path: address of iucv path structure
931 * @handler: address of iucv handler structure
932 * @userid: 8-byte user identification
933 * @system: 8-byte target system identification
934 * @userdata: 16 bytes of data reflected to the communication partner
935 * @private: private data passed to interrupt handlers for this path
936 *
937 * This function establishes an IUCV path. Although the connect may complete
938 * successfully, you are not able to use the path until you receive an IUCV
939 * Connection Complete external interrupt.
940 *
941 * Returns the result of the CP IUCV call.
942 */
943int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
Ursula Braun91e60eb2015-09-18 16:06:52 +0200944 u8 *userid, u8 *system, u8 *userdata,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800945 void *private)
946{
947 union iucv_param *parm;
948 int rc;
949
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700950 spin_lock_bh(&iucv_table_lock);
951 iucv_cleanup_queue();
KOSAKI Motohirof2019032011-05-12 18:45:09 +0000952 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +0200953 rc = -EIO;
954 goto out;
955 }
Christoph Lameter70cf50352007-11-20 11:13:38 +0100956 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800957 memset(parm, 0, sizeof(union iucv_param));
958 parm->ctrl.ipmsglim = path->msglim;
959 parm->ctrl.ipflags1 = path->flags;
960 if (userid) {
961 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));
962 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
963 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
964 }
965 if (system) {
966 memcpy(parm->ctrl.iptarget, system,
967 sizeof(parm->ctrl.iptarget));
968 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
969 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
970 }
971 if (userdata)
972 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
973
974 rc = iucv_call_b2f0(IUCV_CONNECT, parm);
975 if (!rc) {
976 if (parm->ctrl.ippathid < iucv_max_pathid) {
977 path->pathid = parm->ctrl.ippathid;
978 path->msglim = parm->ctrl.ipmsglim;
979 path->flags = parm->ctrl.ipflags1;
980 path->handler = handler;
981 path->private = private;
982 list_add_tail(&path->list, &handler->paths);
983 iucv_path_table[path->pathid] = path;
984 } else {
985 iucv_sever_pathid(parm->ctrl.ippathid,
986 iucv_error_pathid);
987 rc = -EIO;
988 }
989 }
Ursula Braun6c005962009-06-16 10:30:41 +0200990out:
Martin Schwidefsky04b090d2007-04-28 23:03:59 -0700991 spin_unlock_bh(&iucv_table_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800992 return rc;
993}
Heiko Carstensda99f052007-05-04 12:23:27 -0700994EXPORT_SYMBOL(iucv_path_connect);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -0800995
996/**
997 * iucv_path_quiesce:
998 * @path: address of iucv path structure
999 * @userdata: 16 bytes of data reflected to the communication partner
1000 *
1001 * This function temporarily suspends incoming messages on an IUCV path.
1002 * You can later reactivate the path by invoking the iucv_resume function.
1003 *
1004 * Returns the result from the CP IUCV call.
1005 */
Ursula Braun91e60eb2015-09-18 16:06:52 +02001006int iucv_path_quiesce(struct iucv_path *path, u8 *userdata)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001007{
1008 union iucv_param *parm;
1009 int rc;
1010
1011 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001012 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001013 rc = -EIO;
1014 goto out;
1015 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001016 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001017 memset(parm, 0, sizeof(union iucv_param));
1018 if (userdata)
1019 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
1020 parm->ctrl.ippathid = path->pathid;
1021 rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001022out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001023 local_bh_enable();
1024 return rc;
1025}
Heiko Carstensda99f052007-05-04 12:23:27 -07001026EXPORT_SYMBOL(iucv_path_quiesce);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001027
1028/**
1029 * iucv_path_resume:
1030 * @path: address of iucv path structure
1031 * @userdata: 16 bytes of data reflected to the communication partner
1032 *
1033 * This function resumes incoming messages on an IUCV path that has
1034 * been stopped with iucv_path_quiesce.
1035 *
1036 * Returns the result from the CP IUCV call.
1037 */
Ursula Braun91e60eb2015-09-18 16:06:52 +02001038int iucv_path_resume(struct iucv_path *path, u8 *userdata)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001039{
1040 union iucv_param *parm;
1041 int rc;
1042
1043 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001044 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001045 rc = -EIO;
1046 goto out;
1047 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001048 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001049 memset(parm, 0, sizeof(union iucv_param));
1050 if (userdata)
1051 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
1052 parm->ctrl.ippathid = path->pathid;
1053 rc = iucv_call_b2f0(IUCV_RESUME, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001054out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001055 local_bh_enable();
1056 return rc;
1057}
1058
1059/**
1060 * iucv_path_sever
1061 * @path: address of iucv path structure
1062 * @userdata: 16 bytes of data reflected to the communication partner
1063 *
1064 * This function terminates an IUCV path.
1065 *
1066 * Returns the result from the CP IUCV call.
1067 */
Ursula Braun91e60eb2015-09-18 16:06:52 +02001068int iucv_path_sever(struct iucv_path *path, u8 *userdata)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001069{
1070 int rc;
1071
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001072 preempt_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001073 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001074 rc = -EIO;
1075 goto out;
1076 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001077 if (iucv_active_cpu != smp_processor_id())
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001078 spin_lock_bh(&iucv_table_lock);
1079 rc = iucv_sever_pathid(path->pathid, userdata);
Ursula Braun42e1b4c2009-04-21 23:26:20 +00001080 iucv_path_table[path->pathid] = NULL;
1081 list_del_init(&path->list);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001082 if (iucv_active_cpu != smp_processor_id())
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001083 spin_unlock_bh(&iucv_table_lock);
Ursula Braun6c005962009-06-16 10:30:41 +02001084out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001085 preempt_enable();
1086 return rc;
1087}
Heiko Carstensda99f052007-05-04 12:23:27 -07001088EXPORT_SYMBOL(iucv_path_sever);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001089
1090/**
1091 * iucv_message_purge
1092 * @path: address of iucv path structure
1093 * @msg: address of iucv msg structure
1094 * @srccls: source class of message
1095 *
1096 * Cancels a message you have sent.
1097 *
1098 * Returns the result from the CP IUCV call.
1099 */
1100int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
1101 u32 srccls)
1102{
1103 union iucv_param *parm;
1104 int rc;
1105
1106 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001107 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001108 rc = -EIO;
1109 goto out;
1110 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001111 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001112 memset(parm, 0, sizeof(union iucv_param));
1113 parm->purge.ippathid = path->pathid;
1114 parm->purge.ipmsgid = msg->id;
1115 parm->purge.ipsrccls = srccls;
1116 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID;
1117 rc = iucv_call_b2f0(IUCV_PURGE, parm);
1118 if (!rc) {
1119 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8;
1120 msg->tag = parm->purge.ipmsgtag;
1121 }
Ursula Braun6c005962009-06-16 10:30:41 +02001122out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001123 local_bh_enable();
1124 return rc;
1125}
Heiko Carstensda99f052007-05-04 12:23:27 -07001126EXPORT_SYMBOL(iucv_message_purge);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001127
1128/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001129 * iucv_message_receive_iprmdata
1130 * @path: address of iucv path structure
1131 * @msg: address of iucv msg structure
1132 * @flags: how the message is received (IUCV_IPBUFLST)
1133 * @buffer: address of data buffer or address of struct iucv_array
1134 * @size: length of data buffer
1135 * @residual:
1136 *
1137 * Internal function used by iucv_message_receive and __iucv_message_receive
1138 * to receive RMDATA data stored in struct iucv_message.
1139 */
1140static int iucv_message_receive_iprmdata(struct iucv_path *path,
1141 struct iucv_message *msg,
1142 u8 flags, void *buffer,
1143 size_t size, size_t *residual)
1144{
1145 struct iucv_array *array;
1146 u8 *rmmsg;
1147 size_t copy;
1148
1149 /*
1150 * Message is 8 bytes long and has been stored to the
1151 * message descriptor itself.
1152 */
1153 if (residual)
1154 *residual = abs(size - 8);
1155 rmmsg = msg->rmmsg;
1156 if (flags & IUCV_IPBUFLST) {
1157 /* Copy to struct iucv_array. */
1158 size = (size < 8) ? size : 8;
1159 for (array = buffer; size > 0; array++) {
1160 copy = min_t(size_t, size, array->length);
1161 memcpy((u8 *)(addr_t) array->address,
1162 rmmsg, copy);
1163 rmmsg += copy;
1164 size -= copy;
1165 }
1166 } else {
1167 /* Copy to direct buffer. */
1168 memcpy(buffer, rmmsg, min_t(size_t, size, 8));
1169 }
1170 return 0;
1171}
1172
1173/**
1174 * __iucv_message_receive
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001175 * @path: address of iucv path structure
1176 * @msg: address of iucv msg structure
1177 * @flags: how the message is received (IUCV_IPBUFLST)
1178 * @buffer: address of data buffer or address of struct iucv_array
1179 * @size: length of data buffer
1180 * @residual:
1181 *
1182 * This function receives messages that are being sent to you over
1183 * established paths. This function will deal with RMDATA messages
1184 * embedded in struct iucv_message as well.
1185 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001186 * Locking: no locking
1187 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001188 * Returns the result from the CP IUCV call.
1189 */
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001190int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1191 u8 flags, void *buffer, size_t size, size_t *residual)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001192{
1193 union iucv_param *parm;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001194 int rc;
1195
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001196 if (msg->flags & IUCV_IPRMDATA)
1197 return iucv_message_receive_iprmdata(path, msg, flags,
1198 buffer, size, residual);
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001199 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001200 rc = -EIO;
1201 goto out;
1202 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001203 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001204 memset(parm, 0, sizeof(union iucv_param));
1205 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1206 parm->db.ipbfln1f = (u32) size;
1207 parm->db.ipmsgid = msg->id;
1208 parm->db.ippathid = path->pathid;
1209 parm->db.iptrgcls = msg->class;
1210 parm->db.ipflags1 = (flags | IUCV_IPFGPID |
1211 IUCV_IPFGMID | IUCV_IPTRGCLS);
1212 rc = iucv_call_b2f0(IUCV_RECEIVE, parm);
1213 if (!rc || rc == 5) {
1214 msg->flags = parm->db.ipflags1;
1215 if (residual)
1216 *residual = parm->db.ipbfln1f;
1217 }
Ursula Braun6c005962009-06-16 10:30:41 +02001218out:
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001219 return rc;
1220}
1221EXPORT_SYMBOL(__iucv_message_receive);
1222
1223/**
1224 * iucv_message_receive
1225 * @path: address of iucv path structure
1226 * @msg: address of iucv msg structure
1227 * @flags: how the message is received (IUCV_IPBUFLST)
1228 * @buffer: address of data buffer or address of struct iucv_array
1229 * @size: length of data buffer
1230 * @residual:
1231 *
1232 * This function receives messages that are being sent to you over
1233 * established paths. This function will deal with RMDATA messages
1234 * embedded in struct iucv_message as well.
1235 *
1236 * Locking: local_bh_enable/local_bh_disable
1237 *
1238 * Returns the result from the CP IUCV call.
1239 */
1240int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1241 u8 flags, void *buffer, size_t size, size_t *residual)
1242{
1243 int rc;
1244
1245 if (msg->flags & IUCV_IPRMDATA)
1246 return iucv_message_receive_iprmdata(path, msg, flags,
1247 buffer, size, residual);
1248 local_bh_disable();
1249 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
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_receive);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001254
1255/**
1256 * iucv_message_reject
1257 * @path: address of iucv path structure
1258 * @msg: address of iucv msg structure
1259 *
1260 * The reject function refuses a specified message. Between the time you
1261 * are notified of a message and the time that you complete the message,
1262 * the message may be rejected.
1263 *
1264 * Returns the result from the CP IUCV call.
1265 */
1266int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
1267{
1268 union iucv_param *parm;
1269 int rc;
1270
1271 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001272 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001273 rc = -EIO;
1274 goto out;
1275 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001276 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001277 memset(parm, 0, sizeof(union iucv_param));
1278 parm->db.ippathid = path->pathid;
1279 parm->db.ipmsgid = msg->id;
1280 parm->db.iptrgcls = msg->class;
1281 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID);
1282 rc = iucv_call_b2f0(IUCV_REJECT, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001283out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001284 local_bh_enable();
1285 return rc;
1286}
Heiko Carstensda99f052007-05-04 12:23:27 -07001287EXPORT_SYMBOL(iucv_message_reject);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001288
1289/**
1290 * iucv_message_reply
1291 * @path: address of iucv path structure
1292 * @msg: address of iucv msg structure
1293 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1294 * @reply: address of reply data buffer or address of struct iucv_array
1295 * @size: length of reply data buffer
1296 *
1297 * This function responds to the two-way messages that you receive. You
1298 * must identify completely the message to which you wish to reply. ie,
1299 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
1300 * the parameter list.
1301 *
1302 * Returns the result from the CP IUCV call.
1303 */
1304int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
1305 u8 flags, void *reply, size_t size)
1306{
1307 union iucv_param *parm;
1308 int rc;
1309
1310 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001311 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001312 rc = -EIO;
1313 goto out;
1314 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001315 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001316 memset(parm, 0, sizeof(union iucv_param));
1317 if (flags & IUCV_IPRMDATA) {
1318 parm->dpl.ippathid = path->pathid;
1319 parm->dpl.ipflags1 = flags;
1320 parm->dpl.ipmsgid = msg->id;
1321 parm->dpl.iptrgcls = msg->class;
1322 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));
1323 } else {
1324 parm->db.ipbfadr1 = (u32)(addr_t) reply;
1325 parm->db.ipbfln1f = (u32) size;
1326 parm->db.ippathid = path->pathid;
1327 parm->db.ipflags1 = flags;
1328 parm->db.ipmsgid = msg->id;
1329 parm->db.iptrgcls = msg->class;
1330 }
1331 rc = iucv_call_b2f0(IUCV_REPLY, parm);
Ursula Braun6c005962009-06-16 10:30:41 +02001332out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001333 local_bh_enable();
1334 return rc;
1335}
Heiko Carstensda99f052007-05-04 12:23:27 -07001336EXPORT_SYMBOL(iucv_message_reply);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001337
1338/**
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001339 * __iucv_message_send
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001340 * @path: address of iucv path structure
1341 * @msg: address of iucv msg structure
1342 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1343 * @srccls: source class of message
1344 * @buffer: address of send buffer or address of struct iucv_array
1345 * @size: length of send buffer
1346 *
1347 * This function transmits data to another application. Data to be
1348 * transmitted is in a buffer and this is a one-way message and the
1349 * receiver will not reply to the message.
1350 *
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001351 * Locking: no locking
1352 *
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001353 * Returns the result from the CP IUCV call.
1354 */
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001355int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001356 u8 flags, u32 srccls, void *buffer, size_t size)
1357{
1358 union iucv_param *parm;
1359 int rc;
1360
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001361 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001362 rc = -EIO;
1363 goto out;
1364 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001365 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001366 memset(parm, 0, sizeof(union iucv_param));
1367 if (flags & IUCV_IPRMDATA) {
1368 /* Message of 8 bytes can be placed into the parameter list. */
1369 parm->dpl.ippathid = path->pathid;
1370 parm->dpl.ipflags1 = flags | IUCV_IPNORPY;
1371 parm->dpl.iptrgcls = msg->class;
1372 parm->dpl.ipsrccls = srccls;
1373 parm->dpl.ipmsgtag = msg->tag;
1374 memcpy(parm->dpl.iprmmsg, buffer, 8);
1375 } else {
1376 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1377 parm->db.ipbfln1f = (u32) size;
1378 parm->db.ippathid = path->pathid;
1379 parm->db.ipflags1 = flags | IUCV_IPNORPY;
1380 parm->db.iptrgcls = msg->class;
1381 parm->db.ipsrccls = srccls;
1382 parm->db.ipmsgtag = msg->tag;
1383 }
1384 rc = iucv_call_b2f0(IUCV_SEND, parm);
1385 if (!rc)
1386 msg->id = parm->db.ipmsgid;
Ursula Braun6c005962009-06-16 10:30:41 +02001387out:
Hendrik Brueckner91d5d45e2008-12-25 13:38:58 +01001388 return rc;
1389}
1390EXPORT_SYMBOL(__iucv_message_send);
1391
1392/**
1393 * iucv_message_send
1394 * @path: address of iucv path structure
1395 * @msg: address of iucv msg structure
1396 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1397 * @srccls: source class of message
1398 * @buffer: address of send buffer or address of struct iucv_array
1399 * @size: length of send buffer
1400 *
1401 * This function transmits data to another application. Data to be
1402 * transmitted is in a buffer and this is a one-way message and the
1403 * receiver will not reply to the message.
1404 *
1405 * Locking: local_bh_enable/local_bh_disable
1406 *
1407 * Returns the result from the CP IUCV call.
1408 */
1409int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1410 u8 flags, u32 srccls, void *buffer, size_t size)
1411{
1412 int rc;
1413
1414 local_bh_disable();
1415 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001416 local_bh_enable();
1417 return rc;
1418}
Heiko Carstensda99f052007-05-04 12:23:27 -07001419EXPORT_SYMBOL(iucv_message_send);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001420
1421/**
1422 * iucv_message_send2way
1423 * @path: address of iucv path structure
1424 * @msg: address of iucv msg structure
1425 * @flags: how the message is sent and the reply is received
1426 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
1427 * @srccls: source class of message
1428 * @buffer: address of send buffer or address of struct iucv_array
1429 * @size: length of send buffer
1430 * @ansbuf: address of answer buffer or address of struct iucv_array
1431 * @asize: size of reply buffer
1432 *
1433 * This function transmits data to another application. Data to be
1434 * transmitted is in a buffer. The receiver of the send is expected to
1435 * reply to the message and a buffer is provided into which IUCV moves
1436 * the reply to this message.
1437 *
1438 * Returns the result from the CP IUCV call.
1439 */
1440int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
1441 u8 flags, u32 srccls, void *buffer, size_t size,
1442 void *answer, size_t asize, size_t *residual)
1443{
1444 union iucv_param *parm;
1445 int rc;
1446
1447 local_bh_disable();
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001448 if (cpumask_empty(&iucv_buffer_cpumask)) {
Ursula Braun6c005962009-06-16 10:30:41 +02001449 rc = -EIO;
1450 goto out;
1451 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01001452 parm = iucv_param[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001453 memset(parm, 0, sizeof(union iucv_param));
1454 if (flags & IUCV_IPRMDATA) {
1455 parm->dpl.ippathid = path->pathid;
1456 parm->dpl.ipflags1 = path->flags; /* priority message */
1457 parm->dpl.iptrgcls = msg->class;
1458 parm->dpl.ipsrccls = srccls;
1459 parm->dpl.ipmsgtag = msg->tag;
1460 parm->dpl.ipbfadr2 = (u32)(addr_t) answer;
1461 parm->dpl.ipbfln2f = (u32) asize;
1462 memcpy(parm->dpl.iprmmsg, buffer, 8);
1463 } else {
1464 parm->db.ippathid = path->pathid;
1465 parm->db.ipflags1 = path->flags; /* priority message */
1466 parm->db.iptrgcls = msg->class;
1467 parm->db.ipsrccls = srccls;
1468 parm->db.ipmsgtag = msg->tag;
1469 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1470 parm->db.ipbfln1f = (u32) size;
1471 parm->db.ipbfadr2 = (u32)(addr_t) answer;
1472 parm->db.ipbfln2f = (u32) asize;
1473 }
1474 rc = iucv_call_b2f0(IUCV_SEND, parm);
1475 if (!rc)
1476 msg->id = parm->db.ipmsgid;
Ursula Braun6c005962009-06-16 10:30:41 +02001477out:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001478 local_bh_enable();
1479 return rc;
1480}
Heiko Carstensda99f052007-05-04 12:23:27 -07001481EXPORT_SYMBOL(iucv_message_send2way);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001482
1483/**
1484 * iucv_path_pending
1485 * @data: Pointer to external interrupt buffer
1486 *
1487 * Process connection pending work item. Called from tasklet while holding
1488 * iucv_table_lock.
1489 */
1490struct iucv_path_pending {
1491 u16 ippathid;
1492 u8 ipflags1;
1493 u8 iptype;
1494 u16 ipmsglim;
1495 u16 res1;
1496 u8 ipvmid[8];
1497 u8 ipuser[16];
1498 u32 res3;
1499 u8 ippollfg;
1500 u8 res4[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001501} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001502
1503static void iucv_path_pending(struct iucv_irq_data *data)
1504{
1505 struct iucv_path_pending *ipp = (void *) data;
1506 struct iucv_handler *handler;
1507 struct iucv_path *path;
1508 char *error;
1509
1510 BUG_ON(iucv_path_table[ipp->ippathid]);
1511 /* New pathid, handler found. Create a new path struct. */
1512 error = iucv_error_no_memory;
1513 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);
1514 if (!path)
1515 goto out_sever;
1516 path->pathid = ipp->ippathid;
1517 iucv_path_table[path->pathid] = path;
1518 EBCASC(ipp->ipvmid, 8);
1519
1520 /* Call registered handler until one is found that wants the path. */
1521 list_for_each_entry(handler, &iucv_handler_list, list) {
1522 if (!handler->path_pending)
1523 continue;
1524 /*
1525 * Add path to handler to allow a call to iucv_path_sever
1526 * inside the path_pending function. If the handler returns
1527 * an error remove the path from the handler again.
1528 */
1529 list_add(&path->list, &handler->paths);
1530 path->handler = handler;
1531 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))
1532 return;
1533 list_del(&path->list);
1534 path->handler = NULL;
1535 }
1536 /* No handler wanted the path. */
1537 iucv_path_table[path->pathid] = NULL;
1538 iucv_path_free(path);
1539 error = iucv_error_no_listener;
1540out_sever:
1541 iucv_sever_pathid(ipp->ippathid, error);
1542}
1543
1544/**
1545 * iucv_path_complete
1546 * @data: Pointer to external interrupt buffer
1547 *
1548 * Process connection complete work item. Called from tasklet while holding
1549 * iucv_table_lock.
1550 */
1551struct iucv_path_complete {
1552 u16 ippathid;
1553 u8 ipflags1;
1554 u8 iptype;
1555 u16 ipmsglim;
1556 u16 res1;
1557 u8 res2[8];
1558 u8 ipuser[16];
1559 u32 res3;
1560 u8 ippollfg;
1561 u8 res4[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001562} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001563
1564static void iucv_path_complete(struct iucv_irq_data *data)
1565{
1566 struct iucv_path_complete *ipc = (void *) data;
1567 struct iucv_path *path = iucv_path_table[ipc->ippathid];
1568
Hendrik Bruecknerb8942e32009-04-21 23:26:23 +00001569 if (path)
1570 path->flags = ipc->ipflags1;
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001571 if (path && path->handler && path->handler->path_complete)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001572 path->handler->path_complete(path, ipc->ipuser);
1573}
1574
1575/**
1576 * iucv_path_severed
1577 * @data: Pointer to external interrupt buffer
1578 *
1579 * Process connection severed work item. Called from tasklet while holding
1580 * iucv_table_lock.
1581 */
1582struct iucv_path_severed {
1583 u16 ippathid;
1584 u8 res1;
1585 u8 iptype;
1586 u32 res2;
1587 u8 res3[8];
1588 u8 ipuser[16];
1589 u32 res4;
1590 u8 ippollfg;
1591 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001592} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001593
1594static void iucv_path_severed(struct iucv_irq_data *data)
1595{
1596 struct iucv_path_severed *ips = (void *) data;
1597 struct iucv_path *path = iucv_path_table[ips->ippathid];
1598
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001599 if (!path || !path->handler) /* Already severed */
1600 return;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001601 if (path->handler->path_severed)
1602 path->handler->path_severed(path, ips->ipuser);
1603 else {
1604 iucv_sever_pathid(path->pathid, NULL);
1605 iucv_path_table[path->pathid] = NULL;
Ursula Braun42e1b4c2009-04-21 23:26:20 +00001606 list_del(&path->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001607 iucv_path_free(path);
1608 }
1609}
1610
1611/**
1612 * iucv_path_quiesced
1613 * @data: Pointer to external interrupt buffer
1614 *
1615 * Process connection quiesced work item. Called from tasklet while holding
1616 * iucv_table_lock.
1617 */
1618struct iucv_path_quiesced {
1619 u16 ippathid;
1620 u8 res1;
1621 u8 iptype;
1622 u32 res2;
1623 u8 res3[8];
1624 u8 ipuser[16];
1625 u32 res4;
1626 u8 ippollfg;
1627 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001628} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001629
1630static void iucv_path_quiesced(struct iucv_irq_data *data)
1631{
1632 struct iucv_path_quiesced *ipq = (void *) data;
1633 struct iucv_path *path = iucv_path_table[ipq->ippathid];
1634
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001635 if (path && path->handler && path->handler->path_quiesced)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001636 path->handler->path_quiesced(path, ipq->ipuser);
1637}
1638
1639/**
1640 * iucv_path_resumed
1641 * @data: Pointer to external interrupt buffer
1642 *
1643 * Process connection resumed work item. Called from tasklet while holding
1644 * iucv_table_lock.
1645 */
1646struct iucv_path_resumed {
1647 u16 ippathid;
1648 u8 res1;
1649 u8 iptype;
1650 u32 res2;
1651 u8 res3[8];
1652 u8 ipuser[16];
1653 u32 res4;
1654 u8 ippollfg;
1655 u8 res5[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001656} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001657
1658static void iucv_path_resumed(struct iucv_irq_data *data)
1659{
1660 struct iucv_path_resumed *ipr = (void *) data;
1661 struct iucv_path *path = iucv_path_table[ipr->ippathid];
1662
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001663 if (path && path->handler && path->handler->path_resumed)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001664 path->handler->path_resumed(path, ipr->ipuser);
1665}
1666
1667/**
1668 * iucv_message_complete
1669 * @data: Pointer to external interrupt buffer
1670 *
1671 * Process message complete work item. Called from tasklet while holding
1672 * iucv_table_lock.
1673 */
1674struct iucv_message_complete {
1675 u16 ippathid;
1676 u8 ipflags1;
1677 u8 iptype;
1678 u32 ipmsgid;
1679 u32 ipaudit;
1680 u8 iprmmsg[8];
1681 u32 ipsrccls;
1682 u32 ipmsgtag;
1683 u32 res;
1684 u32 ipbfln2f;
1685 u8 ippollfg;
1686 u8 res2[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001687} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001688
1689static void iucv_message_complete(struct iucv_irq_data *data)
1690{
1691 struct iucv_message_complete *imc = (void *) data;
1692 struct iucv_path *path = iucv_path_table[imc->ippathid];
1693 struct iucv_message msg;
1694
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001695 if (path && path->handler && path->handler->message_complete) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001696 msg.flags = imc->ipflags1;
1697 msg.id = imc->ipmsgid;
1698 msg.audit = imc->ipaudit;
1699 memcpy(msg.rmmsg, imc->iprmmsg, 8);
1700 msg.class = imc->ipsrccls;
1701 msg.tag = imc->ipmsgtag;
1702 msg.length = imc->ipbfln2f;
1703 path->handler->message_complete(path, &msg);
1704 }
1705}
1706
1707/**
1708 * iucv_message_pending
1709 * @data: Pointer to external interrupt buffer
1710 *
1711 * Process message pending work item. Called from tasklet while holding
1712 * iucv_table_lock.
1713 */
1714struct iucv_message_pending {
1715 u16 ippathid;
1716 u8 ipflags1;
1717 u8 iptype;
1718 u32 ipmsgid;
1719 u32 iptrgcls;
1720 union {
1721 u32 iprmmsg1_u32;
1722 u8 iprmmsg1[4];
1723 } ln1msg1;
1724 union {
1725 u32 ipbfln1f;
1726 u8 iprmmsg2[4];
1727 } ln1msg2;
1728 u32 res1[3];
1729 u32 ipbfln2f;
1730 u8 ippollfg;
1731 u8 res2[3];
Eric Dumazetbc105022010-06-03 03:21:52 -07001732} __packed;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001733
1734static void iucv_message_pending(struct iucv_irq_data *data)
1735{
1736 struct iucv_message_pending *imp = (void *) data;
1737 struct iucv_path *path = iucv_path_table[imp->ippathid];
1738 struct iucv_message msg;
1739
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001740 if (path && path->handler && path->handler->message_pending) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001741 msg.flags = imp->ipflags1;
1742 msg.id = imp->ipmsgid;
1743 msg.class = imp->iptrgcls;
1744 if (imp->ipflags1 & IUCV_IPRMDATA) {
1745 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8);
1746 msg.length = 8;
1747 } else
1748 msg.length = imp->ln1msg2.ipbfln1f;
1749 msg.reply_size = imp->ipbfln2f;
1750 path->handler->message_pending(path, &msg);
1751 }
1752}
1753
1754/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001755 * iucv_tasklet_fn:
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001756 *
1757 * This tasklet loops over the queue of irq buffers created by
1758 * iucv_external_interrupt, calls the appropriate action handler
1759 * and then frees the buffer.
1760 */
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001761static void iucv_tasklet_fn(unsigned long ignored)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001762{
1763 typedef void iucv_irq_fn(struct iucv_irq_data *);
1764 static iucv_irq_fn *irq_fn[] = {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001765 [0x02] = iucv_path_complete,
1766 [0x03] = iucv_path_severed,
1767 [0x04] = iucv_path_quiesced,
1768 [0x05] = iucv_path_resumed,
1769 [0x06] = iucv_message_complete,
1770 [0x07] = iucv_message_complete,
1771 [0x08] = iucv_message_pending,
1772 [0x09] = iucv_message_pending,
1773 };
Denis Chengb5e78332007-12-07 00:51:45 -08001774 LIST_HEAD(task_queue);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001775 struct iucv_irq_list *p, *n;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001776
1777 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
Ursula Braun13fdc9a2007-07-14 19:03:41 -07001778 if (!spin_trylock(&iucv_table_lock)) {
1779 tasklet_schedule(&iucv_tasklet);
1780 return;
1781 }
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001782 iucv_active_cpu = smp_processor_id();
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001783
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001784 spin_lock_irq(&iucv_queue_lock);
1785 list_splice_init(&iucv_task_queue, &task_queue);
1786 spin_unlock_irq(&iucv_queue_lock);
1787
1788 list_for_each_entry_safe(p, n, &task_queue, list) {
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001789 list_del_init(&p->list);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001790 irq_fn[p->data.iptype](&p->data);
1791 kfree(p);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001792 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001793
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001794 iucv_active_cpu = -1;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001795 spin_unlock(&iucv_table_lock);
1796}
1797
1798/**
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001799 * iucv_work_fn:
1800 *
1801 * This work function loops over the queue of path pending irq blocks
1802 * created by iucv_external_interrupt, calls the appropriate action
1803 * handler and then frees the buffer.
1804 */
1805static void iucv_work_fn(struct work_struct *work)
1806{
Denis Chengb5e78332007-12-07 00:51:45 -08001807 LIST_HEAD(work_queue);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001808 struct iucv_irq_list *p, *n;
1809
1810 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1811 spin_lock_bh(&iucv_table_lock);
1812 iucv_active_cpu = smp_processor_id();
1813
1814 spin_lock_irq(&iucv_queue_lock);
1815 list_splice_init(&iucv_work_queue, &work_queue);
1816 spin_unlock_irq(&iucv_queue_lock);
1817
1818 iucv_cleanup_queue();
1819 list_for_each_entry_safe(p, n, &work_queue, list) {
1820 list_del_init(&p->list);
1821 iucv_path_pending(&p->data);
1822 kfree(p);
1823 }
1824
1825 iucv_active_cpu = -1;
1826 spin_unlock_bh(&iucv_table_lock);
1827}
1828
1829/**
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001830 * iucv_external_interrupt
1831 * @code: irq code
1832 *
1833 * Handles external interrupts coming in from CP.
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001834 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001835 */
Heiko Carstensfde15c32012-03-11 11:59:31 -04001836static void iucv_external_interrupt(struct ext_code ext_code,
Martin Schwidefskyf6649a72010-10-25 16:10:38 +02001837 unsigned int param32, unsigned long param64)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001838{
1839 struct iucv_irq_data *p;
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001840 struct iucv_irq_list *work;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001841
Heiko Carstens420f42e2013-01-02 15:18:18 +01001842 inc_irq_stat(IRQEXT_IUC);
Christoph Lameter70cf50352007-11-20 11:13:38 +01001843 p = iucv_irq_data[smp_processor_id()];
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001844 if (p->ippathid >= iucv_max_pathid) {
Ursula Braunc2b4afd2008-07-14 09:59:29 +02001845 WARN_ON(p->ippathid >= iucv_max_pathid);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001846 iucv_sever_pathid(p->ippathid, iucv_error_no_listener);
1847 return;
1848 }
Ursula Braunc2b4afd2008-07-14 09:59:29 +02001849 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001850 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001851 if (!work) {
Joe Perches47c4cfc2014-09-09 21:17:31 -07001852 pr_warn("iucv_external_interrupt: out of memory\n");
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001853 return;
1854 }
1855 memcpy(&work->data, p, sizeof(work->data));
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07001856 spin_lock(&iucv_queue_lock);
1857 if (p->iptype == 0x01) {
1858 /* Path pending interrupt. */
1859 list_add_tail(&work->list, &iucv_work_queue);
1860 schedule_work(&iucv_work);
1861 } else {
1862 /* The other interrupts. */
1863 list_add_tail(&work->list, &iucv_task_queue);
1864 tasklet_schedule(&iucv_tasklet);
1865 }
1866 spin_unlock(&iucv_queue_lock);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08001867}
1868
Ursula Braun672e4052009-06-16 10:30:42 +02001869static int iucv_pm_prepare(struct device *dev)
1870{
1871 int rc = 0;
1872
1873#ifdef CONFIG_PM_DEBUG
1874 printk(KERN_INFO "iucv_pm_prepare\n");
1875#endif
1876 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)
1877 rc = dev->driver->pm->prepare(dev);
1878 return rc;
1879}
1880
1881static void iucv_pm_complete(struct device *dev)
1882{
1883#ifdef CONFIG_PM_DEBUG
1884 printk(KERN_INFO "iucv_pm_complete\n");
1885#endif
1886 if (dev->driver && dev->driver->pm && dev->driver->pm->complete)
1887 dev->driver->pm->complete(dev);
1888}
1889
1890/**
1891 * iucv_path_table_empty() - determine if iucv path table is empty
1892 *
1893 * Returns 0 if there are still iucv pathes defined
1894 * 1 if there are no iucv pathes defined
1895 */
1896int iucv_path_table_empty(void)
1897{
1898 int i;
1899
1900 for (i = 0; i < iucv_max_pathid; i++) {
1901 if (iucv_path_table[i])
1902 return 0;
1903 }
1904 return 1;
1905}
1906
1907/**
1908 * iucv_pm_freeze() - Freeze PM callback
1909 * @dev: iucv-based device
1910 *
1911 * disable iucv interrupts
1912 * invoke callback function of the iucv-based driver
1913 * shut down iucv, if no iucv-pathes are established anymore
1914 */
1915static int iucv_pm_freeze(struct device *dev)
1916{
1917 int cpu;
Ursula Braunb7c2aec2009-11-12 21:46:27 +00001918 struct iucv_irq_list *p, *n;
Ursula Braun672e4052009-06-16 10:30:42 +02001919 int rc = 0;
1920
1921#ifdef CONFIG_PM_DEBUG
1922 printk(KERN_WARNING "iucv_pm_freeze\n");
1923#endif
Ursula Braunb7c2aec2009-11-12 21:46:27 +00001924 if (iucv_pm_state != IUCV_PM_FREEZING) {
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001925 for_each_cpu(cpu, &iucv_irq_cpumask)
Ursula Braunb7c2aec2009-11-12 21:46:27 +00001926 smp_call_function_single(cpu, iucv_block_cpu_almost,
1927 NULL, 1);
1928 cancel_work_sync(&iucv_work);
1929 list_for_each_entry_safe(p, n, &iucv_work_queue, list) {
1930 list_del_init(&p->list);
1931 iucv_sever_pathid(p->data.ippathid,
1932 iucv_error_no_listener);
1933 kfree(p);
1934 }
1935 }
Ursula Braun4c89d862009-09-16 04:37:22 +00001936 iucv_pm_state = IUCV_PM_FREEZING;
Ursula Braun672e4052009-06-16 10:30:42 +02001937 if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)
1938 rc = dev->driver->pm->freeze(dev);
1939 if (iucv_path_table_empty())
1940 iucv_disable();
1941 return rc;
1942}
1943
1944/**
1945 * iucv_pm_thaw() - Thaw PM callback
1946 * @dev: iucv-based device
1947 *
1948 * make iucv ready for use again: allocate path table, declare interrupt buffers
1949 * and enable iucv interrupts
1950 * invoke callback function of the iucv-based driver
1951 */
1952static int iucv_pm_thaw(struct device *dev)
1953{
1954 int rc = 0;
1955
1956#ifdef CONFIG_PM_DEBUG
1957 printk(KERN_WARNING "iucv_pm_thaw\n");
1958#endif
Ursula Braun4c89d862009-09-16 04:37:22 +00001959 iucv_pm_state = IUCV_PM_THAWING;
Ursula Braun672e4052009-06-16 10:30:42 +02001960 if (!iucv_path_table) {
1961 rc = iucv_enable();
1962 if (rc)
1963 goto out;
1964 }
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001965 if (cpumask_empty(&iucv_irq_cpumask)) {
Ursula Braun672e4052009-06-16 10:30:42 +02001966 if (iucv_nonsmp_handler)
1967 /* enable interrupts on one cpu */
1968 iucv_allow_cpu(NULL);
1969 else
1970 /* enable interrupts on all cpus */
1971 iucv_setmask_mp();
1972 }
1973 if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)
1974 rc = dev->driver->pm->thaw(dev);
1975out:
1976 return rc;
1977}
1978
1979/**
1980 * iucv_pm_restore() - Restore PM callback
1981 * @dev: iucv-based device
1982 *
1983 * make iucv ready for use again: allocate path table, declare interrupt buffers
1984 * and enable iucv interrupts
1985 * invoke callback function of the iucv-based driver
1986 */
1987static int iucv_pm_restore(struct device *dev)
1988{
1989 int rc = 0;
1990
1991#ifdef CONFIG_PM_DEBUG
1992 printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);
1993#endif
Ursula Braun4c89d862009-09-16 04:37:22 +00001994 if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)
Joe Perches47c4cfc2014-09-09 21:17:31 -07001995 pr_warn("Suspending Linux did not completely close all IUCV connections\n");
Ursula Braun4c89d862009-09-16 04:37:22 +00001996 iucv_pm_state = IUCV_PM_RESTORING;
KOSAKI Motohirof2019032011-05-12 18:45:09 +00001997 if (cpumask_empty(&iucv_irq_cpumask)) {
Ursula Braun672e4052009-06-16 10:30:42 +02001998 rc = iucv_query_maxconn();
1999 rc = iucv_enable();
2000 if (rc)
2001 goto out;
2002 }
2003 if (dev->driver && dev->driver->pm && dev->driver->pm->restore)
2004 rc = dev->driver->pm->restore(dev);
2005out:
2006 return rc;
2007}
2008
Frank Blaschka96d042a2011-08-08 01:33:49 +00002009struct iucv_interface iucv_if = {
2010 .message_receive = iucv_message_receive,
2011 .__message_receive = __iucv_message_receive,
2012 .message_reply = iucv_message_reply,
2013 .message_reject = iucv_message_reject,
2014 .message_send = iucv_message_send,
2015 .__message_send = __iucv_message_send,
2016 .message_send2way = iucv_message_send2way,
2017 .message_purge = iucv_message_purge,
2018 .path_accept = iucv_path_accept,
2019 .path_connect = iucv_path_connect,
2020 .path_quiesce = iucv_path_quiesce,
2021 .path_resume = iucv_path_resume,
2022 .path_sever = iucv_path_sever,
2023 .iucv_register = iucv_register,
2024 .iucv_unregister = iucv_unregister,
2025 .bus = NULL,
2026 .root = NULL,
2027};
2028EXPORT_SYMBOL(iucv_if);
2029
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002030/**
2031 * iucv_init
2032 *
2033 * Allocates and initializes various data structures.
2034 */
Heiko Carstensda99f052007-05-04 12:23:27 -07002035static int __init iucv_init(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002036{
2037 int rc;
Christoph Lameter70cf50352007-11-20 11:13:38 +01002038 int cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002039
2040 if (!MACHINE_IS_VM) {
2041 rc = -EPROTONOSUPPORT;
2042 goto out;
2043 }
Martin Schwidefsky5beab992011-07-24 10:48:28 +02002044 ctl_set_bit(0, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002045 rc = iucv_query_maxconn();
2046 if (rc)
Martin Schwidefsky5beab992011-07-24 10:48:28 +02002047 goto out_ctl;
Thomas Huth1dad0932014-03-31 15:24:08 +02002048 rc = register_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002049 if (rc)
Martin Schwidefsky5beab992011-07-24 10:48:28 +02002050 goto out_ctl;
Mark McLoughlin035da162008-12-15 12:58:29 +00002051 iucv_root = root_device_register("iucv");
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002052 if (IS_ERR(iucv_root)) {
2053 rc = PTR_ERR(iucv_root);
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002054 goto out_int;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002055 }
Christoph Lameter70cf50352007-11-20 11:13:38 +01002056
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302057 cpu_notifier_register_begin();
2058
Christoph Lameter70cf50352007-11-20 11:13:38 +01002059 for_each_online_cpu(cpu) {
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302060 if (alloc_iucv_data(cpu)) {
Christoph Lameter70cf50352007-11-20 11:13:38 +01002061 rc = -ENOMEM;
2062 goto out_free;
2063 }
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002064 }
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302065 rc = __register_hotcpu_notifier(&iucv_cpu_notifier);
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002066 if (rc)
2067 goto out_free;
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302068
2069 cpu_notifier_register_done();
2070
Ursula Braun6c005962009-06-16 10:30:41 +02002071 rc = register_reboot_notifier(&iucv_reboot_notifier);
2072 if (rc)
2073 goto out_cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002074 ASCEBC(iucv_error_no_listener, 16);
2075 ASCEBC(iucv_error_no_memory, 16);
2076 ASCEBC(iucv_error_pathid, 16);
2077 iucv_available = 1;
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002078 rc = bus_register(&iucv_bus);
2079 if (rc)
Ursula Braun6c005962009-06-16 10:30:41 +02002080 goto out_reboot;
Frank Blaschka96d042a2011-08-08 01:33:49 +00002081 iucv_if.root = iucv_root;
2082 iucv_if.bus = &iucv_bus;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002083 return 0;
2084
Ursula Braun6c005962009-06-16 10:30:41 +02002085out_reboot:
2086 unregister_reboot_notifier(&iucv_reboot_notifier);
Cornelia Huck2d7bf362008-04-10 02:12:45 -07002087out_cpu:
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302088 cpu_notifier_register_begin();
2089 __unregister_hotcpu_notifier(&iucv_cpu_notifier);
Christoph Lameter70cf50352007-11-20 11:13:38 +01002090out_free:
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302091 for_each_possible_cpu(cpu)
2092 free_iucv_data(cpu);
2093
2094 cpu_notifier_register_done();
2095
Mark McLoughlin035da162008-12-15 12:58:29 +00002096 root_device_unregister(iucv_root);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002097out_int:
Thomas Huth1dad0932014-03-31 15:24:08 +02002098 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
Martin Schwidefsky5beab992011-07-24 10:48:28 +02002099out_ctl:
2100 ctl_clear_bit(0, 1);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002101out:
2102 return rc;
2103}
2104
2105/**
2106 * iucv_exit
2107 *
2108 * Frees everything allocated from iucv_init.
2109 */
Heiko Carstensda99f052007-05-04 12:23:27 -07002110static void __exit iucv_exit(void)
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002111{
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002112 struct iucv_irq_list *p, *n;
Christoph Lameter70cf50352007-11-20 11:13:38 +01002113 int cpu;
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002114
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002115 spin_lock_irq(&iucv_queue_lock);
2116 list_for_each_entry_safe(p, n, &iucv_task_queue, list)
2117 kfree(p);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002118 list_for_each_entry_safe(p, n, &iucv_work_queue, list)
2119 kfree(p);
Martin Schwidefsky04b090d2007-04-28 23:03:59 -07002120 spin_unlock_irq(&iucv_queue_lock);
Ursula Braun6c005962009-06-16 10:30:41 +02002121 unregister_reboot_notifier(&iucv_reboot_notifier);
Srivatsa S. Bhata0e247a2014-03-11 02:12:57 +05302122 cpu_notifier_register_begin();
2123 __unregister_hotcpu_notifier(&iucv_cpu_notifier);
2124 for_each_possible_cpu(cpu)
2125 free_iucv_data(cpu);
2126 cpu_notifier_register_done();
Mark McLoughlin035da162008-12-15 12:58:29 +00002127 root_device_unregister(iucv_root);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002128 bus_unregister(&iucv_bus);
Thomas Huth1dad0932014-03-31 15:24:08 +02002129 unregister_external_irq(EXT_IRQ_IUCV, iucv_external_interrupt);
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002130}
2131
2132subsys_initcall(iucv_init);
2133module_exit(iucv_exit);
2134
Martin Schwidefsky2356f4c2007-02-08 13:37:42 -08002135MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2136MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2137MODULE_LICENSE("GPL");