drivers/s390/cio/chsc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *   S/390 common I/O routines -- channel subsystem call
   4  *
   5  *    Copyright IBM Corp. 1999,2012
   6  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
   7  *               Cornelia Huck (cornelia.huck@de.ibm.com)
   8  *               Arnd Bergmann (arndb@de.ibm.com)
   9  */
  10
  11 #define KMSG_COMPONENT "cio"
  12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  13
  14 #include <linux/module.h>
  15 #include <linux/slab.h>
  16 #include <linux/init.h>
  17 #include <linux/device.h>
  18 #include <linux/mutex.h>
  19 #include <linux/pci.h>
  20
  21 #include <asm/cio.h>
  22 #include <asm/chpid.h>
  23 #include <asm/chsc.h>
  24 #include <asm/crw.h>
  25 #include <asm/isc.h>
  26 #include <asm/ebcdic.h>
  27 #include <asm/ap.h>
  28
  29 #include "css.h"
  30 #include "cio.h"
  31 #include "cio_debug.h"
  32 #include "ioasm.h"
  33 #include "chp.h"
  34 #include "chsc.h"
  35
  36 static void *sei_page;
  37 static void *chsc_page;
  38 static DEFINE_SPINLOCK(chsc_page_lock);
  39
  40 #define SEI_VF_FLA      0xc0 /* VF flag for Full Link Address */
  41 #define SEI_RS_CHPID    0x4  /* 4 in RS field indicates CHPID */
  42
  43 /**
  44  * chsc_error_from_response() - convert a chsc response to an error
  45  * @response: chsc response code
  46  *
  47  * Returns an appropriate Linux error code for @response.
  48  */
  49 int chsc_error_from_response(int response)
  50 {
  51         switch (response) {
  52         case 0x0001:
  53                 return 0;
  54         case 0x0002:
  55         case 0x0003:
  56         case 0x0006:
  57         case 0x0007:
  58         case 0x0008:
  59         case 0x000a:
  60         case 0x0104:
  61                 return -EINVAL;
  62         case 0x0004:
  63         case 0x0106:            /* "Wrong Channel Parm" for the op 0x003d */
  64                 return -EOPNOTSUPP;
  65         case 0x000b:
  66         case 0x0107:            /* "Channel busy" for the op 0x003d */
  67                 return -EBUSY;
  68         case 0x0100:
  69         case 0x0102:
  70                 return -ENOMEM;
  71         case 0x0108:            /* "HW limit exceeded" for the op 0x003d */
  72                 return -EUSERS;
  73         default:
  74                 return -EIO;
  75         }
  76 }
  77 EXPORT_SYMBOL_GPL(chsc_error_from_response);
  78
  79 struct chsc_ssd_area {
  80         struct chsc_header request;
  81         u16 :10;
  82         u16 ssid:2;
  83         u16 :4;
  84         u16 f_sch;        /* first subchannel */
  85         u16 :16;
  86         u16 l_sch;        /* last subchannel */
  87         u32 :32;
  88         struct chsc_header response;
  89         u32 :32;
  90         u8 sch_valid : 1;
  91         u8 dev_valid : 1;
  92         u8 st        : 3; /* subchannel type */
  93         u8 zeroes    : 3;
  94         u8  unit_addr;    /* unit address */
  95         u16 devno;        /* device number */
  96         u8 path_mask;
  97         u8 fla_valid_mask;
  98         u16 sch;          /* subchannel */
  99         u8 chpid[8];      /* chpids 0-7 */
 100         u16 fla[8];       /* full link addresses 0-7 */
 101 } __packed __aligned(PAGE_SIZE);
 102
 103 int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
 104 {
 105         struct chsc_ssd_area *ssd_area;
 106         unsigned long flags;
 107         int ccode;
 108         int ret;
 109         int i;
 110         int mask;
 111
 112         spin_lock_irqsave(&chsc_page_lock, flags);
 113         memset(chsc_page, 0, PAGE_SIZE);
 114         ssd_area = chsc_page;
 115         ssd_area->request.length = 0x0010;
 116         ssd_area->request.code = 0x0004;
 117         ssd_area->ssid = schid.ssid;
 118         ssd_area->f_sch = schid.sch_no;
 119         ssd_area->l_sch = schid.sch_no;
 120
 121         ccode = chsc(ssd_area);
 122         /* Check response. */
 123         if (ccode > 0) {
 124                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
 125                 goto out;
 126         }
 127         ret = chsc_error_from_response(ssd_area->response.code);
 128         if (ret != 0) {
 129                 CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
 130                               schid.ssid, schid.sch_no,
 131                               ssd_area->response.code);
 132                 goto out;
 133         }
 134         if (!ssd_area->sch_valid) {
 135                 ret = -ENODEV;
 136                 goto out;
 137         }
 138         /* Copy data */
 139         ret = 0;
 140         memset(ssd, 0, sizeof(struct chsc_ssd_info));
 141         if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
 142             (ssd_area->st != SUBCHANNEL_TYPE_MSG))
 143                 goto out;
 144         ssd->path_mask = ssd_area->path_mask;
 145         ssd->fla_valid_mask = ssd_area->fla_valid_mask;
 146         for (i = 0; i < 8; i++) {
 147                 mask = 0x80 >> i;
 148                 if (ssd_area->path_mask & mask) {
 149                         chp_id_init(&ssd->chpid[i]);
 150                         ssd->chpid[i].id = ssd_area->chpid[i];
 151                 }
 152                 if (ssd_area->fla_valid_mask & mask)
 153                         ssd->fla[i] = ssd_area->fla[i];
 154         }
 155 out:
 156         spin_unlock_irqrestore(&chsc_page_lock, flags);
 157         return ret;
 158 }
 159
 160 /**
 161  * chsc_ssqd() - store subchannel QDIO data (SSQD)
 162  * @schid: id of the subchannel on which SSQD is performed
 163  * @ssqd: request and response block for SSQD
 164  *
 165  * Returns 0 on success.
 166  */
 167 int chsc_ssqd(struct subchannel_id schid, struct chsc_ssqd_area *ssqd)
 168 {
 169         memset(ssqd, 0, sizeof(*ssqd));
 170         ssqd->request.length = 0x0010;
 171         ssqd->request.code = 0x0024;
 172         ssqd->first_sch = schid.sch_no;
 173         ssqd->last_sch = schid.sch_no;
 174         ssqd->ssid = schid.ssid;
 175
 176         if (chsc(ssqd))
 177                 return -EIO;
 178
 179         return chsc_error_from_response(ssqd->response.code);
 180 }
 181 EXPORT_SYMBOL_GPL(chsc_ssqd);
 182
 183 /**
 184  * chsc_sadc() - set adapter device controls (SADC)
 185  * @schid: id of the subchannel on which SADC is performed
 186  * @scssc: request and response block for SADC
 187  * @summary_indicator_addr: summary indicator address
 188  * @subchannel_indicator_addr: subchannel indicator address
 189  * @isc: Interruption Subclass for this subchannel
 190  *
 191  * Returns 0 on success.
 192  */
 193 int chsc_sadc(struct subchannel_id schid, struct chsc_scssc_area *scssc,
 194               u64 summary_indicator_addr, u64 subchannel_indicator_addr, u8 isc)
 195 {
 196         memset(scssc, 0, sizeof(*scssc));
 197         scssc->request.length = 0x0fe0;
 198         scssc->request.code = 0x0021;
 199         scssc->operation_code = 0;
 200
 201         scssc->summary_indicator_addr = summary_indicator_addr;
 202         scssc->subchannel_indicator_addr = subchannel_indicator_addr;
 203
 204         scssc->ks = PAGE_DEFAULT_KEY >> 4;
 205         scssc->kc = PAGE_DEFAULT_KEY >> 4;
 206         scssc->isc = isc;
 207         scssc->schid = schid;
 208
 209         /* enable the time delay disablement facility */
 210         if (css_general_characteristics.aif_tdd)
 211                 scssc->word_with_d_bit = 0x10000000;
 212
 213         if (chsc(scssc))
 214                 return -EIO;
 215
 216         return chsc_error_from_response(scssc->response.code);
 217 }
 218 EXPORT_SYMBOL_GPL(chsc_sadc);
 219
 220 static int s390_subchannel_remove_chpid(struct subchannel *sch, void *data)
 221 {
 222         spin_lock_irq(sch->lock);
 223         if (sch->driver && sch->driver->chp_event)
 224                 if (sch->driver->chp_event(sch, data, CHP_OFFLINE) != 0)
 225                         goto out_unreg;
 226         spin_unlock_irq(sch->lock);
 227         return 0;
 228
 229 out_unreg:
 230         sch->lpm = 0;
 231         spin_unlock_irq(sch->lock);
 232         css_schedule_eval(sch->schid);
 233         return 0;
 234 }
 235
 236 void chsc_chp_offline(struct chp_id chpid)
 237 {
 238         struct channel_path *chp = chpid_to_chp(chpid);
 239         struct chp_link link;
 240         char dbf_txt[15];
 241
 242         sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);
 243         CIO_TRACE_EVENT(2, dbf_txt);
 244
 245         if (chp_get_status(chpid) <= 0)
 246                 return;
 247         memset(&link, 0, sizeof(struct chp_link));
 248         link.chpid = chpid;
 249         /* Wait until previous actions have settled. */
 250         css_wait_for_slow_path();
 251
 252         mutex_lock(&chp->lock);
 253         chp_update_desc(chp);
 254         mutex_unlock(&chp->lock);
 255
 256         for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &link);
 257 }
 258
 259 static int __s390_process_res_acc(struct subchannel *sch, void *data)
 260 {
 261         spin_lock_irq(sch->lock);
 262         if (sch->driver && sch->driver->chp_event)
 263                 sch->driver->chp_event(sch, data, CHP_ONLINE);
 264         spin_unlock_irq(sch->lock);
 265
 266         return 0;
 267 }
 268
 269 static void s390_process_res_acc(struct chp_link *link)
 270 {
 271         char dbf_txt[15];
 272
 273         sprintf(dbf_txt, "accpr%x.%02x", link->chpid.cssid,
 274                 link->chpid.id);
 275         CIO_TRACE_EVENT( 2, dbf_txt);
 276         if (link->fla != 0) {
 277                 sprintf(dbf_txt, "fla%x", link->fla);
 278                 CIO_TRACE_EVENT( 2, dbf_txt);
 279         }
 280         /* Wait until previous actions have settled. */
 281         css_wait_for_slow_path();
 282         /*
 283          * I/O resources may have become accessible.
 284          * Scan through all subchannels that may be concerned and
 285          * do a validation on those.
 286          * The more information we have (info), the less scanning
 287          * will we have to do.
 288          */
 289         for_each_subchannel_staged(__s390_process_res_acc, NULL, link);
 290         css_schedule_reprobe();
 291 }
 292
 293 static int process_fces_event(struct subchannel *sch, void *data)
 294 {
 295         spin_lock_irq(sch->lock);
 296         if (sch->driver && sch->driver->chp_event)
 297                 sch->driver->chp_event(sch, data, CHP_FCES_EVENT);
 298         spin_unlock_irq(sch->lock);
 299         return 0;
 300 }
 301
 302 struct chsc_sei_nt0_area {
 303         u8  flags;
 304         u8  vf;                         /* validity flags */
 305         u8  rs;                         /* reporting source */
 306         u8  cc;                         /* content code */
 307         u16 fla;                        /* full link address */
 308         u16 rsid;                       /* reporting source id */
 309         u32 reserved1;
 310         u32 reserved2;
 311         /* ccdf has to be big enough for a link-incident record */
 312         u8  ccdf[PAGE_SIZE - 24 - 16];  /* content-code dependent field */
 313 } __packed;
 314
 315 struct chsc_sei_nt2_area {
 316         u8  flags;                      /* p and v bit */
 317         u8  reserved1;
 318         u8  reserved2;
 319         u8  cc;                         /* content code */
 320         u32 reserved3[13];
 321         u8  ccdf[PAGE_SIZE - 24 - 56];  /* content-code dependent field */
 322 } __packed;
 323
 324 #define CHSC_SEI_NT0    (1ULL << 63)
 325 #define CHSC_SEI_NT2    (1ULL << 61)
 326
 327 struct chsc_sei {
 328         struct chsc_header request;
 329         u32 reserved1;
 330         u64 ntsm;                       /* notification type mask */
 331         struct chsc_header response;
 332         u32 :24;
 333         u8 nt;
 334         union {
 335                 struct chsc_sei_nt0_area nt0_area;
 336                 struct chsc_sei_nt2_area nt2_area;
 337                 u8 nt_area[PAGE_SIZE - 24];
 338         } u;
 339 } __packed __aligned(PAGE_SIZE);
 340
 341 /*
 342  * Link Incident Record as defined in SA22-7202, "ESCON I/O Interface"
 343  */
 344
 345 #define LIR_IQ_CLASS_INFO               0
 346 #define LIR_IQ_CLASS_DEGRADED           1
 347 #define LIR_IQ_CLASS_NOT_OPERATIONAL    2
 348
 349 struct lir {
 350         struct {
 351                 u32 null:1;
 352                 u32 reserved:3;
 353                 u32 class:2;
 354                 u32 reserved2:2;
 355         } __packed iq;
 356         u32 ic:8;
 357         u32 reserved:16;
 358         struct node_descriptor incident_node;
 359         struct node_descriptor attached_node;
 360         u8 reserved2[32];
 361 } __packed;
 362
 363 #define PARAMS_LEN      10      /* PARAMS=xx,xxxxxx */
 364 #define NODEID_LEN      35      /* NODEID=tttttt/mdl,mmm.ppssssssssssss,xxxx */
 365
 366 /* Copy EBCIDC text, convert to ASCII and optionally add delimiter. */
 367 static char *store_ebcdic(char *dest, const char *src, unsigned long len,
 368                           char delim)
 369 {
 370         memcpy(dest, src, len);
 371         EBCASC(dest, len);
 372
 373         if (delim)
 374                 dest[len++] = delim;
 375
 376         return dest + len;
 377 }
 378
 379 static void chsc_link_from_sei(struct chp_link *link,
 380                                 struct chsc_sei_nt0_area *sei_area)
 381 {
 382         if ((sei_area->vf & SEI_VF_FLA) != 0) {
 383                 link->fla       = sei_area->fla;
 384                 link->fla_mask  = ((sei_area->vf & SEI_VF_FLA) == SEI_VF_FLA) ?
 385                                                         0xffff : 0xff00;
 386         }
 387 }
 388
 389 /* Format node ID and parameters for output in LIR log message. */
 390 static void format_node_data(char *params, char *id, struct node_descriptor *nd)
 391 {
 392         memset(params, 0, PARAMS_LEN);
 393         memset(id, 0, NODEID_LEN);
 394
 395         if (nd->validity != ND_VALIDITY_VALID) {
 396                 strncpy(params, "n/a", PARAMS_LEN - 1);
 397                 strncpy(id, "n/a", NODEID_LEN - 1);
 398                 return;
 399         }
 400
 401         /* PARAMS=xx,xxxxxx */
 402         snprintf(params, PARAMS_LEN, "%02x,%06x", nd->byte0, nd->params);
 403         /* NODEID=tttttt/mdl,mmm.ppssssssssssss,xxxx */
 404         id = store_ebcdic(id, nd->type, sizeof(nd->type), '/');
 405         id = store_ebcdic(id, nd->model, sizeof(nd->model), ',');
 406         id = store_ebcdic(id, nd->manufacturer, sizeof(nd->manufacturer), '.');
 407         id = store_ebcdic(id, nd->plant, sizeof(nd->plant), 0);
 408         id = store_ebcdic(id, nd->seq, sizeof(nd->seq), ',');
 409         sprintf(id, "%04X", nd->tag);
 410 }
 411
 412 static void chsc_process_sei_link_incident(struct chsc_sei_nt0_area *sei_area)
 413 {
 414         struct lir *lir = (struct lir *) &sei_area->ccdf;
 415         char iuparams[PARAMS_LEN], iunodeid[NODEID_LEN], auparams[PARAMS_LEN],
 416              aunodeid[NODEID_LEN];
 417
 418         CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x, iq=%02x)\n",
 419                       sei_area->rs, sei_area->rsid, sei_area->ccdf[0]);
 420
 421         /* Ignore NULL Link Incident Records. */
 422         if (lir->iq.null)
 423                 return;
 424
 425         /* Inform user that a link requires maintenance actions because it has
 426          * become degraded or not operational. Note that this log message is
 427          * the primary intention behind a Link Incident Record. */
 428
 429         format_node_data(iuparams, iunodeid, &lir->incident_node);
 430         format_node_data(auparams, aunodeid, &lir->attached_node);
 431
 432         switch (lir->iq.class) {
 433         case LIR_IQ_CLASS_DEGRADED:
 434                 pr_warn("Link degraded: RS=%02x RSID=%04x IC=%02x "
 435                         "IUPARAMS=%s IUNODEID=%s AUPARAMS=%s AUNODEID=%s\n",
 436                         sei_area->rs, sei_area->rsid, lir->ic, iuparams,
 437                         iunodeid, auparams, aunodeid);
 438                 break;
 439         case LIR_IQ_CLASS_NOT_OPERATIONAL:
 440                 pr_err("Link stopped: RS=%02x RSID=%04x IC=%02x "
 441                        "IUPARAMS=%s IUNODEID=%s AUPARAMS=%s AUNODEID=%s\n",
 442                        sei_area->rs, sei_area->rsid, lir->ic, iuparams,
 443                        iunodeid, auparams, aunodeid);
 444                 break;
 445         default:
 446                 break;
 447         }
 448 }
 449
 450 static void chsc_process_sei_res_acc(struct chsc_sei_nt0_area *sei_area)
 451 {
 452         struct channel_path *chp;
 453         struct chp_link link;
 454         struct chp_id chpid;
 455         int status;
 456
 457         CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
 458                       "rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
 459         if (sei_area->rs != 4)
 460                 return;
 461         chp_id_init(&chpid);
 462         chpid.id = sei_area->rsid;
 463         /* allocate a new channel path structure, if needed */
 464         status = chp_get_status(chpid);
 465         if (!status)
 466                 return;
 467
 468         if (status < 0) {
 469                 chp_new(chpid);
 470         } else {
 471                 chp = chpid_to_chp(chpid);
 472                 mutex_lock(&chp->lock);
 473                 chp_update_desc(chp);
 474                 mutex_unlock(&chp->lock);
 475         }
 476         memset(&link, 0, sizeof(struct chp_link));
 477         link.chpid = chpid;
 478         chsc_link_from_sei(&link, sei_area);
 479         s390_process_res_acc(&link);
 480 }
 481
 482 static void chsc_process_sei_chp_avail(struct chsc_sei_nt0_area *sei_area)
 483 {
 484         struct channel_path *chp;
 485         struct chp_id chpid;
 486         u8 *data;
 487         int num;
 488
 489         CIO_CRW_EVENT(4, "chsc: channel path availability information\n");
 490         if (sei_area->rs != 0)
 491                 return;
 492         data = sei_area->ccdf;
 493         chp_id_init(&chpid);
 494         for (num = 0; num <= __MAX_CHPID; num++) {
 495                 if (!chp_test_bit(data, num))
 496                         continue;
 497                 chpid.id = num;
 498
 499                 CIO_CRW_EVENT(4, "Update information for channel path "
 500                               "%x.%02x\n", chpid.cssid, chpid.id);
 501                 chp = chpid_to_chp(chpid);
 502                 if (!chp) {
 503                         chp_new(chpid);
 504                         continue;
 505                 }
 506                 mutex_lock(&chp->lock);
 507                 chp_update_desc(chp);
 508                 mutex_unlock(&chp->lock);
 509         }
 510 }
 511
 512 struct chp_config_data {
 513         u8 map[32];
 514         u8 op;
 515         u8 pc;
 516 };
 517
 518 static void chsc_process_sei_chp_config(struct chsc_sei_nt0_area *sei_area)
 519 {
 520         struct chp_config_data *data;
 521         struct chp_id chpid;
 522         int num;
 523         char *events[3] = {"configure", "deconfigure", "cancel deconfigure"};
 524
 525         CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
 526         if (sei_area->rs != 0)
 527                 return;
 528         data = (struct chp_config_data *) &(sei_area->ccdf);
 529         chp_id_init(&chpid);
 530         for (num = 0; num <= __MAX_CHPID; num++) {
 531                 if (!chp_test_bit(data->map, num))
 532                         continue;
 533                 chpid.id = num;
 534                 pr_notice("Processing %s for channel path %x.%02x\n",
 535                           events[data->op], chpid.cssid, chpid.id);
 536                 switch (data->op) {
 537                 case 0:
 538                         chp_cfg_schedule(chpid, 1);
 539                         break;
 540                 case 1:
 541                         chp_cfg_schedule(chpid, 0);
 542                         break;
 543                 case 2:
 544                         chp_cfg_cancel_deconfigure(chpid);
 545                         break;
 546                 }
 547         }
 548 }
 549
 550 static void chsc_process_sei_scm_change(struct chsc_sei_nt0_area *sei_area)
 551 {
 552         int ret;
 553
 554         CIO_CRW_EVENT(4, "chsc: scm change notification\n");
 555         if (sei_area->rs != 7)
 556                 return;
 557
 558         ret = scm_update_information();
 559         if (ret)
 560                 CIO_CRW_EVENT(0, "chsc: updating change notification"
 561                               " failed (rc=%d).\n", ret);
 562 }
 563
 564 static void chsc_process_sei_scm_avail(struct chsc_sei_nt0_area *sei_area)
 565 {
 566         int ret;
 567
 568         CIO_CRW_EVENT(4, "chsc: scm available information\n");
 569         if (sei_area->rs != 7)
 570                 return;
 571
 572         ret = scm_process_availability_information();
 573         if (ret)
 574                 CIO_CRW_EVENT(0, "chsc: process availability information"
 575                               " failed (rc=%d).\n", ret);
 576 }
 577
 578 static void chsc_process_sei_ap_cfg_chg(struct chsc_sei_nt0_area *sei_area)
 579 {
 580         CIO_CRW_EVENT(3, "chsc: ap config changed\n");
 581         if (sei_area->rs != 5)
 582                 return;
 583
 584         ap_bus_cfg_chg();
 585 }
 586
 587 static void chsc_process_sei_fces_event(struct chsc_sei_nt0_area *sei_area)
 588 {
 589         struct chp_link link;
 590         struct chp_id chpid;
 591         struct channel_path *chp;
 592
 593         CIO_CRW_EVENT(4,
 594         "chsc: FCES status notification (rs=%02x, rs_id=%04x, FCES-status=%x)\n",
 595                 sei_area->rs, sei_area->rsid, sei_area->ccdf[0]);
 596
 597         if (sei_area->rs != SEI_RS_CHPID)
 598                 return;
 599         chp_id_init(&chpid);
 600         chpid.id = sei_area->rsid;
 601
 602         /* Ignore the event on unknown/invalid chp */
 603         chp = chpid_to_chp(chpid);
 604         if (!chp)
 605                 return;
 606
 607         memset(&link, 0, sizeof(struct chp_link));
 608         link.chpid = chpid;
 609         chsc_link_from_sei(&link, sei_area);
 610
 611         for_each_subchannel_staged(process_fces_event, NULL, &link);
 612 }
 613
 614 static void chsc_process_sei_nt2(struct chsc_sei_nt2_area *sei_area)
 615 {
 616         switch (sei_area->cc) {
 617         case 1:
 618                 zpci_event_error(sei_area->ccdf);
 619                 break;
 620         case 2:
 621                 zpci_event_availability(sei_area->ccdf);
 622                 break;
 623         default:
 624                 CIO_CRW_EVENT(2, "chsc: sei nt2 unhandled cc=%d\n",
 625                               sei_area->cc);
 626                 break;
 627         }
 628 }
 629
 630 static void chsc_process_sei_nt0(struct chsc_sei_nt0_area *sei_area)
 631 {
 632         /* which kind of information was stored? */
 633         switch (sei_area->cc) {
 634         case 1: /* link incident*/
 635                 chsc_process_sei_link_incident(sei_area);
 636                 break;
 637         case 2: /* i/o resource accessibility */
 638                 chsc_process_sei_res_acc(sei_area);
 639                 break;
 640         case 3: /* ap config changed */
 641                 chsc_process_sei_ap_cfg_chg(sei_area);
 642                 break;
 643         case 7: /* channel-path-availability information */
 644                 chsc_process_sei_chp_avail(sei_area);
 645                 break;
 646         case 8: /* channel-path-configuration notification */
 647                 chsc_process_sei_chp_config(sei_area);
 648                 break;
 649         case 12: /* scm change notification */
 650                 chsc_process_sei_scm_change(sei_area);
 651                 break;
 652         case 14: /* scm available notification */
 653                 chsc_process_sei_scm_avail(sei_area);
 654                 break;
 655         case 15: /* FCES event notification */
 656                 chsc_process_sei_fces_event(sei_area);
 657                 break;
 658         default: /* other stuff */
 659                 CIO_CRW_EVENT(2, "chsc: sei nt0 unhandled cc=%d\n",
 660                               sei_area->cc);
 661                 break;
 662         }
 663
 664         /* Check if we might have lost some information. */
 665         if (sei_area->flags & 0x40) {
 666                 CIO_CRW_EVENT(2, "chsc: event overflow\n");
 667                 css_schedule_eval_all();
 668         }
 669 }
 670
 671 static void chsc_process_event_information(struct chsc_sei *sei, u64 ntsm)
 672 {
 673         static int ntsm_unsupported;
 674
 675         while (true) {
 676                 memset(sei, 0, sizeof(*sei));
 677                 sei->request.length = 0x0010;
 678                 sei->request.code = 0x000e;
 679                 if (!ntsm_unsupported)
 680                         sei->ntsm = ntsm;
 681
 682                 if (chsc(sei))
 683                         break;
 684
 685                 if (sei->response.code != 0x0001) {
 686                         CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x, ntsm=%llx)\n",
 687                                       sei->response.code, sei->ntsm);
 688
 689                         if (sei->response.code == 3 && sei->ntsm) {
 690                                 /* Fallback for old firmware. */
 691                                 ntsm_unsupported = 1;
 692                                 continue;
 693                         }
 694                         break;
 695                 }
 696
 697                 CIO_CRW_EVENT(2, "chsc: sei successful (nt=%d)\n", sei->nt);
 698                 switch (sei->nt) {
 699                 case 0:
 700                         chsc_process_sei_nt0(&sei->u.nt0_area);
 701                         break;
 702                 case 2:
 703                         chsc_process_sei_nt2(&sei->u.nt2_area);
 704                         break;
 705                 default:
 706                         CIO_CRW_EVENT(2, "chsc: unhandled nt: %d\n", sei->nt);
 707                         break;
 708                 }
 709
 710                 if (!(sei->u.nt0_area.flags & 0x80))
 711                         break;
 712         }
 713 }
 714
 715 /*
 716  * Handle channel subsystem related CRWs.
 717  * Use store event information to find out what's going on.
 718  *
 719  * Note: Access to sei_page is serialized through machine check handler
 720  * thread, so no need for locking.
 721  */
 722 static void chsc_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
 723 {
 724         struct chsc_sei *sei = sei_page;
 725
 726         if (overflow) {
 727                 css_schedule_eval_all();
 728                 return;
 729         }
 730         CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "
 731                       "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
 732                       crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
 733                       crw0->erc, crw0->rsid);
 734
 735         CIO_TRACE_EVENT(2, "prcss");
 736         chsc_process_event_information(sei, CHSC_SEI_NT0 | CHSC_SEI_NT2);
 737 }
 738
 739 void chsc_chp_online(struct chp_id chpid)
 740 {
 741         struct channel_path *chp = chpid_to_chp(chpid);
 742         struct chp_link link;
 743         char dbf_txt[15];
 744
 745         sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);
 746         CIO_TRACE_EVENT(2, dbf_txt);
 747
 748         if (chp_get_status(chpid) != 0) {
 749                 memset(&link, 0, sizeof(struct chp_link));
 750                 link.chpid = chpid;
 751                 /* Wait until previous actions have settled. */
 752                 css_wait_for_slow_path();
 753
 754                 mutex_lock(&chp->lock);
 755                 chp_update_desc(chp);
 756                 mutex_unlock(&chp->lock);
 757
 758                 for_each_subchannel_staged(__s390_process_res_acc, NULL,
 759                                            &link);
 760                 css_schedule_reprobe();
 761         }
 762 }
 763
 764 static void __s390_subchannel_vary_chpid(struct subchannel *sch,
 765                                          struct chp_id chpid, int on)
 766 {
 767         unsigned long flags;
 768         struct chp_link link;
 769
 770         memset(&link, 0, sizeof(struct chp_link));
 771         link.chpid = chpid;
 772         spin_lock_irqsave(sch->lock, flags);
 773         if (sch->driver && sch->driver->chp_event)
 774                 sch->driver->chp_event(sch, &link,
 775                                        on ? CHP_VARY_ON : CHP_VARY_OFF);
 776         spin_unlock_irqrestore(sch->lock, flags);
 777 }
 778
 779 static int s390_subchannel_vary_chpid_off(struct subchannel *sch, void *data)
 780 {
 781         struct chp_id *chpid = data;
 782
 783         __s390_subchannel_vary_chpid(sch, *chpid, 0);
 784         return 0;
 785 }
 786
 787 static int s390_subchannel_vary_chpid_on(struct subchannel *sch, void *data)
 788 {
 789         struct chp_id *chpid = data;
 790
 791         __s390_subchannel_vary_chpid(sch, *chpid, 1);
 792         return 0;
 793 }
 794
 795 /**
 796  * chsc_chp_vary - propagate channel-path vary operation to subchannels
 797  * @chpid: channl-path ID
 798  * @on: non-zero for vary online, zero for vary offline
 799  */
 800 int chsc_chp_vary(struct chp_id chpid, int on)
 801 {
 802         struct channel_path *chp = chpid_to_chp(chpid);
 803
 804         /* Wait until previous actions have settled. */
 805         css_wait_for_slow_path();
 806         /*
 807          * Redo PathVerification on the devices the chpid connects to
 808          */
 809         if (on) {
 810                 /* Try to update the channel path description. */
 811                 chp_update_desc(chp);
 812                 for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
 813                                            NULL, &chpid);
 814                 css_schedule_reprobe();
 815         } else
 816                 for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
 817                                            NULL, &chpid);
 818
 819         return 0;
 820 }
 821
 822 static void
 823 chsc_remove_cmg_attr(struct channel_subsystem *css)
 824 {
 825         int i;
 826
 827         for (i = 0; i <= __MAX_CHPID; i++) {
 828                 if (!css->chps[i])
 829                         continue;
 830                 chp_remove_cmg_attr(css->chps[i]);
 831         }
 832 }
 833
 834 static int
 835 chsc_add_cmg_attr(struct channel_subsystem *css)
 836 {
 837         int i, ret;
 838
 839         ret = 0;
 840         for (i = 0; i <= __MAX_CHPID; i++) {
 841                 if (!css->chps[i])
 842                         continue;
 843                 ret = chp_add_cmg_attr(css->chps[i]);
 844                 if (ret)
 845                         goto cleanup;
 846         }
 847         return ret;
 848 cleanup:
 849         for (--i; i >= 0; i--) {
 850                 if (!css->chps[i])
 851                         continue;
 852                 chp_remove_cmg_attr(css->chps[i]);
 853         }
 854         return ret;
 855 }
 856
 857 int __chsc_do_secm(struct channel_subsystem *css, int enable)
 858 {
 859         struct {
 860                 struct chsc_header request;
 861                 u32 operation_code : 2;
 862                 u32 : 30;
 863                 u32 key : 4;
 864                 u32 : 28;
 865                 u32 zeroes1;
 866                 u32 cub_addr1;
 867                 u32 zeroes2;
 868                 u32 cub_addr2;
 869                 u32 reserved[13];
 870                 struct chsc_header response;
 871                 u32 status : 8;
 872                 u32 : 4;
 873                 u32 fmt : 4;
 874                 u32 : 16;
 875         } *secm_area;
 876         unsigned long flags;
 877         int ret, ccode;
 878
 879         spin_lock_irqsave(&chsc_page_lock, flags);
 880         memset(chsc_page, 0, PAGE_SIZE);
 881         secm_area = chsc_page;
 882         secm_area->request.length = 0x0050;
 883         secm_area->request.code = 0x0016;
 884
 885         secm_area->key = PAGE_DEFAULT_KEY >> 4;
 886         secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
 887         secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
 888
 889         secm_area->operation_code = enable ? 0 : 1;
 890
 891         ccode = chsc(secm_area);
 892         if (ccode > 0) {
 893                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
 894                 goto out;
 895         }
 896
 897         switch (secm_area->response.code) {
 898         case 0x0102:
 899         case 0x0103:
 900                 ret = -EINVAL;
 901                 break;
 902         default:
 903                 ret = chsc_error_from_response(secm_area->response.code);
 904         }
 905         if (ret != 0)
 906                 CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",
 907                               secm_area->response.code);
 908 out:
 909         spin_unlock_irqrestore(&chsc_page_lock, flags);
 910         return ret;
 911 }
 912
 913 int
 914 chsc_secm(struct channel_subsystem *css, int enable)
 915 {
 916         int ret;
 917
 918         if (enable && !css->cm_enabled) {
 919                 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 920                 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 921                 if (!css->cub_addr1 || !css->cub_addr2) {
 922                         free_page((unsigned long)css->cub_addr1);
 923                         free_page((unsigned long)css->cub_addr2);
 924                         return -ENOMEM;
 925                 }
 926         }
 927         ret = __chsc_do_secm(css, enable);
 928         if (!ret) {
 929                 css->cm_enabled = enable;
 930                 if (css->cm_enabled) {
 931                         ret = chsc_add_cmg_attr(css);
 932                         if (ret) {
 933                                 __chsc_do_secm(css, 0);
 934                                 css->cm_enabled = 0;
 935                         }
 936                 } else
 937                         chsc_remove_cmg_attr(css);
 938         }
 939         if (!css->cm_enabled) {
 940                 free_page((unsigned long)css->cub_addr1);
 941                 free_page((unsigned long)css->cub_addr2);
 942         }
 943         return ret;
 944 }
 945
 946 int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
 947                                      int c, int m, void *page)
 948 {
 949         struct chsc_scpd *scpd_area;
 950         int ccode, ret;
 951
 952         if ((rfmt == 1 || rfmt == 0) && c == 1 &&
 953             !css_general_characteristics.fcs)
 954                 return -EINVAL;
 955         if ((rfmt == 2) && !css_general_characteristics.cib)
 956                 return -EINVAL;
 957         if ((rfmt == 3) && !css_general_characteristics.util_str)
 958                 return -EINVAL;
 959
 960         memset(page, 0, PAGE_SIZE);
 961         scpd_area = page;
 962         scpd_area->request.length = 0x0010;
 963         scpd_area->request.code = 0x0002;
 964         scpd_area->cssid = chpid.cssid;
 965         scpd_area->first_chpid = chpid.id;
 966         scpd_area->last_chpid = chpid.id;
 967         scpd_area->m = m;
 968         scpd_area->c = c;
 969         scpd_area->fmt = fmt;
 970         scpd_area->rfmt = rfmt;
 971
 972         ccode = chsc(scpd_area);
 973         if (ccode > 0)
 974                 return (ccode == 3) ? -ENODEV : -EBUSY;
 975
 976         ret = chsc_error_from_response(scpd_area->response.code);
 977         if (ret)
 978                 CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",
 979                               scpd_area->response.code);
 980         return ret;
 981 }
 982 EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc);
 983
 984 #define chsc_det_chp_desc(FMT, c)                                       \
 985 int chsc_determine_fmt##FMT##_channel_path_desc(                        \
 986         struct chp_id chpid, struct channel_path_desc_fmt##FMT *desc)   \
 987 {                                                                       \
 988         struct chsc_scpd *scpd_area;                                    \
 989         unsigned long flags;                                            \
 990         int ret;                                                        \
 991                                                                         \
 992         spin_lock_irqsave(&chsc_page_lock, flags);                      \
 993         scpd_area = chsc_page;                                          \
 994         ret = chsc_determine_channel_path_desc(chpid, 0, FMT, c, 0,     \
 995                                                scpd_area);              \
 996         if (ret)                                                        \
 997                 goto out;                                               \
 998                                                                         \
 999         memcpy(desc, scpd_area->data, sizeof(*desc));                   \
1000 out:                                                                    \
1001         spin_unlock_irqrestore(&chsc_page_lock, flags);                 \
1002         return ret;                                                     \
1003 }
1004
1005 chsc_det_chp_desc(0, 0)
1006 chsc_det_chp_desc(1, 1)
1007 chsc_det_chp_desc(3, 0)
1008
1009 static void
1010 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
1011                           struct cmg_chars *chars)
1012 {
1013         int i, mask;
1014
1015         for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
1016                 mask = 0x80 >> (i + 3);
1017                 if (cmcv & mask)
1018                         chp->cmg_chars.values[i] = chars->values[i];
1019                 else
1020                         chp->cmg_chars.values[i] = 0;
1021         }
1022 }
1023
1024 int chsc_get_channel_measurement_chars(struct channel_path *chp)
1025 {
1026         unsigned long flags;
1027         int ccode, ret;
1028
1029         struct {
1030                 struct chsc_header request;
1031                 u32 : 24;
1032                 u32 first_chpid : 8;
1033                 u32 : 24;
1034                 u32 last_chpid : 8;
1035                 u32 zeroes1;
1036                 struct chsc_header response;
1037                 u32 zeroes2;
1038                 u32 not_valid : 1;
1039                 u32 shared : 1;
1040                 u32 : 22;
1041                 u32 chpid : 8;
1042                 u32 cmcv : 5;
1043                 u32 : 11;
1044                 u32 cmgq : 8;
1045                 u32 cmg : 8;
1046                 u32 zeroes3;
1047                 u32 data[NR_MEASUREMENT_CHARS];
1048         } *scmc_area;
1049
1050         chp->shared = -1;
1051         chp->cmg = -1;
1052
1053         if (!css_chsc_characteristics.scmc || !css_chsc_characteristics.secm)
1054                 return -EINVAL;
1055
1056         spin_lock_irqsave(&chsc_page_lock, flags);
1057         memset(chsc_page, 0, PAGE_SIZE);
1058         scmc_area = chsc_page;
1059         scmc_area->request.length = 0x0010;
1060         scmc_area->request.code = 0x0022;
1061         scmc_area->first_chpid = chp->chpid.id;
1062         scmc_area->last_chpid = chp->chpid.id;
1063
1064         ccode = chsc(scmc_area);
1065         if (ccode > 0) {
1066                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1067                 goto out;
1068         }
1069
1070         ret = chsc_error_from_response(scmc_area->response.code);
1071         if (ret) {
1072                 CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",
1073                               scmc_area->response.code);
1074                 goto out;
1075         }
1076         if (scmc_area->not_valid)
1077                 goto out;
1078
1079         chp->cmg = scmc_area->cmg;
1080         chp->shared = scmc_area->shared;
1081         if (chp->cmg != 2 && chp->cmg != 3) {
1082                 /* No cmg-dependent data. */
1083                 goto out;
1084         }
1085         chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
1086                                   (struct cmg_chars *) &scmc_area->data);
1087 out:
1088         spin_unlock_irqrestore(&chsc_page_lock, flags);
1089         return ret;
1090 }
1091
1092 int __init chsc_init(void)
1093 {
1094         int ret;
1095
1096         sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1097         chsc_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1098         if (!sei_page || !chsc_page) {
1099                 ret = -ENOMEM;
1100                 goto out_err;
1101         }
1102         ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw);
1103         if (ret)
1104                 goto out_err;
1105         return ret;
1106 out_err:
1107         free_page((unsigned long)chsc_page);
1108         free_page((unsigned long)sei_page);
1109         return ret;
1110 }
1111
1112 void __init chsc_init_cleanup(void)
1113 {
1114         crw_unregister_handler(CRW_RSC_CSS);
1115         free_page((unsigned long)chsc_page);
1116         free_page((unsigned long)sei_page);
1117 }
1118
1119 int __chsc_enable_facility(struct chsc_sda_area *sda_area, int operation_code)
1120 {
1121         int ret;
1122
1123         sda_area->request.length = 0x0400;
1124         sda_area->request.code = 0x0031;
1125         sda_area->operation_code = operation_code;
1126
1127         ret = chsc(sda_area);
1128         if (ret > 0) {
1129                 ret = (ret == 3) ? -ENODEV : -EBUSY;
1130                 goto out;
1131         }
1132
1133         switch (sda_area->response.code) {
1134         case 0x0101:
1135                 ret = -EOPNOTSUPP;
1136                 break;
1137         default:
1138                 ret = chsc_error_from_response(sda_area->response.code);
1139         }
1140 out:
1141         return ret;
1142 }
1143
1144 int chsc_enable_facility(int operation_code)
1145 {
1146         struct chsc_sda_area *sda_area;
1147         unsigned long flags;
1148         int ret;
1149
1150         spin_lock_irqsave(&chsc_page_lock, flags);
1151         memset(chsc_page, 0, PAGE_SIZE);
1152         sda_area = chsc_page;
1153
1154         ret = __chsc_enable_facility(sda_area, operation_code);
1155         if (ret != 0)
1156                 CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",
1157                               operation_code, sda_area->response.code);
1158
1159         spin_unlock_irqrestore(&chsc_page_lock, flags);
1160         return ret;
1161 }
1162
1163 int __init chsc_get_cssid_iid(int idx, u8 *cssid, u8 *iid)
1164 {
1165         struct {
1166                 struct chsc_header request;
1167                 u8 atype;
1168                 u32 : 24;
1169                 u32 reserved1[6];
1170                 struct chsc_header response;
1171                 u32 reserved2[3];
1172                 struct {
1173                         u8 cssid;
1174                         u8 iid;
1175                         u32 : 16;
1176                 } list[0];
1177         } *sdcal_area;
1178         int ret;
1179
1180         spin_lock_irq(&chsc_page_lock);
1181         memset(chsc_page, 0, PAGE_SIZE);
1182         sdcal_area = chsc_page;
1183         sdcal_area->request.length = 0x0020;
1184         sdcal_area->request.code = 0x0034;
1185         sdcal_area->atype = 4;
1186
1187         ret = chsc(sdcal_area);
1188         if (ret) {
1189                 ret = (ret == 3) ? -ENODEV : -EBUSY;
1190                 goto exit;
1191         }
1192
1193         ret = chsc_error_from_response(sdcal_area->response.code);
1194         if (ret) {
1195                 CIO_CRW_EVENT(2, "chsc: sdcal failed (rc=%04x)\n",
1196                               sdcal_area->response.code);
1197                 goto exit;
1198         }
1199
1200         if ((addr_t) &sdcal_area->list[idx] <
1201             (addr_t) &sdcal_area->response + sdcal_area->response.length) {
1202                 *cssid = sdcal_area->list[idx].cssid;
1203                 *iid = sdcal_area->list[idx].iid;
1204         }
1205         else
1206                 ret = -ENODEV;
1207 exit:
1208         spin_unlock_irq(&chsc_page_lock);
1209         return ret;
1210 }
1211
1212 struct css_general_char css_general_characteristics;
1213 struct css_chsc_char css_chsc_characteristics;
1214
1215 int __init
1216 chsc_determine_css_characteristics(void)
1217 {
1218         unsigned long flags;
1219         int result;
1220         struct {
1221                 struct chsc_header request;
1222                 u32 reserved1;
1223                 u32 reserved2;
1224                 u32 reserved3;
1225                 struct chsc_header response;
1226                 u32 reserved4;
1227                 u32 general_char[510];
1228                 u32 chsc_char[508];
1229         } *scsc_area;
1230
1231         spin_lock_irqsave(&chsc_page_lock, flags);
1232         memset(chsc_page, 0, PAGE_SIZE);
1233         scsc_area = chsc_page;
1234         scsc_area->request.length = 0x0010;
1235         scsc_area->request.code = 0x0010;
1236
1237         result = chsc(scsc_area);
1238         if (result) {
1239                 result = (result == 3) ? -ENODEV : -EBUSY;
1240                 goto exit;
1241         }
1242
1243         result = chsc_error_from_response(scsc_area->response.code);
1244         if (result == 0) {
1245                 memcpy(&css_general_characteristics, scsc_area->general_char,
1246                        sizeof(css_general_characteristics));
1247                 memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1248                        sizeof(css_chsc_characteristics));
1249         } else
1250                 CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",
1251                               scsc_area->response.code);
1252 exit:
1253         spin_unlock_irqrestore(&chsc_page_lock, flags);
1254         return result;
1255 }
1256
1257 EXPORT_SYMBOL_GPL(css_general_characteristics);
1258 EXPORT_SYMBOL_GPL(css_chsc_characteristics);
1259
1260 int chsc_sstpc(void *page, unsigned int op, u16 ctrl, u64 *clock_delta)
1261 {
1262         struct {
1263                 struct chsc_header request;
1264                 unsigned int rsvd0;
1265                 unsigned int op : 8;
1266                 unsigned int rsvd1 : 8;
1267                 unsigned int ctrl : 16;
1268                 unsigned int rsvd2[5];
1269                 struct chsc_header response;
1270                 unsigned int rsvd3[3];
1271                 u64 clock_delta;
1272                 unsigned int rsvd4[2];
1273         } *rr;
1274         int rc;
1275
1276         memset(page, 0, PAGE_SIZE);
1277         rr = page;
1278         rr->request.length = 0x0020;
1279         rr->request.code = 0x0033;
1280         rr->op = op;
1281         rr->ctrl = ctrl;
1282         rc = chsc(rr);
1283         if (rc)
1284                 return -EIO;
1285         rc = (rr->response.code == 0x0001) ? 0 : -EIO;
1286         if (clock_delta)
1287                 *clock_delta = rr->clock_delta;
1288         return rc;
1289 }
1290
1291 int chsc_sstpi(void *page, void *result, size_t size)
1292 {
1293         struct {
1294                 struct chsc_header request;
1295                 unsigned int rsvd0[3];
1296                 struct chsc_header response;
1297                 char data[];
1298         } *rr;
1299         int rc;
1300
1301         memset(page, 0, PAGE_SIZE);
1302         rr = page;
1303         rr->request.length = 0x0010;
1304         rr->request.code = 0x0038;
1305         rc = chsc(rr);
1306         if (rc)
1307                 return -EIO;
1308         memcpy(result, &rr->data, size);
1309         return (rr->response.code == 0x0001) ? 0 : -EIO;
1310 }
1311
1312 int chsc_stzi(void *page, void *result, size_t size)
1313 {
1314         struct {
1315                 struct chsc_header request;
1316                 unsigned int rsvd0[3];
1317                 struct chsc_header response;
1318                 char data[];
1319         } *rr;
1320         int rc;
1321
1322         memset(page, 0, PAGE_SIZE);
1323         rr = page;
1324         rr->request.length = 0x0010;
1325         rr->request.code = 0x003e;
1326         rc = chsc(rr);
1327         if (rc)
1328                 return -EIO;
1329         memcpy(result, &rr->data, size);
1330         return (rr->response.code == 0x0001) ? 0 : -EIO;
1331 }
1332
1333 int chsc_siosl(struct subchannel_id schid)
1334 {
1335         struct {
1336                 struct chsc_header request;
1337                 u32 word1;
1338                 struct subchannel_id sid;
1339                 u32 word3;
1340                 struct chsc_header response;
1341                 u32 word[11];
1342         } *siosl_area;
1343         unsigned long flags;
1344         int ccode;
1345         int rc;
1346
1347         spin_lock_irqsave(&chsc_page_lock, flags);
1348         memset(chsc_page, 0, PAGE_SIZE);
1349         siosl_area = chsc_page;
1350         siosl_area->request.length = 0x0010;
1351         siosl_area->request.code = 0x0046;
1352         siosl_area->word1 = 0x80000000;
1353         siosl_area->sid = schid;
1354
1355         ccode = chsc(siosl_area);
1356         if (ccode > 0) {
1357                 if (ccode == 3)
1358                         rc = -ENODEV;
1359                 else
1360                         rc = -EBUSY;
1361                 CIO_MSG_EVENT(2, "chsc: chsc failed for 0.%x.%04x (ccode=%d)\n",
1362                               schid.ssid, schid.sch_no, ccode);
1363                 goto out;
1364         }
1365         rc = chsc_error_from_response(siosl_area->response.code);
1366         if (rc)
1367                 CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n",
1368                               schid.ssid, schid.sch_no,
1369                               siosl_area->response.code);
1370         else
1371                 CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n",
1372                               schid.ssid, schid.sch_no);
1373 out:
1374         spin_unlock_irqrestore(&chsc_page_lock, flags);
1375         return rc;
1376 }
1377 EXPORT_SYMBOL_GPL(chsc_siosl);
1378
1379 /**
1380  * chsc_scm_info() - store SCM information (SSI)
1381  * @scm_area: request and response block for SSI
1382  * @token: continuation token
1383  *
1384  * Returns 0 on success.
1385  */
1386 int chsc_scm_info(struct chsc_scm_info *scm_area, u64 token)
1387 {
1388         int ccode, ret;
1389
1390         memset(scm_area, 0, sizeof(*scm_area));
1391         scm_area->request.length = 0x0020;
1392         scm_area->request.code = 0x004C;
1393         scm_area->reqtok = token;
1394
1395         ccode = chsc(scm_area);
1396         if (ccode > 0) {
1397                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1398                 goto out;
1399         }
1400         ret = chsc_error_from_response(scm_area->response.code);
1401         if (ret != 0)
1402                 CIO_MSG_EVENT(2, "chsc: scm info failed (rc=%04x)\n",
1403                               scm_area->response.code);
1404 out:
1405         return ret;
1406 }
1407 EXPORT_SYMBOL_GPL(chsc_scm_info);
1408
1409 /**
1410  * chsc_pnso() - Perform Network-Subchannel Operation
1411  * @schid:              id of the subchannel on which PNSO is performed
1412  * @pnso_area:          request and response block for the operation
1413  * @oc:                 Operation Code
1414  * @resume_token:       resume token for multiblock response
1415  * @cnc:                Boolean change-notification control
1416  *
1417  * pnso_area must be allocated by the caller with get_zeroed_page(GFP_KERNEL)
1418  *
1419  * Returns 0 on success.
1420  */
1421 int chsc_pnso(struct subchannel_id schid, struct chsc_pnso_area *pnso_area,
1422               u8 oc, struct chsc_pnso_resume_token resume_token, int cnc)
1423 {
1424         memset(pnso_area, 0, sizeof(*pnso_area));
1425         pnso_area->request.length = 0x0030;
1426         pnso_area->request.code = 0x003d; /* network-subchannel operation */
1427         pnso_area->m       = schid.m;
1428         pnso_area->ssid  = schid.ssid;
1429         pnso_area->sch   = schid.sch_no;
1430         pnso_area->cssid = schid.cssid;
1431         pnso_area->oc    = oc;
1432         pnso_area->resume_token = resume_token;
1433         pnso_area->n       = (cnc != 0);
1434         if (chsc(pnso_area))
1435                 return -EIO;
1436         return chsc_error_from_response(pnso_area->response.code);
1437 }
1438
1439 int chsc_sgib(u32 origin)
1440 {
1441         struct {
1442                 struct chsc_header request;
1443                 u16 op;
1444                 u8  reserved01[2];
1445                 u8  reserved02:4;
1446                 u8  fmt:4;
1447                 u8  reserved03[7];
1448                 /* operation data area begin */
1449                 u8  reserved04[4];
1450                 u32 gib_origin;
1451                 u8  reserved05[10];
1452                 u8  aix;
1453                 u8  reserved06[4029];
1454                 struct chsc_header response;
1455                 u8  reserved07[4];
1456         } *sgib_area;
1457         int ret;
1458
1459         spin_lock_irq(&chsc_page_lock);
1460         memset(chsc_page, 0, PAGE_SIZE);
1461         sgib_area = chsc_page;
1462         sgib_area->request.length = 0x0fe0;
1463         sgib_area->request.code = 0x0021;
1464         sgib_area->op = 0x1;
1465         sgib_area->gib_origin = origin;
1466
1467         ret = chsc(sgib_area);
1468         if (ret == 0)
1469                 ret = chsc_error_from_response(sgib_area->response.code);
1470         spin_unlock_irq(&chsc_page_lock);
1471
1472         return ret;
1473 }
1474 EXPORT_SYMBOL_GPL(chsc_sgib);
1475
1476 #define SCUD_REQ_LEN    0x10 /* SCUD request block length */
1477 #define SCUD_REQ_CMD    0x4b /* SCUD Command Code */
1478
1479 struct chse_cudb {
1480         u16 flags:8;
1481         u16 chp_valid:8;
1482         u16 cu;
1483         u32 esm_valid:8;
1484         u32:24;
1485         u8 chpid[8];
1486         u32:32;
1487         u32:32;
1488         u8 esm[8];
1489         u32 efla[8];
1490 } __packed;
1491
1492 struct chsc_scud {
1493         struct chsc_header request;
1494         u16:4;
1495         u16 fmt:4;
1496         u16 cssid:8;
1497         u16 first_cu;
1498         u16:16;
1499         u16 last_cu;
1500         u32:32;
1501         struct chsc_header response;
1502         u16:4;
1503         u16 fmt_resp:4;
1504         u32:24;
1505         struct chse_cudb cudb[];
1506 } __packed;
1507
1508 /**
1509  * chsc_scud() - Store control-unit description.
1510  * @cu:         number of the control-unit
1511  * @esm:        8 1-byte endpoint security mode values
1512  * @esm_valid:  validity mask for @esm
1513  *
1514  * Interface to retrieve information about the endpoint security
1515  * modes for up to 8 paths of a control unit.
1516  *
1517  * Returns 0 on success.
1518  */
1519 int chsc_scud(u16 cu, u64 *esm, u8 *esm_valid)
1520 {
1521         struct chsc_scud *scud = chsc_page;
1522         int ret;
1523
1524         spin_lock_irq(&chsc_page_lock);
1525         memset(chsc_page, 0, PAGE_SIZE);
1526         scud->request.length = SCUD_REQ_LEN;
1527         scud->request.code = SCUD_REQ_CMD;
1528         scud->fmt = 0;
1529         scud->cssid = 0;
1530         scud->first_cu = cu;
1531         scud->last_cu = cu;
1532
1533         ret = chsc(scud);
1534         if (!ret)
1535                 ret = chsc_error_from_response(scud->response.code);
1536
1537         if (!ret && (scud->response.length <= 8 || scud->fmt_resp != 0
1538                         || !(scud->cudb[0].flags & 0x80)
1539                         || scud->cudb[0].cu != cu)) {
1540
1541                 CIO_MSG_EVENT(2, "chsc: scud failed rc=%04x, L2=%04x "
1542                         "FMT=%04x, cudb.flags=%02x, cudb.cu=%04x",
1543                         scud->response.code, scud->response.length,
1544                         scud->fmt_resp, scud->cudb[0].flags, scud->cudb[0].cu);
1545                 ret = -EINVAL;
1546         }
1547
1548         if (ret)
1549                 goto out;
1550
1551         memcpy(esm, scud->cudb[0].esm, sizeof(*esm));
1552         *esm_valid = scud->cudb[0].esm_valid;
1553 out:
1554         spin_unlock_irq(&chsc_page_lock);
1555         return ret;
1556 }
1557 EXPORT_SYMBOL_GPL(chsc_scud);