~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/iucv/iucv.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp