linux/net/iucv/iucv.c
<<
>>
Prefs
   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
  78static int iucv_bus_match(struct device *dev, struct device_driver *drv)
  79{
  80        return 0;
  81}
  82
  83enum iucv_pm_states {
  84        IUCV_PM_INITIAL = 0,
  85        IUCV_PM_FREEZING = 1,
  86        IUCV_PM_THAWING = 2,
  87        IUCV_PM_RESTORING = 3,
  88};
  89static enum iucv_pm_states iucv_pm_state;
  90
  91static int iucv_pm_prepare(struct device *);
  92static void iucv_pm_complete(struct device *);
  93static int iucv_pm_freeze(struct device *);
  94static int iucv_pm_thaw(struct device *);
  95static int iucv_pm_restore(struct device *);
  96
  97static 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
 105struct bus_type iucv_bus = {
 106        .name = "iucv",
 107        .match = iucv_bus_match,
 108        .pm = &iucv_pm_ops,
 109};
 110EXPORT_SYMBOL(iucv_bus);
 111
 112struct device *iucv_root;
 113EXPORT_SYMBOL(iucv_root);
 114
 115static int iucv_available;
 116
 117/* General IUCV interrupt structure */
 118struct iucv_irq_data {
 119        u16 ippathid;
 120        u8  ipflags1;
 121        u8  iptype;
 122        u32 res2[8];
 123};
 124
 125struct iucv_irq_list {
 126        struct list_head list;
 127        struct iucv_irq_data data;
 128};
 129
 130static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
 131static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE };
 132static 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 */
 138static LIST_HEAD(iucv_task_queue);
 139
 140/*
 141 * The tasklet for fast delivery of iucv interrupts.
 142 */
 143static void iucv_tasklet_fn(unsigned long);
 144static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0);
 145
 146/*
 147 * Queue of interrupt buffers for delivery via a work queue
 148 * (slower but can call smp_call_function).
 149 */
 150static LIST_HEAD(iucv_work_queue);
 151
 152/*
 153 * The work element to deliver path pending interrupts.
 154 */
 155static void iucv_work_fn(struct work_struct *work);
 156static DECLARE_WORK(iucv_work, iucv_work_fn);
 157
 158/*
 159 * Spinlock protecting task and work queue.
 160 */
 161static DEFINE_SPINLOCK(iucv_queue_lock);
 162
 163enum iucv_command_codes {
 164        IUCV_QUERY = 0,
 165        IUCV_RETRIEVE_BUFFER = 2,
 166        IUCV_SEND = 4,
 167        IUCV_RECEIVE = 5,
 168        IUCV_REPLY = 6,
 169        IUCV_REJECT = 8,
 170        IUCV_PURGE = 9,
 171        IUCV_ACCEPT = 10,
 172        IUCV_CONNECT = 11,
 173        IUCV_DECLARE_BUFFER = 12,
 174        IUCV_QUIESCE = 13,
 175        IUCV_RESUME = 14,
 176        IUCV_SEVER = 15,
 177        IUCV_SETMASK = 16,
 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 */
 185static char iucv_error_no_listener[16] = "NO LISTENER";
 186static char iucv_error_no_memory[16] = "NO MEMORY";
 187static char iucv_error_pathid[16] = "INVALID PATHID";
 188
 189/*
 190 * iucv_handler_list: List of registered handlers.
 191 */
 192static LIST_HEAD(iucv_handler_list);
 193
 194/*
 195 * iucv_path_table: an array of iucv_path structures.
 196 */
 197static struct iucv_path **iucv_path_table;
 198static unsigned long iucv_max_pathid;
 199
 200/*
 201 * iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table
 202 */
 203static DEFINE_SPINLOCK(iucv_table_lock);
 204
 205/*
 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 */
 209static int iucv_active_cpu = -1;
 210
 211/*
 212 * Mutex and wait queue for iucv_register/iucv_unregister.
 213 */
 214static DEFINE_MUTEX(iucv_register_mutex);
 215
 216/*
 217 * Counter for number of non-smp capable handlers.
 218 */
 219static int iucv_nonsmp_handler;
 220
 221/*
 222 * IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,
 223 * iucv_path_quiesce and iucv_path_sever.
 224 */
 225struct iucv_cmd_control {
 226        u16 ippathid;
 227        u8  ipflags1;
 228        u8  iprcode;
 229        u16 ipmsglim;
 230        u16 res1;
 231        u8  ipvmid[8];
 232        u8  ipuser[16];
 233        u8  iptarget[8];
 234} __attribute__ ((packed,aligned(8)));
 235
 236/*
 237 * Data in parameter list iucv structure. Used by iucv_message_send,
 238 * iucv_message_send2way and iucv_message_reply.
 239 */
 240struct iucv_cmd_dpl {
 241        u16 ippathid;
 242        u8  ipflags1;
 243        u8  iprcode;
 244        u32 ipmsgid;
 245        u32 iptrgcls;
 246        u8  iprmmsg[8];
 247        u32 ipsrccls;
 248        u32 ipmsgtag;
 249        u32 ipbfadr2;
 250        u32 ipbfln2f;
 251        u32 res;
 252} __attribute__ ((packed,aligned(8)));
 253
 254/*
 255 * Data in buffer iucv structure. Used by iucv_message_receive,
 256 * iucv_message_reject, iucv_message_send, iucv_message_send2way
 257 * and iucv_declare_cpu.
 258 */
 259struct iucv_cmd_db {
 260        u16 ippathid;
 261        u8  ipflags1;
 262        u8  iprcode;
 263        u32 ipmsgid;
 264        u32 iptrgcls;
 265        u32 ipbfadr1;
 266        u32 ipbfln1f;
 267        u32 ipsrccls;
 268        u32 ipmsgtag;
 269        u32 ipbfadr2;
 270        u32 ipbfln2f;
 271        u32 res;
 272} __attribute__ ((packed,aligned(8)));
 273
 274/*
 275 * Purge message iucv structure. Used by iucv_message_purge.
 276 */
 277struct iucv_cmd_purge {
 278        u16 ippathid;
 279        u8  ipflags1;
 280        u8  iprcode;
 281        u32 ipmsgid;
 282        u8  ipaudit[3];
 283        u8  res1[5];
 284        u32 res2;
 285        u32 ipsrccls;
 286        u32 ipmsgtag;
 287        u32 res3[3];
 288} __attribute__ ((packed,aligned(8)));
 289
 290/*
 291 * Set mask iucv structure. Used by iucv_enable_cpu.
 292 */
 293struct iucv_cmd_set_mask {
 294        u8  ipmask;
 295        u8  res1[2];
 296        u8  iprcode;
 297        u32 res2[9];
 298} __attribute__ ((packed,aligned(8)));
 299
 300union iucv_param {
 301        struct iucv_cmd_control ctrl;
 302        struct iucv_cmd_dpl dpl;
 303        struct iucv_cmd_db db;
 304        struct iucv_cmd_purge purge;
 305        struct iucv_cmd_set_mask set_mask;
 306};
 307
 308/*
 309 * Anchor for per-cpu IUCV command parameter block.
 310 */
 311static union iucv_param *iucv_param[NR_CPUS];
 312static 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 */
 323static inline int iucv_call_b2f0(int command, union iucv_param *parm)
 324{
 325        register unsigned long reg0 asm ("0");
 326        register unsigned long reg1 asm ("1");
 327        int ccode;
 328
 329        reg0 = command;
 330        reg1 = virt_to_phys(parm);
 331        asm volatile(
 332                "       .long 0xb2f01000\n"
 333                "       ipm     %0\n"
 334                "       srl     %0,28\n"
 335                : "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)
 336                :  "m" (*parm) : "cc");
 337        return (ccode == 1) ? parm->ctrl.iprcode : ccode;
 338}
 339
 340/**
 341 * iucv_query_maxconn
 342 *
 343 * Determines the maximum number of connections that may be established.
 344 *
 345 * Returns the maximum number of connections or -EPERM is IUCV is not
 346 * available.
 347 */
 348static int iucv_query_maxconn(void)
 349{
 350        register unsigned long reg0 asm ("0");
 351        register unsigned long reg1 asm ("1");
 352        void *param;
 353        int ccode;
 354
 355        param = kzalloc(sizeof(union iucv_param), GFP_KERNEL|GFP_DMA);
 356        if (!param)
 357                return -ENOMEM;
 358        reg0 = IUCV_QUERY;
 359        reg1 = (unsigned long) param;
 360        asm volatile (
 361                "       .long   0xb2f01000\n"
 362                "       ipm     %0\n"
 363                "       srl     %0,28\n"
 364                : "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
 365        if (ccode == 0)
 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 */
 377static void iucv_allow_cpu(void *data)
 378{
 379        int cpu = smp_processor_id();
 380        union iucv_param *parm;
 381
 382        /*
 383         * Enable all iucv interrupts.
 384         * ipmask contains bits for the different interrupts
 385         *      0x80 - Flag to allow nonpriority message pending interrupts
 386         *      0x40 - Flag to allow priority message pending interrupts
 387         *      0x20 - Flag to allow nonpriority message completion interrupts
 388         *      0x10 - Flag to allow priority message completion interrupts
 389         *      0x08 - Flag to allow IUCV control interrupts
 390         */
 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 */
 418static void iucv_block_cpu(void *data)
 419{
 420        int cpu = smp_processor_id();
 421        union iucv_param *parm;
 422
 423        /* Disable all iucv interrupts. */
 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 */
 438static void iucv_block_cpu_almost(void *data)
 439{
 440        int cpu = smp_processor_id();
 441        union iucv_param *parm;
 442
 443        /* Allow iucv control interrupts only */
 444        parm = iucv_param_irq[cpu];
 445        memset(parm, 0, sizeof(union iucv_param));
 446        parm->set_mask.ipmask = 0x08;
 447        iucv_call_b2f0(IUCV_SETMASK, parm);
 448        /* Allow iucv-severed interrupt only */
 449        memset(parm, 0, sizeof(union iucv_param));
 450        parm->set_mask.ipmask = 0x20;
 451        iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
 452
 453        /* Clear indication that iucv interrupts are allowed for this cpu. */
 454        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 */
 463static void iucv_declare_cpu(void *data)
 464{
 465        int cpu = smp_processor_id();
 466        union iucv_param *parm;
 467        int rc;
 468
 469        if (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 */
 518static 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 */
 542static 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 */
 561static void iucv_setmask_up(void)
 562{
 563        cpumask_t cpumask;
 564        int cpu;
 565
 566        /* Disable all cpu but the first in cpu_irq_cpumask. */
 567        cpumask_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 */
 581static 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;
 601out:
 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 */
 615static 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
 624static 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
 693static 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 */
 704static 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 */
 723static 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 */
 734static 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 */
 769int 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;
 790out_mutex:
 791        mutex_unlock(&iucv_register_mutex);
 792        return rc;
 793}
 794EXPORT_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 */
 803void 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}
 827EXPORT_SYMBOL(iucv_unregister);
 828
 829static 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
 850static 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 */
 866int 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        }
 892out:
 893        local_bh_enable();
 894        return rc;
 895}
 896EXPORT_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 */
 913int 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        }
 960out:
 961        spin_unlock_bh(&iucv_table_lock);
 962        return rc;
 963}
 964EXPORT_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 */
 976int 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);
 992out:
 993        local_bh_enable();
 994        return rc;
 995}
 996EXPORT_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 */
1008int 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);
1024out:
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 */
1038int 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);
1054out:
1055        preempt_enable();
1056        return rc;
1057}
1058EXPORT_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 */
1070int 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        }
1092out:
1093        local_bh_enable();
1094        return rc;
1095}
1096EXPORT_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 */
1110static 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 */
1160int __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        }
1188out:
1189        return rc;
1190}
1191EXPORT_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 */
1210int 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}
1223EXPORT_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 */
1236int 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);
1253out:
1254        local_bh_enable();
1255        return rc;
1256}
1257EXPORT_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 */
1274int 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);
1302out:
1303        local_bh_enable();
1304        return rc;
1305}
1306EXPORT_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 */
1325int __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;
1357out:
1358        return rc;
1359}
1360EXPORT_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 */
1379int 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}
1389EXPORT_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 */
1410int 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;
1447out:
1448        local_bh_enable();
1449        return rc;
1450}
1451EXPORT_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 */
1460struct 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
1473static 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;
1510out_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 */
1521struct 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
1534static 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 */
1552struct 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
1564static 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 */
1588struct 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
1600static 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 */
1616struct 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
1628static 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 */
1644struct 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
1659static 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 */
1684struct 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
1704static 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 */
1731static 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 */
1775static 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 */
1806static 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
1839static 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
1851static 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 */
1866int 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 */
1885static 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 */
1922static 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);
1945out:
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 */
1957static 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);
1976out:
1977        return rc;
1978}
1979
1980struct 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};
1999EXPORT_SYMBOL(iucv_if);
2000
2001/**
2002 * iucv_init
2003 *
2004 * Allocates and initializes various data structures.
2005 */
2006static 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
2069out_reboot:
2070        unregister_reboot_notifier(&iucv_reboot_notifier);
2071out_cpu:
2072        unregister_hotcpu_notifier(&iucv_cpu_notifier);
2073out_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);
2083out_int:
2084        unregister_external_interrupt(0x4000, iucv_external_interrupt);
2085out_ctl:
2086        ctl_clear_bit(0, 1);
2087out:
2088        return rc;
2089}
2090
2091/**
2092 * iucv_exit
2093 *
2094 * Frees everything allocated from iucv_init.
2095 */
2096static 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
2122subsys_initcall(iucv_init);
2123module_exit(iucv_exit);
2124
2125MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2126MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2127MODULE_LICENSE("GPL");
2128
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.