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); 1558