Commit 5db79c0679e542a156de54e97be8901aeaa7638a

Authored by Ursula Braun
Committed by David S. Miller
1 parent ff2aed7da1

iucv: get rid of compile warning

-Wunused-but-set-variable generates a compile warning. The affected
variable is removed.

Signed-off-by: Ursula Braun <ursula.braun@de.ibm.com>
Signed-off-by: Frank Blaschka <frank.blaschka@de.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 1 changed file with 2 additions and 2 deletions Inline Diff

1 /* 1 /*
2 * IUCV base infrastructure. 2 * IUCV base infrastructure.
3 * 3 *
4 * Copyright IBM Corp. 2001, 2009 4 * Copyright IBM Corp. 2001, 2009
5 * 5 *
6 * Author(s): 6 * Author(s):
7 * Original source: 7 * Original source:
8 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000 8 * Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
9 * Xenia Tkatschow (xenia@us.ibm.com) 9 * Xenia Tkatschow (xenia@us.ibm.com)
10 * 2Gb awareness and general cleanup: 10 * 2Gb awareness and general cleanup:
11 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com) 11 * Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
12 * Rewritten for af_iucv: 12 * Rewritten for af_iucv:
13 * Martin Schwidefsky <schwidefsky@de.ibm.com> 13 * Martin Schwidefsky <schwidefsky@de.ibm.com>
14 * PM functions: 14 * PM functions:
15 * Ursula Braun (ursula.braun@de.ibm.com) 15 * Ursula Braun (ursula.braun@de.ibm.com)
16 * 16 *
17 * Documentation used: 17 * Documentation used:
18 * The original source 18 * The original source
19 * CP Programming Service, IBM document # SC24-5760 19 * CP Programming Service, IBM document # SC24-5760
20 * 20 *
21 * This program is free software; you can redistribute it and/or modify 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 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) 23 * the Free Software Foundation; either version 2, or (at your option)
24 * any later version. 24 * any later version.
25 * 25 *
26 * This program is distributed in the hope that it will be useful, 26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of 27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details. 29 * GNU General Public License for more details.
30 * 30 *
31 * You should have received a copy of the GNU General Public License 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 32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 33 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34 */ 34 */
35 35
36 #define KMSG_COMPONENT "iucv" 36 #define KMSG_COMPONENT "iucv"
37 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 37 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
38 38
39 #include <linux/kernel_stat.h> 39 #include <linux/kernel_stat.h>
40 #include <linux/module.h> 40 #include <linux/module.h>
41 #include <linux/moduleparam.h> 41 #include <linux/moduleparam.h>
42 #include <linux/spinlock.h> 42 #include <linux/spinlock.h>
43 #include <linux/kernel.h> 43 #include <linux/kernel.h>
44 #include <linux/slab.h> 44 #include <linux/slab.h>
45 #include <linux/init.h> 45 #include <linux/init.h>
46 #include <linux/interrupt.h> 46 #include <linux/interrupt.h>
47 #include <linux/list.h> 47 #include <linux/list.h>
48 #include <linux/errno.h> 48 #include <linux/errno.h>
49 #include <linux/err.h> 49 #include <linux/err.h>
50 #include <linux/device.h> 50 #include <linux/device.h>
51 #include <linux/cpu.h> 51 #include <linux/cpu.h>
52 #include <linux/reboot.h> 52 #include <linux/reboot.h>
53 #include <net/iucv/iucv.h> 53 #include <net/iucv/iucv.h>
54 #include <asm/atomic.h> 54 #include <asm/atomic.h>
55 #include <asm/ebcdic.h> 55 #include <asm/ebcdic.h>
56 #include <asm/io.h> 56 #include <asm/io.h>
57 #include <asm/s390_ext.h> 57 #include <asm/s390_ext.h>
58 #include <asm/smp.h> 58 #include <asm/smp.h>
59 59
60 /* 60 /*
61 * FLAGS: 61 * FLAGS:
62 * All flags are defined in the field IPFLAGS1 of each function 62 * All flags are defined in the field IPFLAGS1 of each function
63 * and can be found in CP Programming Services. 63 * and can be found in CP Programming Services.
64 * IPSRCCLS - Indicates you have specified a source class. 64 * IPSRCCLS - Indicates you have specified a source class.
65 * IPTRGCLS - Indicates you have specified a target class. 65 * IPTRGCLS - Indicates you have specified a target class.
66 * IPFGPID - Indicates you have specified a pathid. 66 * IPFGPID - Indicates you have specified a pathid.
67 * IPFGMID - Indicates you have specified a message ID. 67 * IPFGMID - Indicates you have specified a message ID.
68 * IPNORPY - Indicates a one-way message. No reply expected. 68 * IPNORPY - Indicates a one-way message. No reply expected.
69 * IPALL - Indicates that all paths are affected. 69 * IPALL - Indicates that all paths are affected.
70 */ 70 */
71 #define IUCV_IPSRCCLS 0x01 71 #define IUCV_IPSRCCLS 0x01
72 #define IUCV_IPTRGCLS 0x01 72 #define IUCV_IPTRGCLS 0x01
73 #define IUCV_IPFGPID 0x02 73 #define IUCV_IPFGPID 0x02
74 #define IUCV_IPFGMID 0x04 74 #define IUCV_IPFGMID 0x04
75 #define IUCV_IPNORPY 0x10 75 #define IUCV_IPNORPY 0x10
76 #define IUCV_IPALL 0x80 76 #define IUCV_IPALL 0x80
77 77
78 static int iucv_bus_match(struct device *dev, struct device_driver *drv) 78 static int iucv_bus_match(struct device *dev, struct device_driver *drv)
79 { 79 {
80 return 0; 80 return 0;
81 } 81 }
82 82
83 enum iucv_pm_states { 83 enum iucv_pm_states {
84 IUCV_PM_INITIAL = 0, 84 IUCV_PM_INITIAL = 0,
85 IUCV_PM_FREEZING = 1, 85 IUCV_PM_FREEZING = 1,
86 IUCV_PM_THAWING = 2, 86 IUCV_PM_THAWING = 2,
87 IUCV_PM_RESTORING = 3, 87 IUCV_PM_RESTORING = 3,
88 }; 88 };
89 static enum iucv_pm_states iucv_pm_state; 89 static enum iucv_pm_states iucv_pm_state;
90 90
91 static int iucv_pm_prepare(struct device *); 91 static int iucv_pm_prepare(struct device *);
92 static void iucv_pm_complete(struct device *); 92 static void iucv_pm_complete(struct device *);
93 static int iucv_pm_freeze(struct device *); 93 static int iucv_pm_freeze(struct device *);
94 static int iucv_pm_thaw(struct device *); 94 static int iucv_pm_thaw(struct device *);
95 static int iucv_pm_restore(struct device *); 95 static int iucv_pm_restore(struct device *);
96 96
97 static const struct dev_pm_ops iucv_pm_ops = { 97 static const struct dev_pm_ops iucv_pm_ops = {
98 .prepare = iucv_pm_prepare, 98 .prepare = iucv_pm_prepare,
99 .complete = iucv_pm_complete, 99 .complete = iucv_pm_complete,
100 .freeze = iucv_pm_freeze, 100 .freeze = iucv_pm_freeze,
101 .thaw = iucv_pm_thaw, 101 .thaw = iucv_pm_thaw,
102 .restore = iucv_pm_restore, 102 .restore = iucv_pm_restore,
103 }; 103 };
104 104
105 struct bus_type iucv_bus = { 105 struct bus_type iucv_bus = {
106 .name = "iucv", 106 .name = "iucv",
107 .match = iucv_bus_match, 107 .match = iucv_bus_match,
108 .pm = &iucv_pm_ops, 108 .pm = &iucv_pm_ops,
109 }; 109 };
110 EXPORT_SYMBOL(iucv_bus); 110 EXPORT_SYMBOL(iucv_bus);
111 111
112 struct device *iucv_root; 112 struct device *iucv_root;
113 EXPORT_SYMBOL(iucv_root); 113 EXPORT_SYMBOL(iucv_root);
114 114
115 static int iucv_available; 115 static int iucv_available;
116 116
117 /* General IUCV interrupt structure */ 117 /* General IUCV interrupt structure */
118 struct iucv_irq_data { 118 struct iucv_irq_data {
119 u16 ippathid; 119 u16 ippathid;
120 u8 ipflags1; 120 u8 ipflags1;
121 u8 iptype; 121 u8 iptype;
122 u32 res2[8]; 122 u32 res2[8];
123 }; 123 };
124 124
125 struct iucv_irq_list { 125 struct iucv_irq_list {
126 struct list_head list; 126 struct list_head list;
127 struct iucv_irq_data data; 127 struct iucv_irq_data data;
128 }; 128 };
129 129
130 static struct iucv_irq_data *iucv_irq_data[NR_CPUS]; 130 static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
131 static cpumask_t iucv_buffer_cpumask = CPU_MASK_NONE; 131 static cpumask_t iucv_buffer_cpumask = CPU_MASK_NONE;
132 static cpumask_t iucv_irq_cpumask = CPU_MASK_NONE; 132 static cpumask_t iucv_irq_cpumask = CPU_MASK_NONE;
133 133
134 /* 134 /*
135 * Queue of interrupt buffers lock for delivery via the tasklet 135 * Queue of interrupt buffers lock for delivery via the tasklet
136 * (fast but can't call smp_call_function). 136 * (fast but can't call smp_call_function).
137 */ 137 */
138 static LIST_HEAD(iucv_task_queue); 138 static LIST_HEAD(iucv_task_queue);
139 139
140 /* 140 /*
141 * The tasklet for fast delivery of iucv interrupts. 141 * The tasklet for fast delivery of iucv interrupts.
142 */ 142 */
143 static void iucv_tasklet_fn(unsigned long); 143 static void iucv_tasklet_fn(unsigned long);
144 static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0); 144 static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0);
145 145
146 /* 146 /*
147 * Queue of interrupt buffers for delivery via a work queue 147 * Queue of interrupt buffers for delivery via a work queue
148 * (slower but can call smp_call_function). 148 * (slower but can call smp_call_function).
149 */ 149 */
150 static LIST_HEAD(iucv_work_queue); 150 static LIST_HEAD(iucv_work_queue);
151 151
152 /* 152 /*
153 * The work element to deliver path pending interrupts. 153 * The work element to deliver path pending interrupts.
154 */ 154 */
155 static void iucv_work_fn(struct work_struct *work); 155 static void iucv_work_fn(struct work_struct *work);
156 static DECLARE_WORK(iucv_work, iucv_work_fn); 156 static DECLARE_WORK(iucv_work, iucv_work_fn);
157 157
158 /* 158 /*
159 * Spinlock protecting task and work queue. 159 * Spinlock protecting task and work queue.
160 */ 160 */
161 static DEFINE_SPINLOCK(iucv_queue_lock); 161 static DEFINE_SPINLOCK(iucv_queue_lock);
162 162
163 enum iucv_command_codes { 163 enum iucv_command_codes {
164 IUCV_QUERY = 0, 164 IUCV_QUERY = 0,
165 IUCV_RETRIEVE_BUFFER = 2, 165 IUCV_RETRIEVE_BUFFER = 2,
166 IUCV_SEND = 4, 166 IUCV_SEND = 4,
167 IUCV_RECEIVE = 5, 167 IUCV_RECEIVE = 5,
168 IUCV_REPLY = 6, 168 IUCV_REPLY = 6,
169 IUCV_REJECT = 8, 169 IUCV_REJECT = 8,
170 IUCV_PURGE = 9, 170 IUCV_PURGE = 9,
171 IUCV_ACCEPT = 10, 171 IUCV_ACCEPT = 10,
172 IUCV_CONNECT = 11, 172 IUCV_CONNECT = 11,
173 IUCV_DECLARE_BUFFER = 12, 173 IUCV_DECLARE_BUFFER = 12,
174 IUCV_QUIESCE = 13, 174 IUCV_QUIESCE = 13,
175 IUCV_RESUME = 14, 175 IUCV_RESUME = 14,
176 IUCV_SEVER = 15, 176 IUCV_SEVER = 15,
177 IUCV_SETMASK = 16, 177 IUCV_SETMASK = 16,
178 IUCV_SETCONTROLMASK = 17, 178 IUCV_SETCONTROLMASK = 17,
179 }; 179 };
180 180
181 /* 181 /*
182 * Error messages that are used with the iucv_sever function. They get 182 * Error messages that are used with the iucv_sever function. They get
183 * converted to EBCDIC. 183 * converted to EBCDIC.
184 */ 184 */
185 static char iucv_error_no_listener[16] = "NO LISTENER"; 185 static char iucv_error_no_listener[16] = "NO LISTENER";
186 static char iucv_error_no_memory[16] = "NO MEMORY"; 186 static char iucv_error_no_memory[16] = "NO MEMORY";
187 static char iucv_error_pathid[16] = "INVALID PATHID"; 187 static char iucv_error_pathid[16] = "INVALID PATHID";
188 188
189 /* 189 /*
190 * iucv_handler_list: List of registered handlers. 190 * iucv_handler_list: List of registered handlers.
191 */ 191 */
192 static LIST_HEAD(iucv_handler_list); 192 static LIST_HEAD(iucv_handler_list);
193 193
194 /* 194 /*
195 * iucv_path_table: an array of iucv_path structures. 195 * iucv_path_table: an array of iucv_path structures.
196 */ 196 */
197 static struct iucv_path **iucv_path_table; 197 static struct iucv_path **iucv_path_table;
198 static unsigned long iucv_max_pathid; 198 static unsigned long iucv_max_pathid;
199 199
200 /* 200 /*
201 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table 201 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table
202 */ 202 */
203 static DEFINE_SPINLOCK(iucv_table_lock); 203 static DEFINE_SPINLOCK(iucv_table_lock);
204 204
205 /* 205 /*
206 * iucv_active_cpu: contains the number of the cpu executing the tasklet 206 * 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. 207 * or the work handler. Needed for iucv_path_sever called from tasklet.
208 */ 208 */
209 static int iucv_active_cpu = -1; 209 static int iucv_active_cpu = -1;
210 210
211 /* 211 /*
212 * Mutex and wait queue for iucv_register/iucv_unregister. 212 * Mutex and wait queue for iucv_register/iucv_unregister.
213 */ 213 */
214 static DEFINE_MUTEX(iucv_register_mutex); 214 static DEFINE_MUTEX(iucv_register_mutex);
215 215
216 /* 216 /*
217 * Counter for number of non-smp capable handlers. 217 * Counter for number of non-smp capable handlers.
218 */ 218 */
219 static int iucv_nonsmp_handler; 219 static int iucv_nonsmp_handler;
220 220
221 /* 221 /*
222 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect, 222 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,
223 * iucv_path_quiesce and iucv_path_sever. 223 * iucv_path_quiesce and iucv_path_sever.
224 */ 224 */
225 struct iucv_cmd_control { 225 struct iucv_cmd_control {
226 u16 ippathid; 226 u16 ippathid;
227 u8 ipflags1; 227 u8 ipflags1;
228 u8 iprcode; 228 u8 iprcode;
229 u16 ipmsglim; 229 u16 ipmsglim;
230 u16 res1; 230 u16 res1;
231 u8 ipvmid[8]; 231 u8 ipvmid[8];
232 u8 ipuser[16]; 232 u8 ipuser[16];
233 u8 iptarget[8]; 233 u8 iptarget[8];
234 } __attribute__ ((packed,aligned(8))); 234 } __attribute__ ((packed,aligned(8)));
235 235
236 /* 236 /*
237 * Data in parameter list iucv structure. Used by iucv_message_send, 237 * Data in parameter list iucv structure. Used by iucv_message_send,
238 * iucv_message_send2way and iucv_message_reply. 238 * iucv_message_send2way and iucv_message_reply.
239 */ 239 */
240 struct iucv_cmd_dpl { 240 struct iucv_cmd_dpl {
241 u16 ippathid; 241 u16 ippathid;
242 u8 ipflags1; 242 u8 ipflags1;
243 u8 iprcode; 243 u8 iprcode;
244 u32 ipmsgid; 244 u32 ipmsgid;
245 u32 iptrgcls; 245 u32 iptrgcls;
246 u8 iprmmsg[8]; 246 u8 iprmmsg[8];
247 u32 ipsrccls; 247 u32 ipsrccls;
248 u32 ipmsgtag; 248 u32 ipmsgtag;
249 u32 ipbfadr2; 249 u32 ipbfadr2;
250 u32 ipbfln2f; 250 u32 ipbfln2f;
251 u32 res; 251 u32 res;
252 } __attribute__ ((packed,aligned(8))); 252 } __attribute__ ((packed,aligned(8)));
253 253
254 /* 254 /*
255 * Data in buffer iucv structure. Used by iucv_message_receive, 255 * Data in buffer iucv structure. Used by iucv_message_receive,
256 * iucv_message_reject, iucv_message_send, iucv_message_send2way 256 * iucv_message_reject, iucv_message_send, iucv_message_send2way
257 * and iucv_declare_cpu. 257 * and iucv_declare_cpu.
258 */ 258 */
259 struct iucv_cmd_db { 259 struct iucv_cmd_db {
260 u16 ippathid; 260 u16 ippathid;
261 u8 ipflags1; 261 u8 ipflags1;
262 u8 iprcode; 262 u8 iprcode;
263 u32 ipmsgid; 263 u32 ipmsgid;
264 u32 iptrgcls; 264 u32 iptrgcls;
265 u32 ipbfadr1; 265 u32 ipbfadr1;
266 u32 ipbfln1f; 266 u32 ipbfln1f;
267 u32 ipsrccls; 267 u32 ipsrccls;
268 u32 ipmsgtag; 268 u32 ipmsgtag;
269 u32 ipbfadr2; 269 u32 ipbfadr2;
270 u32 ipbfln2f; 270 u32 ipbfln2f;
271 u32 res; 271 u32 res;
272 } __attribute__ ((packed,aligned(8))); 272 } __attribute__ ((packed,aligned(8)));
273 273
274 /* 274 /*
275 * Purge message iucv structure. Used by iucv_message_purge. 275 * Purge message iucv structure. Used by iucv_message_purge.
276 */ 276 */
277 struct iucv_cmd_purge { 277 struct iucv_cmd_purge {
278 u16 ippathid; 278 u16 ippathid;
279 u8 ipflags1; 279 u8 ipflags1;
280 u8 iprcode; 280 u8 iprcode;
281 u32 ipmsgid; 281 u32 ipmsgid;
282 u8 ipaudit[3]; 282 u8 ipaudit[3];
283 u8 res1[5]; 283 u8 res1[5];
284 u32 res2; 284 u32 res2;
285 u32 ipsrccls; 285 u32 ipsrccls;
286 u32 ipmsgtag; 286 u32 ipmsgtag;
287 u32 res3[3]; 287 u32 res3[3];
288 } __attribute__ ((packed,aligned(8))); 288 } __attribute__ ((packed,aligned(8)));
289 289
290 /* 290 /*
291 * Set mask iucv structure. Used by iucv_enable_cpu. 291 * Set mask iucv structure. Used by iucv_enable_cpu.
292 */ 292 */
293 struct iucv_cmd_set_mask { 293 struct iucv_cmd_set_mask {
294 u8 ipmask; 294 u8 ipmask;
295 u8 res1[2]; 295 u8 res1[2];
296 u8 iprcode; 296 u8 iprcode;
297 u32 res2[9]; 297 u32 res2[9];
298 } __attribute__ ((packed,aligned(8))); 298 } __attribute__ ((packed,aligned(8)));
299 299
300 union iucv_param { 300 union iucv_param {
301 struct iucv_cmd_control ctrl; 301 struct iucv_cmd_control ctrl;
302 struct iucv_cmd_dpl dpl; 302 struct iucv_cmd_dpl dpl;
303 struct iucv_cmd_db db; 303 struct iucv_cmd_db db;
304 struct iucv_cmd_purge purge; 304 struct iucv_cmd_purge purge;
305 struct iucv_cmd_set_mask set_mask; 305 struct iucv_cmd_set_mask set_mask;
306 }; 306 };
307 307
308 /* 308 /*
309 * Anchor for per-cpu IUCV command parameter block. 309 * Anchor for per-cpu IUCV command parameter block.
310 */ 310 */
311 static union iucv_param *iucv_param[NR_CPUS]; 311 static union iucv_param *iucv_param[NR_CPUS];
312 static union iucv_param *iucv_param_irq[NR_CPUS]; 312 static union iucv_param *iucv_param_irq[NR_CPUS];
313 313
314 /** 314 /**
315 * iucv_call_b2f0 315 * iucv_call_b2f0
316 * @code: identifier of IUCV call to CP. 316 * @code: identifier of IUCV call to CP.
317 * @parm: pointer to a struct iucv_parm block 317 * @parm: pointer to a struct iucv_parm block
318 * 318 *
319 * Calls CP to execute IUCV commands. 319 * Calls CP to execute IUCV commands.
320 * 320 *
321 * Returns the result of the CP IUCV call. 321 * Returns the result of the CP IUCV call.
322 */ 322 */
323 static inline int iucv_call_b2f0(int command, union iucv_param *parm) 323 static inline int iucv_call_b2f0(int command, union iucv_param *parm)
324 { 324 {
325 register unsigned long reg0 asm ("0"); 325 register unsigned long reg0 asm ("0");
326 register unsigned long reg1 asm ("1"); 326 register unsigned long reg1 asm ("1");
327 int ccode; 327 int ccode;
328 328
329 reg0 = command; 329 reg0 = command;
330 reg1 = virt_to_phys(parm); 330 reg1 = virt_to_phys(parm);
331 asm volatile( 331 asm volatile(
332 " .long 0xb2f01000\n" 332 " .long 0xb2f01000\n"
333 " ipm %0\n" 333 " ipm %0\n"
334 " srl %0,28\n" 334 " srl %0,28\n"
335 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1) 335 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)
336 : "m" (*parm) : "cc"); 336 : "m" (*parm) : "cc");
337 return (ccode == 1) ? parm->ctrl.iprcode : ccode; 337 return (ccode == 1) ? parm->ctrl.iprcode : ccode;
338 } 338 }
339 339
340 /** 340 /**
341 * iucv_query_maxconn 341 * iucv_query_maxconn
342 * 342 *
343 * Determines the maximum number of connections that may be established. 343 * Determines the maximum number of connections that may be established.
344 * 344 *
345 * Returns the maximum number of connections or -EPERM is IUCV is not 345 * Returns the maximum number of connections or -EPERM is IUCV is not
346 * available. 346 * available.
347 */ 347 */
348 static int iucv_query_maxconn(void) 348 static int iucv_query_maxconn(void)
349 { 349 {
350 register unsigned long reg0 asm ("0"); 350 register unsigned long reg0 asm ("0");
351 register unsigned long reg1 asm ("1"); 351 register unsigned long reg1 asm ("1");
352 void *param; 352 void *param;
353 int ccode; 353 int ccode;
354 354
355 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA); 355 param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA);
356 if (!param) 356 if (!param)
357 return -ENOMEM; 357 return -ENOMEM;
358 reg0 = IUCV_QUERY; 358 reg0 = IUCV_QUERY;
359 reg1 = (unsigned long) param; 359 reg1 = (unsigned long) param;
360 asm volatile ( 360 asm volatile (
361 " .long 0xb2f01000\n" 361 " .long 0xb2f01000\n"
362 " ipm %0\n" 362 " ipm %0\n"
363 " srl %0,28\n" 363 " srl %0,28\n"
364 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc"); 364 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
365 if (ccode == 0) 365 if (ccode == 0)
366 iucv_max_pathid = reg1; 366 iucv_max_pathid = reg1;
367 kfree(param); 367 kfree(param);
368 return ccode ? -EPERM : 0; 368 return ccode ? -EPERM : 0;
369 } 369 }
370 370
371 /** 371 /**
372 * iucv_allow_cpu 372 * iucv_allow_cpu
373 * @data: unused 373 * @data: unused
374 * 374 *
375 * Allow iucv interrupts on this cpu. 375 * Allow iucv interrupts on this cpu.
376 */ 376 */
377 static void iucv_allow_cpu(void *data) 377 static void iucv_allow_cpu(void *data)
378 { 378 {
379 int cpu = smp_processor_id(); 379 int cpu = smp_processor_id();
380 union iucv_param *parm; 380 union iucv_param *parm;
381 381
382 /* 382 /*
383 * Enable all iucv interrupts. 383 * Enable all iucv interrupts.
384 * ipmask contains bits for the different interrupts 384 * ipmask contains bits for the different interrupts
385 * 0x80 - Flag to allow nonpriority message pending interrupts 385 * 0x80 - Flag to allow nonpriority message pending interrupts
386 * 0x40 - Flag to allow priority message pending interrupts 386 * 0x40 - Flag to allow priority message pending interrupts
387 * 0x20 - Flag to allow nonpriority message completion interrupts 387 * 0x20 - Flag to allow nonpriority message completion interrupts
388 * 0x10 - Flag to allow priority message completion interrupts 388 * 0x10 - Flag to allow priority message completion interrupts
389 * 0x08 - Flag to allow IUCV control interrupts 389 * 0x08 - Flag to allow IUCV control interrupts
390 */ 390 */
391 parm = iucv_param_irq[cpu]; 391 parm = iucv_param_irq[cpu];
392 memset(parm, 0, sizeof(union iucv_param)); 392 memset(parm, 0, sizeof(union iucv_param));
393 parm->set_mask.ipmask = 0xf8; 393 parm->set_mask.ipmask = 0xf8;
394 iucv_call_b2f0(IUCV_SETMASK, parm); 394 iucv_call_b2f0(IUCV_SETMASK, parm);
395 395
396 /* 396 /*
397 * Enable all iucv control interrupts. 397 * Enable all iucv control interrupts.
398 * ipmask contains bits for the different interrupts 398 * ipmask contains bits for the different interrupts
399 * 0x80 - Flag to allow pending connections interrupts 399 * 0x80 - Flag to allow pending connections interrupts
400 * 0x40 - Flag to allow connection complete interrupts 400 * 0x40 - Flag to allow connection complete interrupts
401 * 0x20 - Flag to allow connection severed interrupts 401 * 0x20 - Flag to allow connection severed interrupts
402 * 0x10 - Flag to allow connection quiesced interrupts 402 * 0x10 - Flag to allow connection quiesced interrupts
403 * 0x08 - Flag to allow connection resumed interrupts 403 * 0x08 - Flag to allow connection resumed interrupts
404 */ 404 */
405 memset(parm, 0, sizeof(union iucv_param)); 405 memset(parm, 0, sizeof(union iucv_param));
406 parm->set_mask.ipmask = 0xf8; 406 parm->set_mask.ipmask = 0xf8;
407 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm); 407 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
408 /* Set indication that iucv interrupts are allowed for this cpu. */ 408 /* Set indication that iucv interrupts are allowed for this cpu. */
409 cpu_set(cpu, iucv_irq_cpumask); 409 cpu_set(cpu, iucv_irq_cpumask);
410 } 410 }
411 411
412 /** 412 /**
413 * iucv_block_cpu 413 * iucv_block_cpu
414 * @data: unused 414 * @data: unused
415 * 415 *
416 * Block iucv interrupts on this cpu. 416 * Block iucv interrupts on this cpu.
417 */ 417 */
418 static void iucv_block_cpu(void *data) 418 static void iucv_block_cpu(void *data)
419 { 419 {
420 int cpu = smp_processor_id(); 420 int cpu = smp_processor_id();
421 union iucv_param *parm; 421 union iucv_param *parm;
422 422
423 /* Disable all iucv interrupts. */ 423 /* Disable all iucv interrupts. */
424 parm = iucv_param_irq[cpu]; 424 parm = iucv_param_irq[cpu];
425 memset(parm, 0, sizeof(union iucv_param)); 425 memset(parm, 0, sizeof(union iucv_param));
426 iucv_call_b2f0(IUCV_SETMASK, parm); 426 iucv_call_b2f0(IUCV_SETMASK, parm);
427 427
428 /* Clear indication that iucv interrupts are allowed for this cpu. */ 428 /* Clear indication that iucv interrupts are allowed for this cpu. */
429 cpu_clear(cpu, iucv_irq_cpumask); 429 cpu_clear(cpu, iucv_irq_cpumask);
430 } 430 }
431 431
432 /** 432 /**
433 * iucv_block_cpu_almost 433 * iucv_block_cpu_almost
434 * @data: unused 434 * @data: unused
435 * 435 *
436 * Allow connection-severed interrupts only on this cpu. 436 * Allow connection-severed interrupts only on this cpu.
437 */ 437 */
438 static void iucv_block_cpu_almost(void *data) 438 static void iucv_block_cpu_almost(void *data)
439 { 439 {
440 int cpu = smp_processor_id(); 440 int cpu = smp_processor_id();
441 union iucv_param *parm; 441 union iucv_param *parm;
442 442
443 /* Allow iucv control interrupts only */ 443 /* Allow iucv control interrupts only */
444 parm = iucv_param_irq[cpu]; 444 parm = iucv_param_irq[cpu];
445 memset(parm, 0, sizeof(union iucv_param)); 445 memset(parm, 0, sizeof(union iucv_param));
446 parm->set_mask.ipmask = 0x08; 446 parm->set_mask.ipmask = 0x08;
447 iucv_call_b2f0(IUCV_SETMASK, parm); 447 iucv_call_b2f0(IUCV_SETMASK, parm);
448 /* Allow iucv-severed interrupt only */ 448 /* Allow iucv-severed interrupt only */
449 memset(parm, 0, sizeof(union iucv_param)); 449 memset(parm, 0, sizeof(union iucv_param));
450 parm->set_mask.ipmask = 0x20; 450 parm->set_mask.ipmask = 0x20;
451 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm); 451 iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
452 452
453 /* Clear indication that iucv interrupts are allowed for this cpu. */ 453 /* Clear indication that iucv interrupts are allowed for this cpu. */
454 cpu_clear(cpu, iucv_irq_cpumask); 454 cpu_clear(cpu, iucv_irq_cpumask);
455 } 455 }
456 456
457 /** 457 /**
458 * iucv_declare_cpu 458 * iucv_declare_cpu
459 * @data: unused 459 * @data: unused
460 * 460 *
461 * Declare a interrupt buffer on this cpu. 461 * Declare a interrupt buffer on this cpu.
462 */ 462 */
463 static void iucv_declare_cpu(void *data) 463 static void iucv_declare_cpu(void *data)
464 { 464 {
465 int cpu = smp_processor_id(); 465 int cpu = smp_processor_id();
466 union iucv_param *parm; 466 union iucv_param *parm;
467 int rc; 467 int rc;
468 468
469 if (cpu_isset(cpu, iucv_buffer_cpumask)) 469 if (cpu_isset(cpu, iucv_buffer_cpumask))
470 return; 470 return;
471 471
472 /* Declare interrupt buffer. */ 472 /* Declare interrupt buffer. */
473 parm = iucv_param_irq[cpu]; 473 parm = iucv_param_irq[cpu];
474 memset(parm, 0, sizeof(union iucv_param)); 474 memset(parm, 0, sizeof(union iucv_param));
475 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]); 475 parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
476 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm); 476 rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
477 if (rc) { 477 if (rc) {
478 char *err = "Unknown"; 478 char *err = "Unknown";
479 switch (rc) { 479 switch (rc) {
480 case 0x03: 480 case 0x03:
481 err = "Directory error"; 481 err = "Directory error";
482 break; 482 break;
483 case 0x0a: 483 case 0x0a:
484 err = "Invalid length"; 484 err = "Invalid length";
485 break; 485 break;
486 case 0x13: 486 case 0x13:
487 err = "Buffer already exists"; 487 err = "Buffer already exists";
488 break; 488 break;
489 case 0x3e: 489 case 0x3e:
490 err = "Buffer overlap"; 490 err = "Buffer overlap";
491 break; 491 break;
492 case 0x5c: 492 case 0x5c:
493 err = "Paging or storage error"; 493 err = "Paging or storage error";
494 break; 494 break;
495 } 495 }
496 pr_warning("Defining an interrupt buffer on CPU %i" 496 pr_warning("Defining an interrupt buffer on CPU %i"
497 " failed with 0x%02x (%s)\n", cpu, rc, err); 497 " failed with 0x%02x (%s)\n", cpu, rc, err);
498 return; 498 return;
499 } 499 }
500 500
501 /* Set indication that an iucv buffer exists for this cpu. */ 501 /* Set indication that an iucv buffer exists for this cpu. */
502 cpu_set(cpu, iucv_buffer_cpumask); 502 cpu_set(cpu, iucv_buffer_cpumask);
503 503
504 if (iucv_nonsmp_handler == 0 || cpus_empty(iucv_irq_cpumask)) 504 if (iucv_nonsmp_handler == 0 || cpus_empty(iucv_irq_cpumask))
505 /* Enable iucv interrupts on this cpu. */ 505 /* Enable iucv interrupts on this cpu. */
506 iucv_allow_cpu(NULL); 506 iucv_allow_cpu(NULL);
507 else 507 else
508 /* Disable iucv interrupts on this cpu. */ 508 /* Disable iucv interrupts on this cpu. */
509 iucv_block_cpu(NULL); 509 iucv_block_cpu(NULL);
510 } 510 }
511 511
512 /** 512 /**
513 * iucv_retrieve_cpu 513 * iucv_retrieve_cpu
514 * @data: unused 514 * @data: unused
515 * 515 *
516 * Retrieve interrupt buffer on this cpu. 516 * Retrieve interrupt buffer on this cpu.
517 */ 517 */
518 static void iucv_retrieve_cpu(void *data) 518 static void iucv_retrieve_cpu(void *data)
519 { 519 {
520 int cpu = smp_processor_id(); 520 int cpu = smp_processor_id();
521 union iucv_param *parm; 521 union iucv_param *parm;
522 522
523 if (!cpu_isset(cpu, iucv_buffer_cpumask)) 523 if (!cpu_isset(cpu, iucv_buffer_cpumask))
524 return; 524 return;
525 525
526 /* Block iucv interrupts. */ 526 /* Block iucv interrupts. */
527 iucv_block_cpu(NULL); 527 iucv_block_cpu(NULL);
528 528
529 /* Retrieve interrupt buffer. */ 529 /* Retrieve interrupt buffer. */
530 parm = iucv_param_irq[cpu]; 530 parm = iucv_param_irq[cpu];
531 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm); 531 iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
532 532
533 /* Clear indication that an iucv buffer exists for this cpu. */ 533 /* Clear indication that an iucv buffer exists for this cpu. */
534 cpu_clear(cpu, iucv_buffer_cpumask); 534 cpu_clear(cpu, iucv_buffer_cpumask);
535 } 535 }
536 536
537 /** 537 /**
538 * iucv_setmask_smp 538 * iucv_setmask_smp
539 * 539 *
540 * Allow iucv interrupts on all cpus. 540 * Allow iucv interrupts on all cpus.
541 */ 541 */
542 static void iucv_setmask_mp(void) 542 static void iucv_setmask_mp(void)
543 { 543 {
544 int cpu; 544 int cpu;
545 545
546 get_online_cpus(); 546 get_online_cpus();
547 for_each_online_cpu(cpu) 547 for_each_online_cpu(cpu)
548 /* Enable all cpus with a declared buffer. */ 548 /* Enable all cpus with a declared buffer. */
549 if (cpu_isset(cpu, iucv_buffer_cpumask) && 549 if (cpu_isset(cpu, iucv_buffer_cpumask) &&
550 !cpu_isset(cpu, iucv_irq_cpumask)) 550 !cpu_isset(cpu, iucv_irq_cpumask))
551 smp_call_function_single(cpu, iucv_allow_cpu, 551 smp_call_function_single(cpu, iucv_allow_cpu,
552 NULL, 1); 552 NULL, 1);
553 put_online_cpus(); 553 put_online_cpus();
554 } 554 }
555 555
556 /** 556 /**
557 * iucv_setmask_up 557 * iucv_setmask_up
558 * 558 *
559 * Allow iucv interrupts on a single cpu. 559 * Allow iucv interrupts on a single cpu.
560 */ 560 */
561 static void iucv_setmask_up(void) 561 static void iucv_setmask_up(void)
562 { 562 {
563 cpumask_t cpumask; 563 cpumask_t cpumask;
564 int cpu; 564 int cpu;
565 565
566 /* Disable all cpu but the first in cpu_irq_cpumask. */ 566 /* Disable all cpu but the first in cpu_irq_cpumask. */
567 cpumask = iucv_irq_cpumask; 567 cpumask = iucv_irq_cpumask;
568 cpu_clear(first_cpu(iucv_irq_cpumask), cpumask); 568 cpu_clear(first_cpu(iucv_irq_cpumask), cpumask);
569 for_each_cpu_mask_nr(cpu, cpumask) 569 for_each_cpu_mask_nr(cpu, cpumask)
570 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1); 570 smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
571 } 571 }
572 572
573 /** 573 /**
574 * iucv_enable 574 * iucv_enable
575 * 575 *
576 * This function makes iucv ready for use. It allocates the pathid 576 * This function makes iucv ready for use. It allocates the pathid
577 * table, declares an iucv interrupt buffer and enables the iucv 577 * table, declares an iucv interrupt buffer and enables the iucv
578 * interrupts. Called when the first user has registered an iucv 578 * interrupts. Called when the first user has registered an iucv
579 * handler. 579 * handler.
580 */ 580 */
581 static int iucv_enable(void) 581 static int iucv_enable(void)
582 { 582 {
583 size_t alloc_size; 583 size_t alloc_size;
584 int cpu, rc; 584 int cpu, rc;
585 585
586 get_online_cpus(); 586 get_online_cpus();
587 rc = -ENOMEM; 587 rc = -ENOMEM;
588 alloc_size = iucv_max_pathid * sizeof(struct iucv_path); 588 alloc_size = iucv_max_pathid * sizeof(struct iucv_path);
589 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL); 589 iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
590 if (!iucv_path_table) 590 if (!iucv_path_table)
591 goto out; 591 goto out;
592 /* Declare per cpu buffers. */ 592 /* Declare per cpu buffers. */
593 rc = -EIO; 593 rc = -EIO;
594 for_each_online_cpu(cpu) 594 for_each_online_cpu(cpu)
595 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1); 595 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
596 if (cpus_empty(iucv_buffer_cpumask)) 596 if (cpus_empty(iucv_buffer_cpumask))
597 /* No cpu could declare an iucv buffer. */ 597 /* No cpu could declare an iucv buffer. */
598 goto out; 598 goto out;
599 put_online_cpus(); 599 put_online_cpus();
600 return 0; 600 return 0;
601 out: 601 out:
602 kfree(iucv_path_table); 602 kfree(iucv_path_table);
603 iucv_path_table = NULL; 603 iucv_path_table = NULL;
604 put_online_cpus(); 604 put_online_cpus();
605 return rc; 605 return rc;
606 } 606 }
607 607
608 /** 608 /**
609 * iucv_disable 609 * iucv_disable
610 * 610 *
611 * This function shuts down iucv. It disables iucv interrupts, retrieves 611 * This function shuts down iucv. It disables iucv interrupts, retrieves
612 * the iucv interrupt buffer and frees the pathid table. Called after the 612 * the iucv interrupt buffer and frees the pathid table. Called after the
613 * last user unregister its iucv handler. 613 * last user unregister its iucv handler.
614 */ 614 */
615 static void iucv_disable(void) 615 static void iucv_disable(void)
616 { 616 {
617 get_online_cpus(); 617 get_online_cpus();
618 on_each_cpu(iucv_retrieve_cpu, NULL, 1); 618 on_each_cpu(iucv_retrieve_cpu, NULL, 1);
619 kfree(iucv_path_table); 619 kfree(iucv_path_table);
620 iucv_path_table = NULL; 620 iucv_path_table = NULL;
621 put_online_cpus(); 621 put_online_cpus();
622 } 622 }
623 623
624 static int __cpuinit iucv_cpu_notify(struct notifier_block *self, 624 static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
625 unsigned long action, void *hcpu) 625 unsigned long action, void *hcpu)
626 { 626 {
627 cpumask_t cpumask; 627 cpumask_t cpumask;
628 long cpu = (long) hcpu; 628 long cpu = (long) hcpu;
629 629
630 switch (action) { 630 switch (action) {
631 case CPU_UP_PREPARE: 631 case CPU_UP_PREPARE:
632 case CPU_UP_PREPARE_FROZEN: 632 case CPU_UP_PREPARE_FROZEN:
633 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data), 633 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
634 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 634 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
635 if (!iucv_irq_data[cpu]) 635 if (!iucv_irq_data[cpu])
636 return notifier_from_errno(-ENOMEM); 636 return notifier_from_errno(-ENOMEM);
637 637
638 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param), 638 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
639 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 639 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
640 if (!iucv_param[cpu]) { 640 if (!iucv_param[cpu]) {
641 kfree(iucv_irq_data[cpu]); 641 kfree(iucv_irq_data[cpu]);
642 iucv_irq_data[cpu] = NULL; 642 iucv_irq_data[cpu] = NULL;
643 return notifier_from_errno(-ENOMEM); 643 return notifier_from_errno(-ENOMEM);
644 } 644 }
645 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param), 645 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
646 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 646 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
647 if (!iucv_param_irq[cpu]) { 647 if (!iucv_param_irq[cpu]) {
648 kfree(iucv_param[cpu]); 648 kfree(iucv_param[cpu]);
649 iucv_param[cpu] = NULL; 649 iucv_param[cpu] = NULL;
650 kfree(iucv_irq_data[cpu]); 650 kfree(iucv_irq_data[cpu]);
651 iucv_irq_data[cpu] = NULL; 651 iucv_irq_data[cpu] = NULL;
652 return notifier_from_errno(-ENOMEM); 652 return notifier_from_errno(-ENOMEM);
653 } 653 }
654 break; 654 break;
655 case CPU_UP_CANCELED: 655 case CPU_UP_CANCELED:
656 case CPU_UP_CANCELED_FROZEN: 656 case CPU_UP_CANCELED_FROZEN:
657 case CPU_DEAD: 657 case CPU_DEAD:
658 case CPU_DEAD_FROZEN: 658 case CPU_DEAD_FROZEN:
659 kfree(iucv_param_irq[cpu]); 659 kfree(iucv_param_irq[cpu]);
660 iucv_param_irq[cpu] = NULL; 660 iucv_param_irq[cpu] = NULL;
661 kfree(iucv_param[cpu]); 661 kfree(iucv_param[cpu]);
662 iucv_param[cpu] = NULL; 662 iucv_param[cpu] = NULL;
663 kfree(iucv_irq_data[cpu]); 663 kfree(iucv_irq_data[cpu]);
664 iucv_irq_data[cpu] = NULL; 664 iucv_irq_data[cpu] = NULL;
665 break; 665 break;
666 case CPU_ONLINE: 666 case CPU_ONLINE:
667 case CPU_ONLINE_FROZEN: 667 case CPU_ONLINE_FROZEN:
668 case CPU_DOWN_FAILED: 668 case CPU_DOWN_FAILED:
669 case CPU_DOWN_FAILED_FROZEN: 669 case CPU_DOWN_FAILED_FROZEN:
670 if (!iucv_path_table) 670 if (!iucv_path_table)
671 break; 671 break;
672 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1); 672 smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
673 break; 673 break;
674 case CPU_DOWN_PREPARE: 674 case CPU_DOWN_PREPARE:
675 case CPU_DOWN_PREPARE_FROZEN: 675 case CPU_DOWN_PREPARE_FROZEN:
676 if (!iucv_path_table) 676 if (!iucv_path_table)
677 break; 677 break;
678 cpumask = iucv_buffer_cpumask; 678 cpumask = iucv_buffer_cpumask;
679 cpu_clear(cpu, cpumask); 679 cpu_clear(cpu, cpumask);
680 if (cpus_empty(cpumask)) 680 if (cpus_empty(cpumask))
681 /* Can't offline last IUCV enabled cpu. */ 681 /* Can't offline last IUCV enabled cpu. */
682 return notifier_from_errno(-EINVAL); 682 return notifier_from_errno(-EINVAL);
683 smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1); 683 smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1);
684 if (cpus_empty(iucv_irq_cpumask)) 684 if (cpus_empty(iucv_irq_cpumask))
685 smp_call_function_single(first_cpu(iucv_buffer_cpumask), 685 smp_call_function_single(first_cpu(iucv_buffer_cpumask),
686 iucv_allow_cpu, NULL, 1); 686 iucv_allow_cpu, NULL, 1);
687 break; 687 break;
688 } 688 }
689 return NOTIFY_OK; 689 return NOTIFY_OK;
690 } 690 }
691 691
692 static struct notifier_block __refdata iucv_cpu_notifier = { 692 static struct notifier_block __refdata iucv_cpu_notifier = {
693 .notifier_call = iucv_cpu_notify, 693 .notifier_call = iucv_cpu_notify,
694 }; 694 };
695 695
696 /** 696 /**
697 * iucv_sever_pathid 697 * iucv_sever_pathid
698 * @pathid: path identification number. 698 * @pathid: path identification number.
699 * @userdata: 16-bytes of user data. 699 * @userdata: 16-bytes of user data.
700 * 700 *
701 * Sever an iucv path to free up the pathid. Used internally. 701 * Sever an iucv path to free up the pathid. Used internally.
702 */ 702 */
703 static int iucv_sever_pathid(u16 pathid, u8 userdata[16]) 703 static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
704 { 704 {
705 union iucv_param *parm; 705 union iucv_param *parm;
706 706
707 parm = iucv_param_irq[smp_processor_id()]; 707 parm = iucv_param_irq[smp_processor_id()];
708 memset(parm, 0, sizeof(union iucv_param)); 708 memset(parm, 0, sizeof(union iucv_param));
709 if (userdata) 709 if (userdata)
710 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 710 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
711 parm->ctrl.ippathid = pathid; 711 parm->ctrl.ippathid = pathid;
712 return iucv_call_b2f0(IUCV_SEVER, parm); 712 return iucv_call_b2f0(IUCV_SEVER, parm);
713 } 713 }
714 714
715 /** 715 /**
716 * __iucv_cleanup_queue 716 * __iucv_cleanup_queue
717 * @dummy: unused dummy argument 717 * @dummy: unused dummy argument
718 * 718 *
719 * Nop function called via smp_call_function to force work items from 719 * Nop function called via smp_call_function to force work items from
720 * pending external iucv interrupts to the work queue. 720 * pending external iucv interrupts to the work queue.
721 */ 721 */
722 static void __iucv_cleanup_queue(void *dummy) 722 static void __iucv_cleanup_queue(void *dummy)
723 { 723 {
724 } 724 }
725 725
726 /** 726 /**
727 * iucv_cleanup_queue 727 * iucv_cleanup_queue
728 * 728 *
729 * Function called after a path has been severed to find all remaining 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 730 * work items for the now stale pathid. The caller needs to hold the
731 * iucv_table_lock. 731 * iucv_table_lock.
732 */ 732 */
733 static void iucv_cleanup_queue(void) 733 static void iucv_cleanup_queue(void)
734 { 734 {
735 struct iucv_irq_list *p, *n; 735 struct iucv_irq_list *p, *n;
736 736
737 /* 737 /*
738 * When a path is severed, the pathid can be reused immediately 738 * When a path is severed, the pathid can be reused immediately
739 * on a iucv connect or a connection pending interrupt. Remove 739 * on a iucv connect or a connection pending interrupt. Remove
740 * all entries from the task queue that refer to a stale pathid 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 741 * (iucv_path_table[ix] == NULL). Only then do the iucv connect
742 * or deliver the connection pending interrupt. To get all the 742 * or deliver the connection pending interrupt. To get all the
743 * pending interrupts force them to the work queue by calling 743 * pending interrupts force them to the work queue by calling
744 * an empty function on all cpus. 744 * an empty function on all cpus.
745 */ 745 */
746 smp_call_function(__iucv_cleanup_queue, NULL, 1); 746 smp_call_function(__iucv_cleanup_queue, NULL, 1);
747 spin_lock_irq(&iucv_queue_lock); 747 spin_lock_irq(&iucv_queue_lock);
748 list_for_each_entry_safe(p, n, &iucv_task_queue, list) { 748 list_for_each_entry_safe(p, n, &iucv_task_queue, list) {
749 /* Remove stale work items from the task queue. */ 749 /* Remove stale work items from the task queue. */
750 if (iucv_path_table[p->data.ippathid] == NULL) { 750 if (iucv_path_table[p->data.ippathid] == NULL) {
751 list_del(&p->list); 751 list_del(&p->list);
752 kfree(p); 752 kfree(p);
753 } 753 }
754 } 754 }
755 spin_unlock_irq(&iucv_queue_lock); 755 spin_unlock_irq(&iucv_queue_lock);
756 } 756 }
757 757
758 /** 758 /**
759 * iucv_register: 759 * iucv_register:
760 * @handler: address of iucv handler structure 760 * @handler: address of iucv handler structure
761 * @smp: != 0 indicates that the handler can deal with out of order messages 761 * @smp: != 0 indicates that the handler can deal with out of order messages
762 * 762 *
763 * Registers a driver with IUCV. 763 * Registers a driver with IUCV.
764 * 764 *
765 * Returns 0 on success, -ENOMEM if the memory allocation for the pathid 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. 766 * table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
767 */ 767 */
768 int iucv_register(struct iucv_handler *handler, int smp) 768 int iucv_register(struct iucv_handler *handler, int smp)
769 { 769 {
770 int rc; 770 int rc;
771 771
772 if (!iucv_available) 772 if (!iucv_available)
773 return -ENOSYS; 773 return -ENOSYS;
774 mutex_lock(&iucv_register_mutex); 774 mutex_lock(&iucv_register_mutex);
775 if (!smp) 775 if (!smp)
776 iucv_nonsmp_handler++; 776 iucv_nonsmp_handler++;
777 if (list_empty(&iucv_handler_list)) { 777 if (list_empty(&iucv_handler_list)) {
778 rc = iucv_enable(); 778 rc = iucv_enable();
779 if (rc) 779 if (rc)
780 goto out_mutex; 780 goto out_mutex;
781 } else if (!smp && iucv_nonsmp_handler == 1) 781 } else if (!smp && iucv_nonsmp_handler == 1)
782 iucv_setmask_up(); 782 iucv_setmask_up();
783 INIT_LIST_HEAD(&handler->paths); 783 INIT_LIST_HEAD(&handler->paths);
784 784
785 spin_lock_bh(&iucv_table_lock); 785 spin_lock_bh(&iucv_table_lock);
786 list_add_tail(&handler->list, &iucv_handler_list); 786 list_add_tail(&handler->list, &iucv_handler_list);
787 spin_unlock_bh(&iucv_table_lock); 787 spin_unlock_bh(&iucv_table_lock);
788 rc = 0; 788 rc = 0;
789 out_mutex: 789 out_mutex:
790 mutex_unlock(&iucv_register_mutex); 790 mutex_unlock(&iucv_register_mutex);
791 return rc; 791 return rc;
792 } 792 }
793 EXPORT_SYMBOL(iucv_register); 793 EXPORT_SYMBOL(iucv_register);
794 794
795 /** 795 /**
796 * iucv_unregister 796 * iucv_unregister
797 * @handler: address of iucv handler structure 797 * @handler: address of iucv handler structure
798 * @smp: != 0 indicates that the handler can deal with out of order messages 798 * @smp: != 0 indicates that the handler can deal with out of order messages
799 * 799 *
800 * Unregister driver from IUCV. 800 * Unregister driver from IUCV.
801 */ 801 */
802 void iucv_unregister(struct iucv_handler *handler, int smp) 802 void iucv_unregister(struct iucv_handler *handler, int smp)
803 { 803 {
804 struct iucv_path *p, *n; 804 struct iucv_path *p, *n;
805 805
806 mutex_lock(&iucv_register_mutex); 806 mutex_lock(&iucv_register_mutex);
807 spin_lock_bh(&iucv_table_lock); 807 spin_lock_bh(&iucv_table_lock);
808 /* Remove handler from the iucv_handler_list. */ 808 /* Remove handler from the iucv_handler_list. */
809 list_del_init(&handler->list); 809 list_del_init(&handler->list);
810 /* Sever all pathids still referring to the handler. */ 810 /* Sever all pathids still referring to the handler. */
811 list_for_each_entry_safe(p, n, &handler->paths, list) { 811 list_for_each_entry_safe(p, n, &handler->paths, list) {
812 iucv_sever_pathid(p->pathid, NULL); 812 iucv_sever_pathid(p->pathid, NULL);
813 iucv_path_table[p->pathid] = NULL; 813 iucv_path_table[p->pathid] = NULL;
814 list_del(&p->list); 814 list_del(&p->list);
815 iucv_path_free(p); 815 iucv_path_free(p);
816 } 816 }
817 spin_unlock_bh(&iucv_table_lock); 817 spin_unlock_bh(&iucv_table_lock);
818 if (!smp) 818 if (!smp)
819 iucv_nonsmp_handler--; 819 iucv_nonsmp_handler--;
820 if (list_empty(&iucv_handler_list)) 820 if (list_empty(&iucv_handler_list))
821 iucv_disable(); 821 iucv_disable();
822 else if (!smp && iucv_nonsmp_handler == 0) 822 else if (!smp && iucv_nonsmp_handler == 0)
823 iucv_setmask_mp(); 823 iucv_setmask_mp();
824 mutex_unlock(&iucv_register_mutex); 824 mutex_unlock(&iucv_register_mutex);
825 } 825 }
826 EXPORT_SYMBOL(iucv_unregister); 826 EXPORT_SYMBOL(iucv_unregister);
827 827
828 static int iucv_reboot_event(struct notifier_block *this, 828 static int iucv_reboot_event(struct notifier_block *this,
829 unsigned long event, void *ptr) 829 unsigned long event, void *ptr)
830 { 830 {
831 int i, rc; 831 int i;
832 832
833 get_online_cpus(); 833 get_online_cpus();
834 on_each_cpu(iucv_block_cpu, NULL, 1); 834 on_each_cpu(iucv_block_cpu, NULL, 1);
835 preempt_disable(); 835 preempt_disable();
836 for (i = 0; i < iucv_max_pathid; i++) { 836 for (i = 0; i < iucv_max_pathid; i++) {
837 if (iucv_path_table[i]) 837 if (iucv_path_table[i])
838 rc = iucv_sever_pathid(i, NULL); 838 iucv_sever_pathid(i, NULL);
839 } 839 }
840 preempt_enable(); 840 preempt_enable();
841 put_online_cpus(); 841 put_online_cpus();
842 iucv_disable(); 842 iucv_disable();
843 return NOTIFY_DONE; 843 return NOTIFY_DONE;
844 } 844 }
845 845
846 static struct notifier_block iucv_reboot_notifier = { 846 static struct notifier_block iucv_reboot_notifier = {
847 .notifier_call = iucv_reboot_event, 847 .notifier_call = iucv_reboot_event,
848 }; 848 };
849 849
850 /** 850 /**
851 * iucv_path_accept 851 * iucv_path_accept
852 * @path: address of iucv path structure 852 * @path: address of iucv path structure
853 * @handler: address of iucv handler structure 853 * @handler: address of iucv handler structure
854 * @userdata: 16 bytes of data reflected to the communication partner 854 * @userdata: 16 bytes of data reflected to the communication partner
855 * @private: private data passed to interrupt handlers for this path 855 * @private: private data passed to interrupt handlers for this path
856 * 856 *
857 * This function is issued after the user received a connection pending 857 * This function is issued after the user received a connection pending
858 * external interrupt and now wishes to complete the IUCV communication path. 858 * external interrupt and now wishes to complete the IUCV communication path.
859 * 859 *
860 * Returns the result of the CP IUCV call. 860 * Returns the result of the CP IUCV call.
861 */ 861 */
862 int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler, 862 int iucv_path_accept(struct iucv_path *path, struct iucv_handler *handler,
863 u8 userdata[16], void *private) 863 u8 userdata[16], void *private)
864 { 864 {
865 union iucv_param *parm; 865 union iucv_param *parm;
866 int rc; 866 int rc;
867 867
868 local_bh_disable(); 868 local_bh_disable();
869 if (cpus_empty(iucv_buffer_cpumask)) { 869 if (cpus_empty(iucv_buffer_cpumask)) {
870 rc = -EIO; 870 rc = -EIO;
871 goto out; 871 goto out;
872 } 872 }
873 /* Prepare parameter block. */ 873 /* Prepare parameter block. */
874 parm = iucv_param[smp_processor_id()]; 874 parm = iucv_param[smp_processor_id()];
875 memset(parm, 0, sizeof(union iucv_param)); 875 memset(parm, 0, sizeof(union iucv_param));
876 parm->ctrl.ippathid = path->pathid; 876 parm->ctrl.ippathid = path->pathid;
877 parm->ctrl.ipmsglim = path->msglim; 877 parm->ctrl.ipmsglim = path->msglim;
878 if (userdata) 878 if (userdata)
879 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 879 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
880 parm->ctrl.ipflags1 = path->flags; 880 parm->ctrl.ipflags1 = path->flags;
881 881
882 rc = iucv_call_b2f0(IUCV_ACCEPT, parm); 882 rc = iucv_call_b2f0(IUCV_ACCEPT, parm);
883 if (!rc) { 883 if (!rc) {
884 path->private = private; 884 path->private = private;
885 path->msglim = parm->ctrl.ipmsglim; 885 path->msglim = parm->ctrl.ipmsglim;
886 path->flags = parm->ctrl.ipflags1; 886 path->flags = parm->ctrl.ipflags1;
887 } 887 }
888 out: 888 out:
889 local_bh_enable(); 889 local_bh_enable();
890 return rc; 890 return rc;
891 } 891 }
892 EXPORT_SYMBOL(iucv_path_accept); 892 EXPORT_SYMBOL(iucv_path_accept);
893 893
894 /** 894 /**
895 * iucv_path_connect 895 * iucv_path_connect
896 * @path: address of iucv path structure 896 * @path: address of iucv path structure
897 * @handler: address of iucv handler structure 897 * @handler: address of iucv handler structure
898 * @userid: 8-byte user identification 898 * @userid: 8-byte user identification
899 * @system: 8-byte target system identification 899 * @system: 8-byte target system identification
900 * @userdata: 16 bytes of data reflected to the communication partner 900 * @userdata: 16 bytes of data reflected to the communication partner
901 * @private: private data passed to interrupt handlers for this path 901 * @private: private data passed to interrupt handlers for this path
902 * 902 *
903 * This function establishes an IUCV path. Although the connect may complete 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 904 * successfully, you are not able to use the path until you receive an IUCV
905 * Connection Complete external interrupt. 905 * Connection Complete external interrupt.
906 * 906 *
907 * Returns the result of the CP IUCV call. 907 * Returns the result of the CP IUCV call.
908 */ 908 */
909 int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler, 909 int iucv_path_connect(struct iucv_path *path, struct iucv_handler *handler,
910 u8 userid[8], u8 system[8], u8 userdata[16], 910 u8 userid[8], u8 system[8], u8 userdata[16],
911 void *private) 911 void *private)
912 { 912 {
913 union iucv_param *parm; 913 union iucv_param *parm;
914 int rc; 914 int rc;
915 915
916 spin_lock_bh(&iucv_table_lock); 916 spin_lock_bh(&iucv_table_lock);
917 iucv_cleanup_queue(); 917 iucv_cleanup_queue();
918 if (cpus_empty(iucv_buffer_cpumask)) { 918 if (cpus_empty(iucv_buffer_cpumask)) {
919 rc = -EIO; 919 rc = -EIO;
920 goto out; 920 goto out;
921 } 921 }
922 parm = iucv_param[smp_processor_id()]; 922 parm = iucv_param[smp_processor_id()];
923 memset(parm, 0, sizeof(union iucv_param)); 923 memset(parm, 0, sizeof(union iucv_param));
924 parm->ctrl.ipmsglim = path->msglim; 924 parm->ctrl.ipmsglim = path->msglim;
925 parm->ctrl.ipflags1 = path->flags; 925 parm->ctrl.ipflags1 = path->flags;
926 if (userid) { 926 if (userid) {
927 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid)); 927 memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));
928 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 928 ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
929 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid)); 929 EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
930 } 930 }
931 if (system) { 931 if (system) {
932 memcpy(parm->ctrl.iptarget, system, 932 memcpy(parm->ctrl.iptarget, system,
933 sizeof(parm->ctrl.iptarget)); 933 sizeof(parm->ctrl.iptarget));
934 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 934 ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
935 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget)); 935 EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
936 } 936 }
937 if (userdata) 937 if (userdata)
938 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 938 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
939 939
940 rc = iucv_call_b2f0(IUCV_CONNECT, parm); 940 rc = iucv_call_b2f0(IUCV_CONNECT, parm);
941 if (!rc) { 941 if (!rc) {
942 if (parm->ctrl.ippathid < iucv_max_pathid) { 942 if (parm->ctrl.ippathid < iucv_max_pathid) {
943 path->pathid = parm->ctrl.ippathid; 943 path->pathid = parm->ctrl.ippathid;
944 path->msglim = parm->ctrl.ipmsglim; 944 path->msglim = parm->ctrl.ipmsglim;
945 path->flags = parm->ctrl.ipflags1; 945 path->flags = parm->ctrl.ipflags1;
946 path->handler = handler; 946 path->handler = handler;
947 path->private = private; 947 path->private = private;
948 list_add_tail(&path->list, &handler->paths); 948 list_add_tail(&path->list, &handler->paths);
949 iucv_path_table[path->pathid] = path; 949 iucv_path_table[path->pathid] = path;
950 } else { 950 } else {
951 iucv_sever_pathid(parm->ctrl.ippathid, 951 iucv_sever_pathid(parm->ctrl.ippathid,
952 iucv_error_pathid); 952 iucv_error_pathid);
953 rc = -EIO; 953 rc = -EIO;
954 } 954 }
955 } 955 }
956 out: 956 out:
957 spin_unlock_bh(&iucv_table_lock); 957 spin_unlock_bh(&iucv_table_lock);
958 return rc; 958 return rc;
959 } 959 }
960 EXPORT_SYMBOL(iucv_path_connect); 960 EXPORT_SYMBOL(iucv_path_connect);
961 961
962 /** 962 /**
963 * iucv_path_quiesce: 963 * iucv_path_quiesce:
964 * @path: address of iucv path structure 964 * @path: address of iucv path structure
965 * @userdata: 16 bytes of data reflected to the communication partner 965 * @userdata: 16 bytes of data reflected to the communication partner
966 * 966 *
967 * This function temporarily suspends incoming messages on an IUCV path. 967 * This function temporarily suspends incoming messages on an IUCV path.
968 * You can later reactivate the path by invoking the iucv_resume function. 968 * You can later reactivate the path by invoking the iucv_resume function.
969 * 969 *
970 * Returns the result from the CP IUCV call. 970 * Returns the result from the CP IUCV call.
971 */ 971 */
972 int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16]) 972 int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])
973 { 973 {
974 union iucv_param *parm; 974 union iucv_param *parm;
975 int rc; 975 int rc;
976 976
977 local_bh_disable(); 977 local_bh_disable();
978 if (cpus_empty(iucv_buffer_cpumask)) { 978 if (cpus_empty(iucv_buffer_cpumask)) {
979 rc = -EIO; 979 rc = -EIO;
980 goto out; 980 goto out;
981 } 981 }
982 parm = iucv_param[smp_processor_id()]; 982 parm = iucv_param[smp_processor_id()];
983 memset(parm, 0, sizeof(union iucv_param)); 983 memset(parm, 0, sizeof(union iucv_param));
984 if (userdata) 984 if (userdata)
985 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 985 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
986 parm->ctrl.ippathid = path->pathid; 986 parm->ctrl.ippathid = path->pathid;
987 rc = iucv_call_b2f0(IUCV_QUIESCE, parm); 987 rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
988 out: 988 out:
989 local_bh_enable(); 989 local_bh_enable();
990 return rc; 990 return rc;
991 } 991 }
992 EXPORT_SYMBOL(iucv_path_quiesce); 992 EXPORT_SYMBOL(iucv_path_quiesce);
993 993
994 /** 994 /**
995 * iucv_path_resume: 995 * iucv_path_resume:
996 * @path: address of iucv path structure 996 * @path: address of iucv path structure
997 * @userdata: 16 bytes of data reflected to the communication partner 997 * @userdata: 16 bytes of data reflected to the communication partner
998 * 998 *
999 * This function resumes incoming messages on an IUCV path that has 999 * This function resumes incoming messages on an IUCV path that has
1000 * been stopped with iucv_path_quiesce. 1000 * been stopped with iucv_path_quiesce.
1001 * 1001 *
1002 * Returns the result from the CP IUCV call. 1002 * Returns the result from the CP IUCV call.
1003 */ 1003 */
1004 int iucv_path_resume(struct iucv_path *path, u8 userdata[16]) 1004 int iucv_path_resume(struct iucv_path *path, u8 userdata[16])
1005 { 1005 {
1006 union iucv_param *parm; 1006 union iucv_param *parm;
1007 int rc; 1007 int rc;
1008 1008
1009 local_bh_disable(); 1009 local_bh_disable();
1010 if (cpus_empty(iucv_buffer_cpumask)) { 1010 if (cpus_empty(iucv_buffer_cpumask)) {
1011 rc = -EIO; 1011 rc = -EIO;
1012 goto out; 1012 goto out;
1013 } 1013 }
1014 parm = iucv_param[smp_processor_id()]; 1014 parm = iucv_param[smp_processor_id()];
1015 memset(parm, 0, sizeof(union iucv_param)); 1015 memset(parm, 0, sizeof(union iucv_param));
1016 if (userdata) 1016 if (userdata)
1017 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser)); 1017 memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
1018 parm->ctrl.ippathid = path->pathid; 1018 parm->ctrl.ippathid = path->pathid;
1019 rc = iucv_call_b2f0(IUCV_RESUME, parm); 1019 rc = iucv_call_b2f0(IUCV_RESUME, parm);
1020 out: 1020 out:
1021 local_bh_enable(); 1021 local_bh_enable();
1022 return rc; 1022 return rc;
1023 } 1023 }
1024 1024
1025 /** 1025 /**
1026 * iucv_path_sever 1026 * iucv_path_sever
1027 * @path: address of iucv path structure 1027 * @path: address of iucv path structure
1028 * @userdata: 16 bytes of data reflected to the communication partner 1028 * @userdata: 16 bytes of data reflected to the communication partner
1029 * 1029 *
1030 * This function terminates an IUCV path. 1030 * This function terminates an IUCV path.
1031 * 1031 *
1032 * Returns the result from the CP IUCV call. 1032 * Returns the result from the CP IUCV call.
1033 */ 1033 */
1034 int iucv_path_sever(struct iucv_path *path, u8 userdata[16]) 1034 int iucv_path_sever(struct iucv_path *path, u8 userdata[16])
1035 { 1035 {
1036 int rc; 1036 int rc;
1037 1037
1038 preempt_disable(); 1038 preempt_disable();
1039 if (cpus_empty(iucv_buffer_cpumask)) { 1039 if (cpus_empty(iucv_buffer_cpumask)) {
1040 rc = -EIO; 1040 rc = -EIO;
1041 goto out; 1041 goto out;
1042 } 1042 }
1043 if (iucv_active_cpu != smp_processor_id()) 1043 if (iucv_active_cpu != smp_processor_id())
1044 spin_lock_bh(&iucv_table_lock); 1044 spin_lock_bh(&iucv_table_lock);
1045 rc = iucv_sever_pathid(path->pathid, userdata); 1045 rc = iucv_sever_pathid(path->pathid, userdata);
1046 iucv_path_table[path->pathid] = NULL; 1046 iucv_path_table[path->pathid] = NULL;
1047 list_del_init(&path->list); 1047 list_del_init(&path->list);
1048 if (iucv_active_cpu != smp_processor_id()) 1048 if (iucv_active_cpu != smp_processor_id())
1049 spin_unlock_bh(&iucv_table_lock); 1049 spin_unlock_bh(&iucv_table_lock);
1050 out: 1050 out:
1051 preempt_enable(); 1051 preempt_enable();
1052 return rc; 1052 return rc;
1053 } 1053 }
1054 EXPORT_SYMBOL(iucv_path_sever); 1054 EXPORT_SYMBOL(iucv_path_sever);
1055 1055
1056 /** 1056 /**
1057 * iucv_message_purge 1057 * iucv_message_purge
1058 * @path: address of iucv path structure 1058 * @path: address of iucv path structure
1059 * @msg: address of iucv msg structure 1059 * @msg: address of iucv msg structure
1060 * @srccls: source class of message 1060 * @srccls: source class of message
1061 * 1061 *
1062 * Cancels a message you have sent. 1062 * Cancels a message you have sent.
1063 * 1063 *
1064 * Returns the result from the CP IUCV call. 1064 * Returns the result from the CP IUCV call.
1065 */ 1065 */
1066 int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg, 1066 int iucv_message_purge(struct iucv_path *path, struct iucv_message *msg,
1067 u32 srccls) 1067 u32 srccls)
1068 { 1068 {
1069 union iucv_param *parm; 1069 union iucv_param *parm;
1070 int rc; 1070 int rc;
1071 1071
1072 local_bh_disable(); 1072 local_bh_disable();
1073 if (cpus_empty(iucv_buffer_cpumask)) { 1073 if (cpus_empty(iucv_buffer_cpumask)) {
1074 rc = -EIO; 1074 rc = -EIO;
1075 goto out; 1075 goto out;
1076 } 1076 }
1077 parm = iucv_param[smp_processor_id()]; 1077 parm = iucv_param[smp_processor_id()];
1078 memset(parm, 0, sizeof(union iucv_param)); 1078 memset(parm, 0, sizeof(union iucv_param));
1079 parm->purge.ippathid = path->pathid; 1079 parm->purge.ippathid = path->pathid;
1080 parm->purge.ipmsgid = msg->id; 1080 parm->purge.ipmsgid = msg->id;
1081 parm->purge.ipsrccls = srccls; 1081 parm->purge.ipsrccls = srccls;
1082 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID; 1082 parm->purge.ipflags1 = IUCV_IPSRCCLS | IUCV_IPFGMID | IUCV_IPFGPID;
1083 rc = iucv_call_b2f0(IUCV_PURGE, parm); 1083 rc = iucv_call_b2f0(IUCV_PURGE, parm);
1084 if (!rc) { 1084 if (!rc) {
1085 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8; 1085 msg->audit = (*(u32 *) &parm->purge.ipaudit) >> 8;
1086 msg->tag = parm->purge.ipmsgtag; 1086 msg->tag = parm->purge.ipmsgtag;
1087 } 1087 }
1088 out: 1088 out:
1089 local_bh_enable(); 1089 local_bh_enable();
1090 return rc; 1090 return rc;
1091 } 1091 }
1092 EXPORT_SYMBOL(iucv_message_purge); 1092 EXPORT_SYMBOL(iucv_message_purge);
1093 1093
1094 /** 1094 /**
1095 * iucv_message_receive_iprmdata 1095 * iucv_message_receive_iprmdata
1096 * @path: address of iucv path structure 1096 * @path: address of iucv path structure
1097 * @msg: address of iucv msg structure 1097 * @msg: address of iucv msg structure
1098 * @flags: how the message is received (IUCV_IPBUFLST) 1098 * @flags: how the message is received (IUCV_IPBUFLST)
1099 * @buffer: address of data buffer or address of struct iucv_array 1099 * @buffer: address of data buffer or address of struct iucv_array
1100 * @size: length of data buffer 1100 * @size: length of data buffer
1101 * @residual: 1101 * @residual:
1102 * 1102 *
1103 * Internal function used by iucv_message_receive and __iucv_message_receive 1103 * Internal function used by iucv_message_receive and __iucv_message_receive
1104 * to receive RMDATA data stored in struct iucv_message. 1104 * to receive RMDATA data stored in struct iucv_message.
1105 */ 1105 */
1106 static int iucv_message_receive_iprmdata(struct iucv_path *path, 1106 static int iucv_message_receive_iprmdata(struct iucv_path *path,
1107 struct iucv_message *msg, 1107 struct iucv_message *msg,
1108 u8 flags, void *buffer, 1108 u8 flags, void *buffer,
1109 size_t size, size_t *residual) 1109 size_t size, size_t *residual)
1110 { 1110 {
1111 struct iucv_array *array; 1111 struct iucv_array *array;
1112 u8 *rmmsg; 1112 u8 *rmmsg;
1113 size_t copy; 1113 size_t copy;
1114 1114
1115 /* 1115 /*
1116 * Message is 8 bytes long and has been stored to the 1116 * Message is 8 bytes long and has been stored to the
1117 * message descriptor itself. 1117 * message descriptor itself.
1118 */ 1118 */
1119 if (residual) 1119 if (residual)
1120 *residual = abs(size - 8); 1120 *residual = abs(size - 8);
1121 rmmsg = msg->rmmsg; 1121 rmmsg = msg->rmmsg;
1122 if (flags & IUCV_IPBUFLST) { 1122 if (flags & IUCV_IPBUFLST) {
1123 /* Copy to struct iucv_array. */ 1123 /* Copy to struct iucv_array. */
1124 size = (size < 8) ? size : 8; 1124 size = (size < 8) ? size : 8;
1125 for (array = buffer; size > 0; array++) { 1125 for (array = buffer; size > 0; array++) {
1126 copy = min_t(size_t, size, array->length); 1126 copy = min_t(size_t, size, array->length);
1127 memcpy((u8 *)(addr_t) array->address, 1127 memcpy((u8 *)(addr_t) array->address,
1128 rmmsg, copy); 1128 rmmsg, copy);
1129 rmmsg += copy; 1129 rmmsg += copy;
1130 size -= copy; 1130 size -= copy;
1131 } 1131 }
1132 } else { 1132 } else {
1133 /* Copy to direct buffer. */ 1133 /* Copy to direct buffer. */
1134 memcpy(buffer, rmmsg, min_t(size_t, size, 8)); 1134 memcpy(buffer, rmmsg, min_t(size_t, size, 8));
1135 } 1135 }
1136 return 0; 1136 return 0;
1137 } 1137 }
1138 1138
1139 /** 1139 /**
1140 * __iucv_message_receive 1140 * __iucv_message_receive
1141 * @path: address of iucv path structure 1141 * @path: address of iucv path structure
1142 * @msg: address of iucv msg structure 1142 * @msg: address of iucv msg structure
1143 * @flags: how the message is received (IUCV_IPBUFLST) 1143 * @flags: how the message is received (IUCV_IPBUFLST)
1144 * @buffer: address of data buffer or address of struct iucv_array 1144 * @buffer: address of data buffer or address of struct iucv_array
1145 * @size: length of data buffer 1145 * @size: length of data buffer
1146 * @residual: 1146 * @residual:
1147 * 1147 *
1148 * This function receives messages that are being sent to you over 1148 * This function receives messages that are being sent to you over
1149 * established paths. This function will deal with RMDATA messages 1149 * established paths. This function will deal with RMDATA messages
1150 * embedded in struct iucv_message as well. 1150 * embedded in struct iucv_message as well.
1151 * 1151 *
1152 * Locking: no locking 1152 * Locking: no locking
1153 * 1153 *
1154 * Returns the result from the CP IUCV call. 1154 * Returns the result from the CP IUCV call.
1155 */ 1155 */
1156 int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1156 int __iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1157 u8 flags, void *buffer, size_t size, size_t *residual) 1157 u8 flags, void *buffer, size_t size, size_t *residual)
1158 { 1158 {
1159 union iucv_param *parm; 1159 union iucv_param *parm;
1160 int rc; 1160 int rc;
1161 1161
1162 if (msg->flags & IUCV_IPRMDATA) 1162 if (msg->flags & IUCV_IPRMDATA)
1163 return iucv_message_receive_iprmdata(path, msg, flags, 1163 return iucv_message_receive_iprmdata(path, msg, flags,
1164 buffer, size, residual); 1164 buffer, size, residual);
1165 if (cpus_empty(iucv_buffer_cpumask)) { 1165 if (cpus_empty(iucv_buffer_cpumask)) {
1166 rc = -EIO; 1166 rc = -EIO;
1167 goto out; 1167 goto out;
1168 } 1168 }
1169 parm = iucv_param[smp_processor_id()]; 1169 parm = iucv_param[smp_processor_id()];
1170 memset(parm, 0, sizeof(union iucv_param)); 1170 memset(parm, 0, sizeof(union iucv_param));
1171 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1171 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1172 parm->db.ipbfln1f = (u32) size; 1172 parm->db.ipbfln1f = (u32) size;
1173 parm->db.ipmsgid = msg->id; 1173 parm->db.ipmsgid = msg->id;
1174 parm->db.ippathid = path->pathid; 1174 parm->db.ippathid = path->pathid;
1175 parm->db.iptrgcls = msg->class; 1175 parm->db.iptrgcls = msg->class;
1176 parm->db.ipflags1 = (flags | IUCV_IPFGPID | 1176 parm->db.ipflags1 = (flags | IUCV_IPFGPID |
1177 IUCV_IPFGMID | IUCV_IPTRGCLS); 1177 IUCV_IPFGMID | IUCV_IPTRGCLS);
1178 rc = iucv_call_b2f0(IUCV_RECEIVE, parm); 1178 rc = iucv_call_b2f0(IUCV_RECEIVE, parm);
1179 if (!rc || rc == 5) { 1179 if (!rc || rc == 5) {
1180 msg->flags = parm->db.ipflags1; 1180 msg->flags = parm->db.ipflags1;
1181 if (residual) 1181 if (residual)
1182 *residual = parm->db.ipbfln1f; 1182 *residual = parm->db.ipbfln1f;
1183 } 1183 }
1184 out: 1184 out:
1185 return rc; 1185 return rc;
1186 } 1186 }
1187 EXPORT_SYMBOL(__iucv_message_receive); 1187 EXPORT_SYMBOL(__iucv_message_receive);
1188 1188
1189 /** 1189 /**
1190 * iucv_message_receive 1190 * iucv_message_receive
1191 * @path: address of iucv path structure 1191 * @path: address of iucv path structure
1192 * @msg: address of iucv msg structure 1192 * @msg: address of iucv msg structure
1193 * @flags: how the message is received (IUCV_IPBUFLST) 1193 * @flags: how the message is received (IUCV_IPBUFLST)
1194 * @buffer: address of data buffer or address of struct iucv_array 1194 * @buffer: address of data buffer or address of struct iucv_array
1195 * @size: length of data buffer 1195 * @size: length of data buffer
1196 * @residual: 1196 * @residual:
1197 * 1197 *
1198 * This function receives messages that are being sent to you over 1198 * This function receives messages that are being sent to you over
1199 * established paths. This function will deal with RMDATA messages 1199 * established paths. This function will deal with RMDATA messages
1200 * embedded in struct iucv_message as well. 1200 * embedded in struct iucv_message as well.
1201 * 1201 *
1202 * Locking: local_bh_enable/local_bh_disable 1202 * Locking: local_bh_enable/local_bh_disable
1203 * 1203 *
1204 * Returns the result from the CP IUCV call. 1204 * Returns the result from the CP IUCV call.
1205 */ 1205 */
1206 int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg, 1206 int iucv_message_receive(struct iucv_path *path, struct iucv_message *msg,
1207 u8 flags, void *buffer, size_t size, size_t *residual) 1207 u8 flags, void *buffer, size_t size, size_t *residual)
1208 { 1208 {
1209 int rc; 1209 int rc;
1210 1210
1211 if (msg->flags & IUCV_IPRMDATA) 1211 if (msg->flags & IUCV_IPRMDATA)
1212 return iucv_message_receive_iprmdata(path, msg, flags, 1212 return iucv_message_receive_iprmdata(path, msg, flags,
1213 buffer, size, residual); 1213 buffer, size, residual);
1214 local_bh_disable(); 1214 local_bh_disable();
1215 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual); 1215 rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
1216 local_bh_enable(); 1216 local_bh_enable();
1217 return rc; 1217 return rc;
1218 } 1218 }
1219 EXPORT_SYMBOL(iucv_message_receive); 1219 EXPORT_SYMBOL(iucv_message_receive);
1220 1220
1221 /** 1221 /**
1222 * iucv_message_reject 1222 * iucv_message_reject
1223 * @path: address of iucv path structure 1223 * @path: address of iucv path structure
1224 * @msg: address of iucv msg structure 1224 * @msg: address of iucv msg structure
1225 * 1225 *
1226 * The reject function refuses a specified message. Between the time you 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, 1227 * are notified of a message and the time that you complete the message,
1228 * the message may be rejected. 1228 * the message may be rejected.
1229 * 1229 *
1230 * Returns the result from the CP IUCV call. 1230 * Returns the result from the CP IUCV call.
1231 */ 1231 */
1232 int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg) 1232 int iucv_message_reject(struct iucv_path *path, struct iucv_message *msg)
1233 { 1233 {
1234 union iucv_param *parm; 1234 union iucv_param *parm;
1235 int rc; 1235 int rc;
1236 1236
1237 local_bh_disable(); 1237 local_bh_disable();
1238 if (cpus_empty(iucv_buffer_cpumask)) { 1238 if (cpus_empty(iucv_buffer_cpumask)) {
1239 rc = -EIO; 1239 rc = -EIO;
1240 goto out; 1240 goto out;
1241 } 1241 }
1242 parm = iucv_param[smp_processor_id()]; 1242 parm = iucv_param[smp_processor_id()];
1243 memset(parm, 0, sizeof(union iucv_param)); 1243 memset(parm, 0, sizeof(union iucv_param));
1244 parm->db.ippathid = path->pathid; 1244 parm->db.ippathid = path->pathid;
1245 parm->db.ipmsgid = msg->id; 1245 parm->db.ipmsgid = msg->id;
1246 parm->db.iptrgcls = msg->class; 1246 parm->db.iptrgcls = msg->class;
1247 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID); 1247 parm->db.ipflags1 = (IUCV_IPTRGCLS | IUCV_IPFGMID | IUCV_IPFGPID);
1248 rc = iucv_call_b2f0(IUCV_REJECT, parm); 1248 rc = iucv_call_b2f0(IUCV_REJECT, parm);
1249 out: 1249 out:
1250 local_bh_enable(); 1250 local_bh_enable();
1251 return rc; 1251 return rc;
1252 } 1252 }
1253 EXPORT_SYMBOL(iucv_message_reject); 1253 EXPORT_SYMBOL(iucv_message_reject);
1254 1254
1255 /** 1255 /**
1256 * iucv_message_reply 1256 * iucv_message_reply
1257 * @path: address of iucv path structure 1257 * @path: address of iucv path structure
1258 * @msg: address of iucv msg structure 1258 * @msg: address of iucv msg structure
1259 * @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 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 1260 * @reply: address of reply data buffer or address of struct iucv_array
1261 * @size: length of reply data buffer 1261 * @size: length of reply data buffer
1262 * 1262 *
1263 * This function responds to the two-way messages that you receive. You 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, 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 1265 * pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
1266 * the parameter list. 1266 * the parameter list.
1267 * 1267 *
1268 * Returns the result from the CP IUCV call. 1268 * Returns the result from the CP IUCV call.
1269 */ 1269 */
1270 int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg, 1270 int iucv_message_reply(struct iucv_path *path, struct iucv_message *msg,
1271 u8 flags, void *reply, size_t size) 1271 u8 flags, void *reply, size_t size)
1272 { 1272 {
1273 union iucv_param *parm; 1273 union iucv_param *parm;
1274 int rc; 1274 int rc;
1275 1275
1276 local_bh_disable(); 1276 local_bh_disable();
1277 if (cpus_empty(iucv_buffer_cpumask)) { 1277 if (cpus_empty(iucv_buffer_cpumask)) {
1278 rc = -EIO; 1278 rc = -EIO;
1279 goto out; 1279 goto out;
1280 } 1280 }
1281 parm = iucv_param[smp_processor_id()]; 1281 parm = iucv_param[smp_processor_id()];
1282 memset(parm, 0, sizeof(union iucv_param)); 1282 memset(parm, 0, sizeof(union iucv_param));
1283 if (flags & IUCV_IPRMDATA) { 1283 if (flags & IUCV_IPRMDATA) {
1284 parm->dpl.ippathid = path->pathid; 1284 parm->dpl.ippathid = path->pathid;
1285 parm->dpl.ipflags1 = flags; 1285 parm->dpl.ipflags1 = flags;
1286 parm->dpl.ipmsgid = msg->id; 1286 parm->dpl.ipmsgid = msg->id;
1287 parm->dpl.iptrgcls = msg->class; 1287 parm->dpl.iptrgcls = msg->class;
1288 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8)); 1288 memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));
1289 } else { 1289 } else {
1290 parm->db.ipbfadr1 = (u32)(addr_t) reply; 1290 parm->db.ipbfadr1 = (u32)(addr_t) reply;
1291 parm->db.ipbfln1f = (u32) size; 1291 parm->db.ipbfln1f = (u32) size;
1292 parm->db.ippathid = path->pathid; 1292 parm->db.ippathid = path->pathid;
1293 parm->db.ipflags1 = flags; 1293 parm->db.ipflags1 = flags;
1294 parm->db.ipmsgid = msg->id; 1294 parm->db.ipmsgid = msg->id;
1295 parm->db.iptrgcls = msg->class; 1295 parm->db.iptrgcls = msg->class;
1296 } 1296 }
1297 rc = iucv_call_b2f0(IUCV_REPLY, parm); 1297 rc = iucv_call_b2f0(IUCV_REPLY, parm);
1298 out: 1298 out:
1299 local_bh_enable(); 1299 local_bh_enable();
1300 return rc; 1300 return rc;
1301 } 1301 }
1302 EXPORT_SYMBOL(iucv_message_reply); 1302 EXPORT_SYMBOL(iucv_message_reply);
1303 1303
1304 /** 1304 /**
1305 * __iucv_message_send 1305 * __iucv_message_send
1306 * @path: address of iucv path structure 1306 * @path: address of iucv path structure
1307 * @msg: address of iucv msg structure 1307 * @msg: address of iucv msg structure
1308 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1308 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1309 * @srccls: source class of message 1309 * @srccls: source class of message
1310 * @buffer: address of send buffer or address of struct iucv_array 1310 * @buffer: address of send buffer or address of struct iucv_array
1311 * @size: length of send buffer 1311 * @size: length of send buffer
1312 * 1312 *
1313 * This function transmits data to another application. Data to be 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 1314 * transmitted is in a buffer and this is a one-way message and the
1315 * receiver will not reply to the message. 1315 * receiver will not reply to the message.
1316 * 1316 *
1317 * Locking: no locking 1317 * Locking: no locking
1318 * 1318 *
1319 * Returns the result from the CP IUCV call. 1319 * Returns the result from the CP IUCV call.
1320 */ 1320 */
1321 int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1321 int __iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1322 u8 flags, u32 srccls, void *buffer, size_t size) 1322 u8 flags, u32 srccls, void *buffer, size_t size)
1323 { 1323 {
1324 union iucv_param *parm; 1324 union iucv_param *parm;
1325 int rc; 1325 int rc;
1326 1326
1327 if (cpus_empty(iucv_buffer_cpumask)) { 1327 if (cpus_empty(iucv_buffer_cpumask)) {
1328 rc = -EIO; 1328 rc = -EIO;
1329 goto out; 1329 goto out;
1330 } 1330 }
1331 parm = iucv_param[smp_processor_id()]; 1331 parm = iucv_param[smp_processor_id()];
1332 memset(parm, 0, sizeof(union iucv_param)); 1332 memset(parm, 0, sizeof(union iucv_param));
1333 if (flags & IUCV_IPRMDATA) { 1333 if (flags & IUCV_IPRMDATA) {
1334 /* Message of 8 bytes can be placed into the parameter list. */ 1334 /* Message of 8 bytes can be placed into the parameter list. */
1335 parm->dpl.ippathid = path->pathid; 1335 parm->dpl.ippathid = path->pathid;
1336 parm->dpl.ipflags1 = flags | IUCV_IPNORPY; 1336 parm->dpl.ipflags1 = flags | IUCV_IPNORPY;
1337 parm->dpl.iptrgcls = msg->class; 1337 parm->dpl.iptrgcls = msg->class;
1338 parm->dpl.ipsrccls = srccls; 1338 parm->dpl.ipsrccls = srccls;
1339 parm->dpl.ipmsgtag = msg->tag; 1339 parm->dpl.ipmsgtag = msg->tag;
1340 memcpy(parm->dpl.iprmmsg, buffer, 8); 1340 memcpy(parm->dpl.iprmmsg, buffer, 8);
1341 } else { 1341 } else {
1342 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1342 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1343 parm->db.ipbfln1f = (u32) size; 1343 parm->db.ipbfln1f = (u32) size;
1344 parm->db.ippathid = path->pathid; 1344 parm->db.ippathid = path->pathid;
1345 parm->db.ipflags1 = flags | IUCV_IPNORPY; 1345 parm->db.ipflags1 = flags | IUCV_IPNORPY;
1346 parm->db.iptrgcls = msg->class; 1346 parm->db.iptrgcls = msg->class;
1347 parm->db.ipsrccls = srccls; 1347 parm->db.ipsrccls = srccls;
1348 parm->db.ipmsgtag = msg->tag; 1348 parm->db.ipmsgtag = msg->tag;
1349 } 1349 }
1350 rc = iucv_call_b2f0(IUCV_SEND, parm); 1350 rc = iucv_call_b2f0(IUCV_SEND, parm);
1351 if (!rc) 1351 if (!rc)
1352 msg->id = parm->db.ipmsgid; 1352 msg->id = parm->db.ipmsgid;
1353 out: 1353 out:
1354 return rc; 1354 return rc;
1355 } 1355 }
1356 EXPORT_SYMBOL(__iucv_message_send); 1356 EXPORT_SYMBOL(__iucv_message_send);
1357 1357
1358 /** 1358 /**
1359 * iucv_message_send 1359 * iucv_message_send
1360 * @path: address of iucv path structure 1360 * @path: address of iucv path structure
1361 * @msg: address of iucv msg structure 1361 * @msg: address of iucv msg structure
1362 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST) 1362 * @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1363 * @srccls: source class of message 1363 * @srccls: source class of message
1364 * @buffer: address of send buffer or address of struct iucv_array 1364 * @buffer: address of send buffer or address of struct iucv_array
1365 * @size: length of send buffer 1365 * @size: length of send buffer
1366 * 1366 *
1367 * This function transmits data to another application. Data to be 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 1368 * transmitted is in a buffer and this is a one-way message and the
1369 * receiver will not reply to the message. 1369 * receiver will not reply to the message.
1370 * 1370 *
1371 * Locking: local_bh_enable/local_bh_disable 1371 * Locking: local_bh_enable/local_bh_disable
1372 * 1372 *
1373 * Returns the result from the CP IUCV call. 1373 * Returns the result from the CP IUCV call.
1374 */ 1374 */
1375 int iucv_message_send(struct iucv_path *path, struct iucv_message *msg, 1375 int iucv_message_send(struct iucv_path *path, struct iucv_message *msg,
1376 u8 flags, u32 srccls, void *buffer, size_t size) 1376 u8 flags, u32 srccls, void *buffer, size_t size)
1377 { 1377 {
1378 int rc; 1378 int rc;
1379 1379
1380 local_bh_disable(); 1380 local_bh_disable();
1381 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size); 1381 rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
1382 local_bh_enable(); 1382 local_bh_enable();
1383 return rc; 1383 return rc;
1384 } 1384 }
1385 EXPORT_SYMBOL(iucv_message_send); 1385 EXPORT_SYMBOL(iucv_message_send);
1386 1386
1387 /** 1387 /**
1388 * iucv_message_send2way 1388 * iucv_message_send2way
1389 * @path: address of iucv path structure 1389 * @path: address of iucv path structure
1390 * @msg: address of iucv msg structure 1390 * @msg: address of iucv msg structure
1391 * @flags: how the message is sent and the reply is received 1391 * @flags: how the message is sent and the reply is received
1392 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST) 1392 * (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
1393 * @srccls: source class of message 1393 * @srccls: source class of message
1394 * @buffer: address of send buffer or address of struct iucv_array 1394 * @buffer: address of send buffer or address of struct iucv_array
1395 * @size: length of send buffer 1395 * @size: length of send buffer
1396 * @ansbuf: address of answer buffer or address of struct iucv_array 1396 * @ansbuf: address of answer buffer or address of struct iucv_array
1397 * @asize: size of reply buffer 1397 * @asize: size of reply buffer
1398 * 1398 *
1399 * This function transmits data to another application. Data to be 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 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 1401 * reply to the message and a buffer is provided into which IUCV moves
1402 * the reply to this message. 1402 * the reply to this message.
1403 * 1403 *
1404 * Returns the result from the CP IUCV call. 1404 * Returns the result from the CP IUCV call.
1405 */ 1405 */
1406 int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg, 1406 int iucv_message_send2way(struct iucv_path *path, struct iucv_message *msg,
1407 u8 flags, u32 srccls, void *buffer, size_t size, 1407 u8 flags, u32 srccls, void *buffer, size_t size,
1408 void *answer, size_t asize, size_t *residual) 1408 void *answer, size_t asize, size_t *residual)
1409 { 1409 {
1410 union iucv_param *parm; 1410 union iucv_param *parm;
1411 int rc; 1411 int rc;
1412 1412
1413 local_bh_disable(); 1413 local_bh_disable();
1414 if (cpus_empty(iucv_buffer_cpumask)) { 1414 if (cpus_empty(iucv_buffer_cpumask)) {
1415 rc = -EIO; 1415 rc = -EIO;
1416 goto out; 1416 goto out;
1417 } 1417 }
1418 parm = iucv_param[smp_processor_id()]; 1418 parm = iucv_param[smp_processor_id()];
1419 memset(parm, 0, sizeof(union iucv_param)); 1419 memset(parm, 0, sizeof(union iucv_param));
1420 if (flags & IUCV_IPRMDATA) { 1420 if (flags & IUCV_IPRMDATA) {
1421 parm->dpl.ippathid = path->pathid; 1421 parm->dpl.ippathid = path->pathid;
1422 parm->dpl.ipflags1 = path->flags; /* priority message */ 1422 parm->dpl.ipflags1 = path->flags; /* priority message */
1423 parm->dpl.iptrgcls = msg->class; 1423 parm->dpl.iptrgcls = msg->class;
1424 parm->dpl.ipsrccls = srccls; 1424 parm->dpl.ipsrccls = srccls;
1425 parm->dpl.ipmsgtag = msg->tag; 1425 parm->dpl.ipmsgtag = msg->tag;
1426 parm->dpl.ipbfadr2 = (u32)(addr_t) answer; 1426 parm->dpl.ipbfadr2 = (u32)(addr_t) answer;
1427 parm->dpl.ipbfln2f = (u32) asize; 1427 parm->dpl.ipbfln2f = (u32) asize;
1428 memcpy(parm->dpl.iprmmsg, buffer, 8); 1428 memcpy(parm->dpl.iprmmsg, buffer, 8);
1429 } else { 1429 } else {
1430 parm->db.ippathid = path->pathid; 1430 parm->db.ippathid = path->pathid;
1431 parm->db.ipflags1 = path->flags; /* priority message */ 1431 parm->db.ipflags1 = path->flags; /* priority message */
1432 parm->db.iptrgcls = msg->class; 1432 parm->db.iptrgcls = msg->class;
1433 parm->db.ipsrccls = srccls; 1433 parm->db.ipsrccls = srccls;
1434 parm->db.ipmsgtag = msg->tag; 1434 parm->db.ipmsgtag = msg->tag;
1435 parm->db.ipbfadr1 = (u32)(addr_t) buffer; 1435 parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1436 parm->db.ipbfln1f = (u32) size; 1436 parm->db.ipbfln1f = (u32) size;
1437 parm->db.ipbfadr2 = (u32)(addr_t) answer; 1437 parm->db.ipbfadr2 = (u32)(addr_t) answer;
1438 parm->db.ipbfln2f = (u32) asize; 1438 parm->db.ipbfln2f = (u32) asize;
1439 } 1439 }
1440 rc = iucv_call_b2f0(IUCV_SEND, parm); 1440 rc = iucv_call_b2f0(IUCV_SEND, parm);
1441 if (!rc) 1441 if (!rc)
1442 msg->id = parm->db.ipmsgid; 1442 msg->id = parm->db.ipmsgid;
1443 out: 1443 out:
1444 local_bh_enable(); 1444 local_bh_enable();
1445 return rc; 1445 return rc;
1446 } 1446 }
1447 EXPORT_SYMBOL(iucv_message_send2way); 1447 EXPORT_SYMBOL(iucv_message_send2way);
1448 1448
1449 /** 1449 /**
1450 * iucv_path_pending 1450 * iucv_path_pending
1451 * @data: Pointer to external interrupt buffer 1451 * @data: Pointer to external interrupt buffer
1452 * 1452 *
1453 * Process connection pending work item. Called from tasklet while holding 1453 * Process connection pending work item. Called from tasklet while holding
1454 * iucv_table_lock. 1454 * iucv_table_lock.
1455 */ 1455 */
1456 struct iucv_path_pending { 1456 struct iucv_path_pending {
1457 u16 ippathid; 1457 u16 ippathid;
1458 u8 ipflags1; 1458 u8 ipflags1;
1459 u8 iptype; 1459 u8 iptype;
1460 u16 ipmsglim; 1460 u16 ipmsglim;
1461 u16 res1; 1461 u16 res1;
1462 u8 ipvmid[8]; 1462 u8 ipvmid[8];
1463 u8 ipuser[16]; 1463 u8 ipuser[16];
1464 u32 res3; 1464 u32 res3;
1465 u8 ippollfg; 1465 u8 ippollfg;
1466 u8 res4[3]; 1466 u8 res4[3];
1467 } __packed; 1467 } __packed;
1468 1468
1469 static void iucv_path_pending(struct iucv_irq_data *data) 1469 static void iucv_path_pending(struct iucv_irq_data *data)
1470 { 1470 {
1471 struct iucv_path_pending *ipp = (void *) data; 1471 struct iucv_path_pending *ipp = (void *) data;
1472 struct iucv_handler *handler; 1472 struct iucv_handler *handler;
1473 struct iucv_path *path; 1473 struct iucv_path *path;
1474 char *error; 1474 char *error;
1475 1475
1476 BUG_ON(iucv_path_table[ipp->ippathid]); 1476 BUG_ON(iucv_path_table[ipp->ippathid]);
1477 /* New pathid, handler found. Create a new path struct. */ 1477 /* New pathid, handler found. Create a new path struct. */
1478 error = iucv_error_no_memory; 1478 error = iucv_error_no_memory;
1479 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC); 1479 path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);
1480 if (!path) 1480 if (!path)
1481 goto out_sever; 1481 goto out_sever;
1482 path->pathid = ipp->ippathid; 1482 path->pathid = ipp->ippathid;
1483 iucv_path_table[path->pathid] = path; 1483 iucv_path_table[path->pathid] = path;
1484 EBCASC(ipp->ipvmid, 8); 1484 EBCASC(ipp->ipvmid, 8);
1485 1485
1486 /* Call registered handler until one is found that wants the path. */ 1486 /* Call registered handler until one is found that wants the path. */
1487 list_for_each_entry(handler, &iucv_handler_list, list) { 1487 list_for_each_entry(handler, &iucv_handler_list, list) {
1488 if (!handler->path_pending) 1488 if (!handler->path_pending)
1489 continue; 1489 continue;
1490 /* 1490 /*
1491 * Add path to handler to allow a call to iucv_path_sever 1491 * Add path to handler to allow a call to iucv_path_sever
1492 * inside the path_pending function. If the handler returns 1492 * inside the path_pending function. If the handler returns
1493 * an error remove the path from the handler again. 1493 * an error remove the path from the handler again.
1494 */ 1494 */
1495 list_add(&path->list, &handler->paths); 1495 list_add(&path->list, &handler->paths);
1496 path->handler = handler; 1496 path->handler = handler;
1497 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser)) 1497 if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))
1498 return; 1498 return;
1499 list_del(&path->list); 1499 list_del(&path->list);
1500 path->handler = NULL; 1500 path->handler = NULL;
1501 } 1501 }
1502 /* No handler wanted the path. */ 1502 /* No handler wanted the path. */
1503 iucv_path_table[path->pathid] = NULL; 1503 iucv_path_table[path->pathid] = NULL;
1504 iucv_path_free(path); 1504 iucv_path_free(path);
1505 error = iucv_error_no_listener; 1505 error = iucv_error_no_listener;
1506 out_sever: 1506 out_sever:
1507 iucv_sever_pathid(ipp->ippathid, error); 1507 iucv_sever_pathid(ipp->ippathid, error);
1508 } 1508 }
1509 1509
1510 /** 1510 /**
1511 * iucv_path_complete 1511 * iucv_path_complete
1512 * @data: Pointer to external interrupt buffer 1512 * @data: Pointer to external interrupt buffer
1513 * 1513 *
1514 * Process connection complete work item. Called from tasklet while holding 1514 * Process connection complete work item. Called from tasklet while holding
1515 * iucv_table_lock. 1515 * iucv_table_lock.
1516 */ 1516 */
1517 struct iucv_path_complete { 1517 struct iucv_path_complete {
1518 u16 ippathid; 1518 u16 ippathid;
1519 u8 ipflags1; 1519 u8 ipflags1;
1520 u8 iptype; 1520 u8 iptype;
1521 u16 ipmsglim; 1521 u16 ipmsglim;
1522 u16 res1; 1522 u16 res1;
1523 u8 res2[8]; 1523 u8 res2[8];
1524 u8 ipuser[16]; 1524 u8 ipuser[16];
1525 u32 res3; 1525 u32 res3;
1526 u8 ippollfg; 1526 u8 ippollfg;
1527 u8 res4[3]; 1527 u8 res4[3];
1528 } __packed; 1528 } __packed;
1529 1529
1530 static void iucv_path_complete(struct iucv_irq_data *data) 1530 static void iucv_path_complete(struct iucv_irq_data *data)
1531 { 1531 {
1532 struct iucv_path_complete *ipc = (void *) data; 1532 struct iucv_path_complete *ipc = (void *) data;
1533 struct iucv_path *path = iucv_path_table[ipc->ippathid]; 1533 struct iucv_path *path = iucv_path_table[ipc->ippathid];
1534 1534
1535 if (path) 1535 if (path)
1536 path->flags = ipc->ipflags1; 1536 path->flags = ipc->ipflags1;
1537 if (path && path->handler && path->handler->path_complete) 1537 if (path && path->handler && path->handler->path_complete)
1538 path->handler->path_complete(path, ipc->ipuser); 1538 path->handler->path_complete(path, ipc->ipuser);
1539 } 1539 }
1540 1540
1541 /** 1541 /**
1542 * iucv_path_severed 1542 * iucv_path_severed
1543 * @data: Pointer to external interrupt buffer 1543 * @data: Pointer to external interrupt buffer
1544 * 1544 *
1545 * Process connection severed work item. Called from tasklet while holding 1545 * Process connection severed work item. Called from tasklet while holding
1546 * iucv_table_lock. 1546 * iucv_table_lock.
1547 */ 1547 */
1548 struct iucv_path_severed { 1548 struct iucv_path_severed {
1549 u16 ippathid; 1549 u16 ippathid;
1550 u8 res1; 1550 u8 res1;
1551 u8 iptype; 1551 u8 iptype;
1552 u32 res2; 1552 u32 res2;
1553 u8 res3[8]; 1553 u8 res3[8];
1554 u8 ipuser[16]; 1554 u8 ipuser[16];
1555 u32 res4; 1555 u32 res4;
1556 u8 ippollfg; 1556 u8 ippollfg;
1557 u8 res5[3]; 1557 u8 res5[3];
1558 } __packed; 1558 } __packed;
1559 1559
1560 static void iucv_path_severed(struct iucv_irq_data *data) 1560 static void iucv_path_severed(struct iucv_irq_data *data)
1561 { 1561 {
1562 struct iucv_path_severed *ips = (void *) data; 1562 struct iucv_path_severed *ips = (void *) data;
1563 struct iucv_path *path = iucv_path_table[ips->ippathid]; 1563 struct iucv_path *path = iucv_path_table[ips->ippathid];
1564 1564
1565 if (!path || !path->handler) /* Already severed */ 1565 if (!path || !path->handler) /* Already severed */
1566 return; 1566 return;
1567 if (path->handler->path_severed) 1567 if (path->handler->path_severed)
1568 path->handler->path_severed(path, ips->ipuser); 1568 path->handler->path_severed(path, ips->ipuser);
1569 else { 1569 else {
1570 iucv_sever_pathid(path->pathid, NULL); 1570 iucv_sever_pathid(path->pathid, NULL);
1571 iucv_path_table[path->pathid] = NULL; 1571 iucv_path_table[path->pathid] = NULL;
1572 list_del(&path->list); 1572 list_del(&path->list);
1573 iucv_path_free(path); 1573 iucv_path_free(path);
1574 } 1574 }
1575 } 1575 }
1576 1576
1577 /** 1577 /**
1578 * iucv_path_quiesced 1578 * iucv_path_quiesced
1579 * @data: Pointer to external interrupt buffer 1579 * @data: Pointer to external interrupt buffer
1580 * 1580 *
1581 * Process connection quiesced work item. Called from tasklet while holding 1581 * Process connection quiesced work item. Called from tasklet while holding
1582 * iucv_table_lock. 1582 * iucv_table_lock.
1583 */ 1583 */
1584 struct iucv_path_quiesced { 1584 struct iucv_path_quiesced {
1585 u16 ippathid; 1585 u16 ippathid;
1586 u8 res1; 1586 u8 res1;
1587 u8 iptype; 1587 u8 iptype;
1588 u32 res2; 1588 u32 res2;
1589 u8 res3[8]; 1589 u8 res3[8];
1590 u8 ipuser[16]; 1590 u8 ipuser[16];
1591 u32 res4; 1591 u32 res4;
1592 u8 ippollfg; 1592 u8 ippollfg;
1593 u8 res5[3]; 1593 u8 res5[3];
1594 } __packed; 1594 } __packed;
1595 1595
1596 static void iucv_path_quiesced(struct iucv_irq_data *data) 1596 static void iucv_path_quiesced(struct iucv_irq_data *data)
1597 { 1597 {
1598 struct iucv_path_quiesced *ipq = (void *) data; 1598 struct iucv_path_quiesced *ipq = (void *) data;
1599 struct iucv_path *path = iucv_path_table[ipq->ippathid]; 1599 struct iucv_path *path = iucv_path_table[ipq->ippathid];
1600 1600
1601 if (path && path->handler && path->handler->path_quiesced) 1601 if (path && path->handler && path->handler->path_quiesced)
1602 path->handler->path_quiesced(path, ipq->ipuser); 1602 path->handler->path_quiesced(path, ipq->ipuser);
1603 } 1603 }
1604 1604
1605 /** 1605 /**
1606 * iucv_path_resumed 1606 * iucv_path_resumed
1607 * @data: Pointer to external interrupt buffer 1607 * @data: Pointer to external interrupt buffer
1608 * 1608 *
1609 * Process connection resumed work item. Called from tasklet while holding 1609 * Process connection resumed work item. Called from tasklet while holding
1610 * iucv_table_lock. 1610 * iucv_table_lock.
1611 */ 1611 */
1612 struct iucv_path_resumed { 1612 struct iucv_path_resumed {
1613 u16 ippathid; 1613 u16 ippathid;
1614 u8 res1; 1614 u8 res1;
1615 u8 iptype; 1615 u8 iptype;
1616 u32 res2; 1616 u32 res2;
1617 u8 res3[8]; 1617 u8 res3[8];
1618 u8 ipuser[16]; 1618 u8 ipuser[16];
1619 u32 res4; 1619 u32 res4;
1620 u8 ippollfg; 1620 u8 ippollfg;
1621 u8 res5[3]; 1621 u8 res5[3];
1622 } __packed; 1622 } __packed;
1623 1623
1624 static void iucv_path_resumed(struct iucv_irq_data *data) 1624 static void iucv_path_resumed(struct iucv_irq_data *data)
1625 { 1625 {
1626 struct iucv_path_resumed *ipr = (void *) data; 1626 struct iucv_path_resumed *ipr = (void *) data;
1627 struct iucv_path *path = iucv_path_table[ipr->ippathid]; 1627 struct iucv_path *path = iucv_path_table[ipr->ippathid];
1628 1628
1629 if (path && path->handler && path->handler->path_resumed) 1629 if (path && path->handler && path->handler->path_resumed)
1630 path->handler->path_resumed(path, ipr->ipuser); 1630 path->handler->path_resumed(path, ipr->ipuser);
1631 } 1631 }
1632 1632
1633 /** 1633 /**
1634 * iucv_message_complete 1634 * iucv_message_complete
1635 * @data: Pointer to external interrupt buffer 1635 * @data: Pointer to external interrupt buffer
1636 * 1636 *
1637 * Process message complete work item. Called from tasklet while holding 1637 * Process message complete work item. Called from tasklet while holding
1638 * iucv_table_lock. 1638 * iucv_table_lock.
1639 */ 1639 */
1640 struct iucv_message_complete { 1640 struct iucv_message_complete {
1641 u16 ippathid; 1641 u16 ippathid;
1642 u8 ipflags1; 1642 u8 ipflags1;
1643 u8 iptype; 1643 u8 iptype;
1644 u32 ipmsgid; 1644 u32 ipmsgid;
1645 u32 ipaudit; 1645 u32 ipaudit;
1646 u8 iprmmsg[8]; 1646 u8 iprmmsg[8];
1647 u32 ipsrccls; 1647 u32 ipsrccls;
1648 u32 ipmsgtag; 1648 u32 ipmsgtag;
1649 u32 res; 1649 u32 res;
1650 u32 ipbfln2f; 1650 u32 ipbfln2f;
1651 u8 ippollfg; 1651 u8 ippollfg;
1652 u8 res2[3]; 1652 u8 res2[3];
1653 } __packed; 1653 } __packed;
1654 1654
1655 static void iucv_message_complete(struct iucv_irq_data *data) 1655 static void iucv_message_complete(struct iucv_irq_data *data)
1656 { 1656 {
1657 struct iucv_message_complete *imc = (void *) data; 1657 struct iucv_message_complete *imc = (void *) data;
1658 struct iucv_path *path = iucv_path_table[imc->ippathid]; 1658 struct iucv_path *path = iucv_path_table[imc->ippathid];
1659 struct iucv_message msg; 1659 struct iucv_message msg;
1660 1660
1661 if (path && path->handler && path->handler->message_complete) { 1661 if (path && path->handler && path->handler->message_complete) {
1662 msg.flags = imc->ipflags1; 1662 msg.flags = imc->ipflags1;
1663 msg.id = imc->ipmsgid; 1663 msg.id = imc->ipmsgid;
1664 msg.audit = imc->ipaudit; 1664 msg.audit = imc->ipaudit;
1665 memcpy(msg.rmmsg, imc->iprmmsg, 8); 1665 memcpy(msg.rmmsg, imc->iprmmsg, 8);
1666 msg.class = imc->ipsrccls; 1666 msg.class = imc->ipsrccls;
1667 msg.tag = imc->ipmsgtag; 1667 msg.tag = imc->ipmsgtag;
1668 msg.length = imc->ipbfln2f; 1668 msg.length = imc->ipbfln2f;
1669 path->handler->message_complete(path, &msg); 1669 path->handler->message_complete(path, &msg);
1670 } 1670 }
1671 } 1671 }
1672 1672
1673 /** 1673 /**
1674 * iucv_message_pending 1674 * iucv_message_pending
1675 * @data: Pointer to external interrupt buffer 1675 * @data: Pointer to external interrupt buffer
1676 * 1676 *
1677 * Process message pending work item. Called from tasklet while holding 1677 * Process message pending work item. Called from tasklet while holding
1678 * iucv_table_lock. 1678 * iucv_table_lock.
1679 */ 1679 */
1680 struct iucv_message_pending { 1680 struct iucv_message_pending {
1681 u16 ippathid; 1681 u16 ippathid;
1682 u8 ipflags1; 1682 u8 ipflags1;
1683 u8 iptype; 1683 u8 iptype;
1684 u32 ipmsgid; 1684 u32 ipmsgid;
1685 u32 iptrgcls; 1685 u32 iptrgcls;
1686 union { 1686 union {
1687 u32 iprmmsg1_u32; 1687 u32 iprmmsg1_u32;
1688 u8 iprmmsg1[4]; 1688 u8 iprmmsg1[4];
1689 } ln1msg1; 1689 } ln1msg1;
1690 union { 1690 union {
1691 u32 ipbfln1f; 1691 u32 ipbfln1f;
1692 u8 iprmmsg2[4]; 1692 u8 iprmmsg2[4];
1693 } ln1msg2; 1693 } ln1msg2;
1694 u32 res1[3]; 1694 u32 res1[3];
1695 u32 ipbfln2f; 1695 u32 ipbfln2f;
1696 u8 ippollfg; 1696 u8 ippollfg;
1697 u8 res2[3]; 1697 u8 res2[3];
1698 } __packed; 1698 } __packed;
1699 1699
1700 static void iucv_message_pending(struct iucv_irq_data *data) 1700 static void iucv_message_pending(struct iucv_irq_data *data)
1701 { 1701 {
1702 struct iucv_message_pending *imp = (void *) data; 1702 struct iucv_message_pending *imp = (void *) data;
1703 struct iucv_path *path = iucv_path_table[imp->ippathid]; 1703 struct iucv_path *path = iucv_path_table[imp->ippathid];
1704 struct iucv_message msg; 1704 struct iucv_message msg;
1705 1705
1706 if (path && path->handler && path->handler->message_pending) { 1706 if (path && path->handler && path->handler->message_pending) {
1707 msg.flags = imp->ipflags1; 1707 msg.flags = imp->ipflags1;
1708 msg.id = imp->ipmsgid; 1708 msg.id = imp->ipmsgid;
1709 msg.class = imp->iptrgcls; 1709 msg.class = imp->iptrgcls;
1710 if (imp->ipflags1 & IUCV_IPRMDATA) { 1710 if (imp->ipflags1 & IUCV_IPRMDATA) {
1711 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8); 1711 memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8);
1712 msg.length = 8; 1712 msg.length = 8;
1713 } else 1713 } else
1714 msg.length = imp->ln1msg2.ipbfln1f; 1714 msg.length = imp->ln1msg2.ipbfln1f;
1715 msg.reply_size = imp->ipbfln2f; 1715 msg.reply_size = imp->ipbfln2f;
1716 path->handler->message_pending(path, &msg); 1716 path->handler->message_pending(path, &msg);
1717 } 1717 }
1718 } 1718 }
1719 1719
1720 /** 1720 /**
1721 * iucv_tasklet_fn: 1721 * iucv_tasklet_fn:
1722 * 1722 *
1723 * This tasklet loops over the queue of irq buffers created by 1723 * This tasklet loops over the queue of irq buffers created by
1724 * iucv_external_interrupt, calls the appropriate action handler 1724 * iucv_external_interrupt, calls the appropriate action handler
1725 * and then frees the buffer. 1725 * and then frees the buffer.
1726 */ 1726 */
1727 static void iucv_tasklet_fn(unsigned long ignored) 1727 static void iucv_tasklet_fn(unsigned long ignored)
1728 { 1728 {
1729 typedef void iucv_irq_fn(struct iucv_irq_data *); 1729 typedef void iucv_irq_fn(struct iucv_irq_data *);
1730 static iucv_irq_fn *irq_fn[] = { 1730 static iucv_irq_fn *irq_fn[] = {
1731 [0x02] = iucv_path_complete, 1731 [0x02] = iucv_path_complete,
1732 [0x03] = iucv_path_severed, 1732 [0x03] = iucv_path_severed,
1733 [0x04] = iucv_path_quiesced, 1733 [0x04] = iucv_path_quiesced,
1734 [0x05] = iucv_path_resumed, 1734 [0x05] = iucv_path_resumed,
1735 [0x06] = iucv_message_complete, 1735 [0x06] = iucv_message_complete,
1736 [0x07] = iucv_message_complete, 1736 [0x07] = iucv_message_complete,
1737 [0x08] = iucv_message_pending, 1737 [0x08] = iucv_message_pending,
1738 [0x09] = iucv_message_pending, 1738 [0x09] = iucv_message_pending,
1739 }; 1739 };
1740 LIST_HEAD(task_queue); 1740 LIST_HEAD(task_queue);
1741 struct iucv_irq_list *p, *n; 1741 struct iucv_irq_list *p, *n;
1742 1742
1743 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1743 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1744 if (!spin_trylock(&iucv_table_lock)) { 1744 if (!spin_trylock(&iucv_table_lock)) {
1745 tasklet_schedule(&iucv_tasklet); 1745 tasklet_schedule(&iucv_tasklet);
1746 return; 1746 return;
1747 } 1747 }
1748 iucv_active_cpu = smp_processor_id(); 1748 iucv_active_cpu = smp_processor_id();
1749 1749
1750 spin_lock_irq(&iucv_queue_lock); 1750 spin_lock_irq(&iucv_queue_lock);
1751 list_splice_init(&iucv_task_queue, &task_queue); 1751 list_splice_init(&iucv_task_queue, &task_queue);
1752 spin_unlock_irq(&iucv_queue_lock); 1752 spin_unlock_irq(&iucv_queue_lock);
1753 1753
1754 list_for_each_entry_safe(p, n, &task_queue, list) { 1754 list_for_each_entry_safe(p, n, &task_queue, list) {
1755 list_del_init(&p->list); 1755 list_del_init(&p->list);
1756 irq_fn[p->data.iptype](&p->data); 1756 irq_fn[p->data.iptype](&p->data);
1757 kfree(p); 1757 kfree(p);
1758 } 1758 }
1759 1759
1760 iucv_active_cpu = -1; 1760 iucv_active_cpu = -1;
1761 spin_unlock(&iucv_table_lock); 1761 spin_unlock(&iucv_table_lock);
1762 } 1762 }
1763 1763
1764 /** 1764 /**
1765 * iucv_work_fn: 1765 * iucv_work_fn:
1766 * 1766 *
1767 * This work function loops over the queue of path pending irq blocks 1767 * This work function loops over the queue of path pending irq blocks
1768 * created by iucv_external_interrupt, calls the appropriate action 1768 * created by iucv_external_interrupt, calls the appropriate action
1769 * handler and then frees the buffer. 1769 * handler and then frees the buffer.
1770 */ 1770 */
1771 static void iucv_work_fn(struct work_struct *work) 1771 static void iucv_work_fn(struct work_struct *work)
1772 { 1772 {
1773 LIST_HEAD(work_queue); 1773 LIST_HEAD(work_queue);
1774 struct iucv_irq_list *p, *n; 1774 struct iucv_irq_list *p, *n;
1775 1775
1776 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */ 1776 /* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1777 spin_lock_bh(&iucv_table_lock); 1777 spin_lock_bh(&iucv_table_lock);
1778 iucv_active_cpu = smp_processor_id(); 1778 iucv_active_cpu = smp_processor_id();
1779 1779
1780 spin_lock_irq(&iucv_queue_lock); 1780 spin_lock_irq(&iucv_queue_lock);
1781 list_splice_init(&iucv_work_queue, &work_queue); 1781 list_splice_init(&iucv_work_queue, &work_queue);
1782 spin_unlock_irq(&iucv_queue_lock); 1782 spin_unlock_irq(&iucv_queue_lock);
1783 1783
1784 iucv_cleanup_queue(); 1784 iucv_cleanup_queue();
1785 list_for_each_entry_safe(p, n, &work_queue, list) { 1785 list_for_each_entry_safe(p, n, &work_queue, list) {
1786 list_del_init(&p->list); 1786 list_del_init(&p->list);
1787 iucv_path_pending(&p->data); 1787 iucv_path_pending(&p->data);
1788 kfree(p); 1788 kfree(p);
1789 } 1789 }
1790 1790
1791 iucv_active_cpu = -1; 1791 iucv_active_cpu = -1;
1792 spin_unlock_bh(&iucv_table_lock); 1792 spin_unlock_bh(&iucv_table_lock);
1793 } 1793 }
1794 1794
1795 /** 1795 /**
1796 * iucv_external_interrupt 1796 * iucv_external_interrupt
1797 * @code: irq code 1797 * @code: irq code
1798 * 1798 *
1799 * Handles external interrupts coming in from CP. 1799 * Handles external interrupts coming in from CP.
1800 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn(). 1800 * Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().
1801 */ 1801 */
1802 static void iucv_external_interrupt(unsigned int ext_int_code, 1802 static void iucv_external_interrupt(unsigned int ext_int_code,
1803 unsigned int param32, unsigned long param64) 1803 unsigned int param32, unsigned long param64)
1804 { 1804 {
1805 struct iucv_irq_data *p; 1805 struct iucv_irq_data *p;
1806 struct iucv_irq_list *work; 1806 struct iucv_irq_list *work;
1807 1807
1808 kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++; 1808 kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++;
1809 p = iucv_irq_data[smp_processor_id()]; 1809 p = iucv_irq_data[smp_processor_id()];
1810 if (p->ippathid >= iucv_max_pathid) { 1810 if (p->ippathid >= iucv_max_pathid) {
1811 WARN_ON(p->ippathid >= iucv_max_pathid); 1811 WARN_ON(p->ippathid >= iucv_max_pathid);
1812 iucv_sever_pathid(p->ippathid, iucv_error_no_listener); 1812 iucv_sever_pathid(p->ippathid, iucv_error_no_listener);
1813 return; 1813 return;
1814 } 1814 }
1815 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09); 1815 BUG_ON(p->iptype < 0x01 || p->iptype > 0x09);
1816 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC); 1816 work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
1817 if (!work) { 1817 if (!work) {
1818 pr_warning("iucv_external_interrupt: out of memory\n"); 1818 pr_warning("iucv_external_interrupt: out of memory\n");
1819 return; 1819 return;
1820 } 1820 }
1821 memcpy(&work->data, p, sizeof(work->data)); 1821 memcpy(&work->data, p, sizeof(work->data));
1822 spin_lock(&iucv_queue_lock); 1822 spin_lock(&iucv_queue_lock);
1823 if (p->iptype == 0x01) { 1823 if (p->iptype == 0x01) {
1824 /* Path pending interrupt. */ 1824 /* Path pending interrupt. */
1825 list_add_tail(&work->list, &iucv_work_queue); 1825 list_add_tail(&work->list, &iucv_work_queue);
1826 schedule_work(&iucv_work); 1826 schedule_work(&iucv_work);
1827 } else { 1827 } else {
1828 /* The other interrupts. */ 1828 /* The other interrupts. */
1829 list_add_tail(&work->list, &iucv_task_queue); 1829 list_add_tail(&work->list, &iucv_task_queue);
1830 tasklet_schedule(&iucv_tasklet); 1830 tasklet_schedule(&iucv_tasklet);
1831 } 1831 }
1832 spin_unlock(&iucv_queue_lock); 1832 spin_unlock(&iucv_queue_lock);
1833 } 1833 }
1834 1834
1835 static int iucv_pm_prepare(struct device *dev) 1835 static int iucv_pm_prepare(struct device *dev)
1836 { 1836 {
1837 int rc = 0; 1837 int rc = 0;
1838 1838
1839 #ifdef CONFIG_PM_DEBUG 1839 #ifdef CONFIG_PM_DEBUG
1840 printk(KERN_INFO "iucv_pm_prepare\n"); 1840 printk(KERN_INFO "iucv_pm_prepare\n");
1841 #endif 1841 #endif
1842 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) 1842 if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)
1843 rc = dev->driver->pm->prepare(dev); 1843 rc = dev->driver->pm->prepare(dev);
1844 return rc; 1844 return rc;
1845 } 1845 }
1846 1846
1847 static void iucv_pm_complete(struct device *dev) 1847 static void iucv_pm_complete(struct device *dev)
1848 { 1848 {
1849 #ifdef CONFIG_PM_DEBUG 1849 #ifdef CONFIG_PM_DEBUG
1850 printk(KERN_INFO "iucv_pm_complete\n"); 1850 printk(KERN_INFO "iucv_pm_complete\n");
1851 #endif 1851 #endif
1852 if (dev->driver && dev->driver->pm && dev->driver->pm->complete) 1852 if (dev->driver && dev->driver->pm && dev->driver->pm->complete)
1853 dev->driver->pm->complete(dev); 1853 dev->driver->pm->complete(dev);
1854 } 1854 }
1855 1855
1856 /** 1856 /**
1857 * iucv_path_table_empty() - determine if iucv path table is empty 1857 * iucv_path_table_empty() - determine if iucv path table is empty
1858 * 1858 *
1859 * Returns 0 if there are still iucv pathes defined 1859 * Returns 0 if there are still iucv pathes defined
1860 * 1 if there are no iucv pathes defined 1860 * 1 if there are no iucv pathes defined
1861 */ 1861 */
1862 int iucv_path_table_empty(void) 1862 int iucv_path_table_empty(void)
1863 { 1863 {
1864 int i; 1864 int i;
1865 1865
1866 for (i = 0; i < iucv_max_pathid; i++) { 1866 for (i = 0; i < iucv_max_pathid; i++) {
1867 if (iucv_path_table[i]) 1867 if (iucv_path_table[i])
1868 return 0; 1868 return 0;
1869 } 1869 }
1870 return 1; 1870 return 1;
1871 } 1871 }
1872 1872
1873 /** 1873 /**
1874 * iucv_pm_freeze() - Freeze PM callback 1874 * iucv_pm_freeze() - Freeze PM callback
1875 * @dev: iucv-based device 1875 * @dev: iucv-based device
1876 * 1876 *
1877 * disable iucv interrupts 1877 * disable iucv interrupts
1878 * invoke callback function of the iucv-based driver 1878 * invoke callback function of the iucv-based driver
1879 * shut down iucv, if no iucv-pathes are established anymore 1879 * shut down iucv, if no iucv-pathes are established anymore
1880 */ 1880 */
1881 static int iucv_pm_freeze(struct device *dev) 1881 static int iucv_pm_freeze(struct device *dev)
1882 { 1882 {
1883 int cpu; 1883 int cpu;
1884 struct iucv_irq_list *p, *n; 1884 struct iucv_irq_list *p, *n;
1885 int rc = 0; 1885 int rc = 0;
1886 1886
1887 #ifdef CONFIG_PM_DEBUG 1887 #ifdef CONFIG_PM_DEBUG
1888 printk(KERN_WARNING "iucv_pm_freeze\n"); 1888 printk(KERN_WARNING "iucv_pm_freeze\n");
1889 #endif 1889 #endif
1890 if (iucv_pm_state != IUCV_PM_FREEZING) { 1890 if (iucv_pm_state != IUCV_PM_FREEZING) {
1891 for_each_cpu_mask_nr(cpu, iucv_irq_cpumask) 1891 for_each_cpu_mask_nr(cpu, iucv_irq_cpumask)
1892 smp_call_function_single(cpu, iucv_block_cpu_almost, 1892 smp_call_function_single(cpu, iucv_block_cpu_almost,
1893 NULL, 1); 1893 NULL, 1);
1894 cancel_work_sync(&iucv_work); 1894 cancel_work_sync(&iucv_work);
1895 list_for_each_entry_safe(p, n, &iucv_work_queue, list) { 1895 list_for_each_entry_safe(p, n, &iucv_work_queue, list) {
1896 list_del_init(&p->list); 1896 list_del_init(&p->list);
1897 iucv_sever_pathid(p->data.ippathid, 1897 iucv_sever_pathid(p->data.ippathid,
1898 iucv_error_no_listener); 1898 iucv_error_no_listener);
1899 kfree(p); 1899 kfree(p);
1900 } 1900 }
1901 } 1901 }
1902 iucv_pm_state = IUCV_PM_FREEZING; 1902 iucv_pm_state = IUCV_PM_FREEZING;
1903 if (dev->driver && dev->driver->pm && dev->driver->pm->freeze) 1903 if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)
1904 rc = dev->driver->pm->freeze(dev); 1904 rc = dev->driver->pm->freeze(dev);
1905 if (iucv_path_table_empty()) 1905 if (iucv_path_table_empty())
1906 iucv_disable(); 1906 iucv_disable();
1907 return rc; 1907 return rc;
1908 } 1908 }
1909 1909
1910 /** 1910 /**
1911 * iucv_pm_thaw() - Thaw PM callback 1911 * iucv_pm_thaw() - Thaw PM callback
1912 * @dev: iucv-based device 1912 * @dev: iucv-based device
1913 * 1913 *
1914 * make iucv ready for use again: allocate path table, declare interrupt buffers 1914 * make iucv ready for use again: allocate path table, declare interrupt buffers
1915 * and enable iucv interrupts 1915 * and enable iucv interrupts
1916 * invoke callback function of the iucv-based driver 1916 * invoke callback function of the iucv-based driver
1917 */ 1917 */
1918 static int iucv_pm_thaw(struct device *dev) 1918 static int iucv_pm_thaw(struct device *dev)
1919 { 1919 {
1920 int rc = 0; 1920 int rc = 0;
1921 1921
1922 #ifdef CONFIG_PM_DEBUG 1922 #ifdef CONFIG_PM_DEBUG
1923 printk(KERN_WARNING "iucv_pm_thaw\n"); 1923 printk(KERN_WARNING "iucv_pm_thaw\n");
1924 #endif 1924 #endif
1925 iucv_pm_state = IUCV_PM_THAWING; 1925 iucv_pm_state = IUCV_PM_THAWING;
1926 if (!iucv_path_table) { 1926 if (!iucv_path_table) {
1927 rc = iucv_enable(); 1927 rc = iucv_enable();
1928 if (rc) 1928 if (rc)
1929 goto out; 1929 goto out;
1930 } 1930 }
1931 if (cpus_empty(iucv_irq_cpumask)) { 1931 if (cpus_empty(iucv_irq_cpumask)) {
1932 if (iucv_nonsmp_handler) 1932 if (iucv_nonsmp_handler)
1933 /* enable interrupts on one cpu */ 1933 /* enable interrupts on one cpu */
1934 iucv_allow_cpu(NULL); 1934 iucv_allow_cpu(NULL);
1935 else 1935 else
1936 /* enable interrupts on all cpus */ 1936 /* enable interrupts on all cpus */
1937 iucv_setmask_mp(); 1937 iucv_setmask_mp();
1938 } 1938 }
1939 if (dev->driver && dev->driver->pm && dev->driver->pm->thaw) 1939 if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)
1940 rc = dev->driver->pm->thaw(dev); 1940 rc = dev->driver->pm->thaw(dev);
1941 out: 1941 out:
1942 return rc; 1942 return rc;
1943 } 1943 }
1944 1944
1945 /** 1945 /**
1946 * iucv_pm_restore() - Restore PM callback 1946 * iucv_pm_restore() - Restore PM callback
1947 * @dev: iucv-based device 1947 * @dev: iucv-based device
1948 * 1948 *
1949 * make iucv ready for use again: allocate path table, declare interrupt buffers 1949 * make iucv ready for use again: allocate path table, declare interrupt buffers
1950 * and enable iucv interrupts 1950 * and enable iucv interrupts
1951 * invoke callback function of the iucv-based driver 1951 * invoke callback function of the iucv-based driver
1952 */ 1952 */
1953 static int iucv_pm_restore(struct device *dev) 1953 static int iucv_pm_restore(struct device *dev)
1954 { 1954 {
1955 int rc = 0; 1955 int rc = 0;
1956 1956
1957 #ifdef CONFIG_PM_DEBUG 1957 #ifdef CONFIG_PM_DEBUG
1958 printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table); 1958 printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);
1959 #endif 1959 #endif
1960 if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table) 1960 if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)
1961 pr_warning("Suspending Linux did not completely close all IUCV " 1961 pr_warning("Suspending Linux did not completely close all IUCV "
1962 "connections\n"); 1962 "connections\n");
1963 iucv_pm_state = IUCV_PM_RESTORING; 1963 iucv_pm_state = IUCV_PM_RESTORING;
1964 if (cpus_empty(iucv_irq_cpumask)) { 1964 if (cpus_empty(iucv_irq_cpumask)) {
1965 rc = iucv_query_maxconn(); 1965 rc = iucv_query_maxconn();
1966 rc = iucv_enable(); 1966 rc = iucv_enable();
1967 if (rc) 1967 if (rc)
1968 goto out; 1968 goto out;
1969 } 1969 }
1970 if (dev->driver && dev->driver->pm && dev->driver->pm->restore) 1970 if (dev->driver && dev->driver->pm && dev->driver->pm->restore)
1971 rc = dev->driver->pm->restore(dev); 1971 rc = dev->driver->pm->restore(dev);
1972 out: 1972 out:
1973 return rc; 1973 return rc;
1974 } 1974 }
1975 1975
1976 /** 1976 /**
1977 * iucv_init 1977 * iucv_init
1978 * 1978 *
1979 * Allocates and initializes various data structures. 1979 * Allocates and initializes various data structures.
1980 */ 1980 */
1981 static int __init iucv_init(void) 1981 static int __init iucv_init(void)
1982 { 1982 {
1983 int rc; 1983 int rc;
1984 int cpu; 1984 int cpu;
1985 1985
1986 if (!MACHINE_IS_VM) { 1986 if (!MACHINE_IS_VM) {
1987 rc = -EPROTONOSUPPORT; 1987 rc = -EPROTONOSUPPORT;
1988 goto out; 1988 goto out;
1989 } 1989 }
1990 rc = iucv_query_maxconn(); 1990 rc = iucv_query_maxconn();
1991 if (rc) 1991 if (rc)
1992 goto out; 1992 goto out;
1993 rc = register_external_interrupt(0x4000, iucv_external_interrupt); 1993 rc = register_external_interrupt(0x4000, iucv_external_interrupt);
1994 if (rc) 1994 if (rc)
1995 goto out; 1995 goto out;
1996 iucv_root = root_device_register("iucv"); 1996 iucv_root = root_device_register("iucv");
1997 if (IS_ERR(iucv_root)) { 1997 if (IS_ERR(iucv_root)) {
1998 rc = PTR_ERR(iucv_root); 1998 rc = PTR_ERR(iucv_root);
1999 goto out_int; 1999 goto out_int;
2000 } 2000 }
2001 2001
2002 for_each_online_cpu(cpu) { 2002 for_each_online_cpu(cpu) {
2003 /* Note: GFP_DMA used to get memory below 2G */ 2003 /* Note: GFP_DMA used to get memory below 2G */
2004 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data), 2004 iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
2005 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2005 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2006 if (!iucv_irq_data[cpu]) { 2006 if (!iucv_irq_data[cpu]) {
2007 rc = -ENOMEM; 2007 rc = -ENOMEM;
2008 goto out_free; 2008 goto out_free;
2009 } 2009 }
2010 2010
2011 /* Allocate parameter blocks. */ 2011 /* Allocate parameter blocks. */
2012 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param), 2012 iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
2013 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2013 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2014 if (!iucv_param[cpu]) { 2014 if (!iucv_param[cpu]) {
2015 rc = -ENOMEM; 2015 rc = -ENOMEM;
2016 goto out_free; 2016 goto out_free;
2017 } 2017 }
2018 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param), 2018 iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
2019 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu)); 2019 GFP_KERNEL|GFP_DMA, cpu_to_node(cpu));
2020 if (!iucv_param_irq[cpu]) { 2020 if (!iucv_param_irq[cpu]) {
2021 rc = -ENOMEM; 2021 rc = -ENOMEM;
2022 goto out_free; 2022 goto out_free;
2023 } 2023 }
2024 2024
2025 } 2025 }
2026 rc = register_hotcpu_notifier(&iucv_cpu_notifier); 2026 rc = register_hotcpu_notifier(&iucv_cpu_notifier);
2027 if (rc) 2027 if (rc)
2028 goto out_free; 2028 goto out_free;
2029 rc = register_reboot_notifier(&iucv_reboot_notifier); 2029 rc = register_reboot_notifier(&iucv_reboot_notifier);
2030 if (rc) 2030 if (rc)
2031 goto out_cpu; 2031 goto out_cpu;
2032 ASCEBC(iucv_error_no_listener, 16); 2032 ASCEBC(iucv_error_no_listener, 16);
2033 ASCEBC(iucv_error_no_memory, 16); 2033 ASCEBC(iucv_error_no_memory, 16);
2034 ASCEBC(iucv_error_pathid, 16); 2034 ASCEBC(iucv_error_pathid, 16);
2035 iucv_available = 1; 2035 iucv_available = 1;
2036 rc = bus_register(&iucv_bus); 2036 rc = bus_register(&iucv_bus);
2037 if (rc) 2037 if (rc)
2038 goto out_reboot; 2038 goto out_reboot;
2039 return 0; 2039 return 0;
2040 2040
2041 out_reboot: 2041 out_reboot:
2042 unregister_reboot_notifier(&iucv_reboot_notifier); 2042 unregister_reboot_notifier(&iucv_reboot_notifier);
2043 out_cpu: 2043 out_cpu:
2044 unregister_hotcpu_notifier(&iucv_cpu_notifier); 2044 unregister_hotcpu_notifier(&iucv_cpu_notifier);
2045 out_free: 2045 out_free:
2046 for_each_possible_cpu(cpu) { 2046 for_each_possible_cpu(cpu) {
2047 kfree(iucv_param_irq[cpu]); 2047 kfree(iucv_param_irq[cpu]);
2048 iucv_param_irq[cpu] = NULL; 2048 iucv_param_irq[cpu] = NULL;
2049 kfree(iucv_param[cpu]); 2049 kfree(iucv_param[cpu]);
2050 iucv_param[cpu] = NULL; 2050 iucv_param[cpu] = NULL;
2051 kfree(iucv_irq_data[cpu]); 2051 kfree(iucv_irq_data[cpu]);
2052 iucv_irq_data[cpu] = NULL; 2052 iucv_irq_data[cpu] = NULL;
2053 } 2053 }
2054 root_device_unregister(iucv_root); 2054 root_device_unregister(iucv_root);
2055 out_int: 2055 out_int:
2056 unregister_external_interrupt(0x4000, iucv_external_interrupt); 2056 unregister_external_interrupt(0x4000, iucv_external_interrupt);
2057 out: 2057 out:
2058 return rc; 2058 return rc;
2059 } 2059 }
2060 2060
2061 /** 2061 /**
2062 * iucv_exit 2062 * iucv_exit
2063 * 2063 *
2064 * Frees everything allocated from iucv_init. 2064 * Frees everything allocated from iucv_init.
2065 */ 2065 */
2066 static void __exit iucv_exit(void) 2066 static void __exit iucv_exit(void)
2067 { 2067 {
2068 struct iucv_irq_list *p, *n; 2068 struct iucv_irq_list *p, *n;
2069 int cpu; 2069 int cpu;
2070 2070
2071 spin_lock_irq(&iucv_queue_lock); 2071 spin_lock_irq(&iucv_queue_lock);
2072 list_for_each_entry_safe(p, n, &iucv_task_queue, list) 2072 list_for_each_entry_safe(p, n, &iucv_task_queue, list)
2073 kfree(p); 2073 kfree(p);
2074 list_for_each_entry_safe(p, n, &iucv_work_queue, list) 2074 list_for_each_entry_safe(p, n, &iucv_work_queue, list)
2075 kfree(p); 2075 kfree(p);
2076 spin_unlock_irq(&iucv_queue_lock); 2076 spin_unlock_irq(&iucv_queue_lock);
2077 unregister_reboot_notifier(&iucv_reboot_notifier); 2077 unregister_reboot_notifier(&iucv_reboot_notifier);
2078 unregister_hotcpu_notifier(&iucv_cpu_notifier); 2078 unregister_hotcpu_notifier(&iucv_cpu_notifier);
2079 for_each_possible_cpu(cpu) { 2079 for_each_possible_cpu(cpu) {
2080 kfree(iucv_param_irq[cpu]); 2080 kfree(iucv_param_irq[cpu]);
2081 iucv_param_irq[cpu] = NULL; 2081 iucv_param_irq[cpu] = NULL;
2082 kfree(iucv_param[cpu]); 2082 kfree(iucv_param[cpu]);
2083 iucv_param[cpu] = NULL; 2083 iucv_param[cpu] = NULL;
2084 kfree(iucv_irq_data[cpu]); 2084 kfree(iucv_irq_data[cpu]);
2085 iucv_irq_data[cpu] = NULL; 2085 iucv_irq_data[cpu] = NULL;
2086 } 2086 }
2087 root_device_unregister(iucv_root); 2087 root_device_unregister(iucv_root);
2088 bus_unregister(&iucv_bus); 2088 bus_unregister(&iucv_bus);
2089 unregister_external_interrupt(0x4000, iucv_external_interrupt); 2089 unregister_external_interrupt(0x4000, iucv_external_interrupt);
2090 } 2090 }
2091 2091
2092 subsys_initcall(iucv_init); 2092 subsys_initcall(iucv_init);
2093 module_exit(iucv_exit); 2093 module_exit(iucv_exit);
2094 2094
2095 MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)"); 2095 MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2096 MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver"); 2096 MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2097 MODULE_LICENSE("GPL"); 2097 MODULE_LICENSE("GPL");
2098 2098