net/iucv/iucv.c

   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 ("0");
 326         register unsigned long reg1 asm ("1");
 327         int ccode;
 328
 329         reg0 = command;
 330         reg1 = virt_to_phys(parm);
 331         asm volatile(
 332                 "       .long 0xb2f01000\n"
 333                 "       ipm     %0\n"
 334                 "       srl     %0,28\n"
 335                 : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)
 336                 :  "m" (*parm) : "cc");
 337         return (ccode == 1) ? parm->ctrl.iprcode : ccode;
 338 }
 339
 340 /**
 341  * iucv_query_maxconn
 342  *
 343  * Determines the maximum number of connections that may be established.
 344  *
 345  * Returns the maximum number of connections or -EPERM is IUCV is not
 346  * available.
 347  */
 348 static int iucv_query_maxconn(void)
 349 {
 350         register unsigned long reg0 asm ("0");
 351         register unsigned long reg1 asm ("1");
 352         void *param;
 353         int ccode;
 354
 355         param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA);
 356         if (!param)
 357                 return -ENOMEM;
 358         reg0 = IUCV_QUERY;
 359         reg1 = (unsigned long) param;
 360         asm volatile (
 361                 "       .long   0xb2f01000\n"
 362                 "       ipm     %0\n"
 363                 "       srl     %0,28\n"
 364                 : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
 365         if (ccode == 0)
 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 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");