kernel/drivers/s390/cio/chsc.c

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