1 /* 2 * drivers/s390/cio/chsc.c 3 * S/390 common I/O routines -- channel subsystem call 4 * 5 * Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH, 6 * IBM Corporation 7 * Author(s): Ingo Adlung (adlung@de.ibm.com) 8 * Cornelia Huck (cornelia.huck@de.ibm.com) 9 * Arnd Bergmann (arndb@de.ibm.com) 10 */ 11 12 #include <linux/module.h> 13 #include <linux/config.h> 14 #include <linux/slab.h> 15 #include <linux/init.h> 16 #include <linux/device.h> 17 18 #include <asm/cio.h> 19 20 #include "css.h" 21 #include "cio.h" 22 #include "cio_debug.h" 23 #include "ioasm.h" 24 #include "chsc.h" 25 26 static void *sei_page; 27 28 static int new_channel_path(int chpid); 29 30 static inline void 31 set_chp_logically_online(int chp, int onoff) 32 { 33 css[0]->chps[chp]->state = onoff; 34 } 35 36 static int 37 get_chp_status(int chp) 38 { 39 return (css[0]->chps[chp] ? css[0]->chps[chp]->state : -ENODEV); 40 } 41 42 void 43 chsc_validate_chpids(struct subchannel *sch) 44 { 45 int mask, chp; 46 47 for (chp = 0; chp <= 7; chp++) { 48 mask = 0x80 >> chp; 49 if (!get_chp_status(sch->schib.pmcw.chpid[chp])) 50 /* disable using this path */ 51 sch->opm &= ~mask; 52 } 53 } 54 55 void 56 chpid_is_actually_online(int chp) 57 { 58 int state; 59 60 state = get_chp_status(chp); 61 if (state < 0) { 62 need_rescan = 1; 63 queue_work(slow_path_wq, &slow_path_work); 64 } else 65 WARN_ON(!state); 66 } 67 68 /* FIXME: this is _always_ called for every subchannel. shouldn't we 69 * process more than one at a time? */ 70 static int 71 chsc_get_sch_desc_irq(struct subchannel *sch, void *page) 72 { 73 int ccode, j; 74 75 struct { 76 struct chsc_header request; 77 u16 reserved1a:10; 78 u16 ssid:2; 79 u16 reserved1b:4; 80 u16 f_sch; /* first subchannel */ 81 u16 reserved2; 82 u16 l_sch; /* last subchannel */ 83 u32 reserved3; 84 struct chsc_header response; 85 u32 reserved4; 86 u8 sch_valid : 1; 87 u8 dev_valid : 1; 88 u8 st : 3; /* subchannel type */ 89 u8 zeroes : 3; 90 u8 unit_addr; /* unit address */ 91 u16 devno; /* device number */ 92 u8 path_mask; 93 u8 fla_valid_mask; 94 u16 sch; /* subchannel */ 95 u8 chpid[8]; /* chpids 0-7 */ 96 u16 fla[8]; /* full link addresses 0-7 */ 97 } *ssd_area; 98 99 ssd_area = page; 100 101 ssd_area->request.length = 0x0010; 102 ssd_area->request.code = 0x0004; 103 104 ssd_area->ssid = sch->schid.ssid; 105 ssd_area->f_sch = sch->schid.sch_no; 106 ssd_area->l_sch = sch->schid.sch_no; 107 108 ccode = chsc(ssd_area); 109 if (ccode > 0) { 110 pr_debug("chsc returned with ccode = %d\n", ccode); 111 return (ccode == 3) ? -ENODEV : -EBUSY; 112 } 113 114 switch (ssd_area->response.code) { 115 case 0x0001: /* everything ok */ 116 break; 117 case 0x0002: 118 CIO_CRW_EVENT(2, "Invalid command!\n"); 119 return -EINVAL; 120 case 0x0003: 121 CIO_CRW_EVENT(2, "Error in chsc request block!\n"); 122 return -EINVAL; 123 case 0x0004: 124 CIO_CRW_EVENT(2, "Model does not provide ssd\n"); 125 return -EOPNOTSUPP; 126 default: 127 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n", 128 ssd_area->response.code); 129 return -EIO; 130 } 131 132 /* 133 * ssd_area->st stores the type of the detected 134 * subchannel, with the following definitions: 135 * 136 * 0: I/O subchannel: All fields have meaning 137 * 1: CHSC subchannel: Only sch_val, st and sch 138 * have meaning 139 * 2: Message subchannel: All fields except unit_addr 140 * have meaning 141 * 3: ADM subchannel: Only sch_val, st and sch 142 * have meaning 143 * 144 * Other types are currently undefined. 145 */ 146 if (ssd_area->st > 3) { /* uhm, that looks strange... */ 147 CIO_CRW_EVENT(0, "Strange subchannel type %d" 148 " for sch 0.%x.%04x\n", ssd_area->st, 149 sch->schid.ssid, sch->schid.sch_no); 150 /* 151 * There may have been a new subchannel type defined in the 152 * time since this code was written; since we don't know which 153 * fields have meaning and what to do with it we just jump out 154 */ 155 return 0; 156 } else { 157 const char *type[4] = {"I/O", "chsc", "message", "ADM"}; 158 CIO_CRW_EVENT(6, "ssd: sch 0.%x.%04x is %s subchannel\n", 159 sch->schid.ssid, sch->schid.sch_no, 160 type[ssd_area->st]); 161 162 sch->ssd_info.valid = 1; 163 sch->ssd_info.type = ssd_area->st; 164 } 165 166 if (ssd_area->st == 0 || ssd_area->st == 2) { 167 for (j = 0; j < 8; j++) { 168 if (!((0x80 >> j) & ssd_area->path_mask & 169 ssd_area->fla_valid_mask)) 170 continue; 171 sch->ssd_info.chpid[j] = ssd_area->chpid[j]; 172 sch->ssd_info.fla[j] = ssd_area->fla[j]; 173 } 174 } 175 return 0; 176 } 177 178 int 179 css_get_ssd_info(struct subchannel *sch) 180 { 181 int ret; 182 void *page; 183 184 page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 185 if (!page) 186 return -ENOMEM; 187 spin_lock_irq(&sch->lock); 188 ret = chsc_get_sch_desc_irq(sch, page); 189 if (ret) { 190 static int cio_chsc_err_msg; 191 192 if (!cio_chsc_err_msg) { 193 printk(KERN_ERR 194 "chsc_get_sch_descriptions:" 195 " Error %d while doing chsc; " 196 "processing some machine checks may " 197 "not work\n", ret); 198 cio_chsc_err_msg = 1; 199 } 200 } 201 spin_unlock_irq(&sch->lock); 202 free_page((unsigned long)page); 203 if (!ret) { 204 int j, chpid; 205 /* Allocate channel path structures, if needed. */ 206 for (j = 0; j < 8; j++) { 207 chpid = sch->ssd_info.chpid[j]; 208 if (chpid && (get_chp_status(chpid) < 0)) 209 new_channel_path(chpid); 210 } 211 } 212 return ret; 213 } 214 215 static int 216 s390_subchannel_remove_chpid(struct device *dev, void *data) 217 { 218 int j; 219 int mask; 220 struct subchannel *sch; 221 struct channel_path *chpid; 222 struct schib schib; 223 224 sch = to_subchannel(dev); 225 chpid = data; 226 for (j = 0; j < 8; j++) 227 if (sch->schib.pmcw.chpid[j] == chpid->id) 228 break; 229 if (j >= 8) 230 return 0; 231 232 mask = 0x80 >> j; 233 spin_lock_irq(&sch->lock); 234 235 stsch(sch->schid, &schib); 236 if (!schib.pmcw.dnv) 237 goto out_unreg; 238 memcpy(&sch->schib, &schib, sizeof(struct schib)); 239 /* Check for single path devices. */ 240 if (sch->schib.pmcw.pim == 0x80) 241 goto out_unreg; 242 if (sch->vpm == mask) 243 goto out_unreg; 244 245 if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) && 246 (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) && 247 (sch->schib.pmcw.lpum == mask) && 248 (sch->vpm == 0)) { 249 int cc; 250 251 cc = cio_clear(sch); 252 if (cc == -ENODEV) 253 goto out_unreg; 254 /* Call handler. */ 255 if (sch->driver && sch->driver->termination) 256 sch->driver->termination(&sch->dev); 257 goto out_unlock; 258 } 259 260 /* trigger path verification. */ 261 if (sch->driver && sch->driver->verify) 262 sch->driver->verify(&sch->dev); 263 out_unlock: 264 spin_unlock_irq(&sch->lock); 265 return 0; 266 out_unreg: 267 spin_unlock_irq(&sch->lock); 268 sch->lpm = 0; 269 if (css_enqueue_subchannel_slow(sch->schid)) { 270 css_clear_subchannel_slow_list(); 271 need_rescan = 1; 272 } 273 return 0; 274 } 275 276 static inline void 277 s390_set_chpid_offline( __u8 chpid) 278 { 279 char dbf_txt[15]; 280 struct device *dev; 281 282 sprintf(dbf_txt, "chpr%x", chpid); 283 CIO_TRACE_EVENT(2, dbf_txt); 284 285 if (get_chp_status(chpid) <= 0) 286 return; 287 dev = get_device(&css[0]->chps[chpid]->dev); 288 bus_for_each_dev(&css_bus_type, NULL, to_channelpath(dev), 289 s390_subchannel_remove_chpid); 290 291 if (need_rescan || css_slow_subchannels_exist()) 292 queue_work(slow_path_wq, &slow_path_work); 293 put_device(dev); 294 } 295 296 struct res_acc_data { 297 struct channel_path *chp; 298 u32 fla_mask; 299 u16 fla; 300 }; 301 302 static int 303 s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch) 304 { 305 int found; 306 int chp; 307 int ccode; 308 309 found = 0; 310 for (chp = 0; chp <= 7; chp++) 311 /* 312 * check if chpid is in information updated by ssd 313 */ 314 if (sch->ssd_info.valid && 315 sch->ssd_info.chpid[chp] == res_data->chp->id && 316 (sch->ssd_info.fla[chp] & res_data->fla_mask) 317 == res_data->fla) { 318 found = 1; 319 break; 320 } 321 322 if (found == 0) 323 return 0; 324 325 /* 326 * Do a stsch to update our subchannel structure with the 327 * new path information and eventually check for logically 328 * offline chpids. 329 */ 330 ccode = stsch(sch->schid, &sch->schib); 331 if (ccode > 0) 332 return 0; 333 334 return 0x80 >> chp; 335 } 336 337 static inline int 338 s390_process_res_acc_new_sch(struct subchannel_id schid) 339 { 340 struct schib schib; 341 int ret; 342 /* 343 * We don't know the device yet, but since a path 344 * may be available now to the device we'll have 345 * to do recognition again. 346 * Since we don't have any idea about which chpid 347 * that beast may be on we'll have to do a stsch 348 * on all devices, grr... 349 */ 350 if (stsch_err(schid, &schib)) 351 /* We're through */ 352 return need_rescan ? -EAGAIN : -ENXIO; 353 354 /* Put it on the slow path. */ 355 ret = css_enqueue_subchannel_slow(schid); 356 if (ret) { 357 css_clear_subchannel_slow_list(); 358 need_rescan = 1; 359 return -EAGAIN; 360 } 361 return 0; 362 } 363 364 static int 365 __s390_process_res_acc(struct subchannel_id schid, void *data) 366 { 367 int chp_mask, old_lpm; 368 struct res_acc_data *res_data; 369 struct subchannel *sch; 370 371 res_data = (struct res_acc_data *)data; 372 sch = get_subchannel_by_schid(schid); 373 if (!sch) 374 /* Check if a subchannel is newly available. */ 375 return s390_process_res_acc_new_sch(schid); 376 377 spin_lock_irq(&sch->lock); 378 379 chp_mask = s390_process_res_acc_sch(res_data, sch); 380 381 if (chp_mask == 0) { 382 spin_unlock_irq(&sch->lock); 383 return 0; 384 } 385 old_lpm = sch->lpm; 386 sch->lpm = ((sch->schib.pmcw.pim & 387 sch->schib.pmcw.pam & 388 sch->schib.pmcw.pom) 389 | chp_mask) & sch->opm; 390 if (!old_lpm && sch->lpm) 391 device_trigger_reprobe(sch); 392 else if (sch->driver && sch->driver->verify) 393 sch->driver->verify(&sch->dev); 394 395 spin_unlock_irq(&sch->lock); 396 put_device(&sch->dev); 397 return (res_data->fla_mask == 0xffff) ? -ENODEV : 0; 398 } 399 400 401 static int 402 s390_process_res_acc (struct res_acc_data *res_data) 403 { 404 int rc; 405 char dbf_txt[15]; 406 407 sprintf(dbf_txt, "accpr%x", res_data->chp->id); 408 CIO_TRACE_EVENT( 2, dbf_txt); 409 if (res_data->fla != 0) { 410 sprintf(dbf_txt, "fla%x", res_data->fla); 411 CIO_TRACE_EVENT( 2, dbf_txt); 412 } 413 414 /* 415 * I/O resources may have become accessible. 416 * Scan through all subchannels that may be concerned and 417 * do a validation on those. 418 * The more information we have (info), the less scanning 419 * will we have to do. 420 */ 421 rc = for_each_subchannel(__s390_process_res_acc, res_data); 422 if (css_slow_subchannels_exist()) 423 rc = -EAGAIN; 424 else if (rc != -EAGAIN) 425 rc = 0; 426 return rc; 427 } 428 429 static int 430 __get_chpid_from_lir(void *data) 431 { 432 struct lir { 433 u8 iq; 434 u8 ic; 435 u16 sci; 436 /* incident-node descriptor */ 437 u32 indesc[28]; 438 /* attached-node descriptor */ 439 u32 andesc[28]; 440 /* incident-specific information */ 441 u32 isinfo[28]; 442 } *lir; 443 444 lir = (struct lir*) data; 445 if (!(lir->iq&0x80)) 446 /* NULL link incident record */ 447 return -EINVAL; 448 if (!(lir->indesc[0]&0xc0000000)) 449 /* node descriptor not valid */ 450 return -EINVAL; 451 if (!(lir->indesc[0]&0x10000000)) 452 /* don't handle device-type nodes - FIXME */ 453 return -EINVAL; 454 /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */ 455 456 return (u16) (lir->indesc[0]&0x000000ff); 457 } 458 459 int 460 chsc_process_crw(void) 461 { 462 int chpid, ret; 463 struct res_acc_data res_data; 464 struct { 465 struct chsc_header request; 466 u32 reserved1; 467 u32 reserved2; 468 u32 reserved3; 469 struct chsc_header response; 470 u32 reserved4; 471 u8 flags; 472 u8 vf; /* validity flags */ 473 u8 rs; /* reporting source */ 474 u8 cc; /* content code */ 475 u16 fla; /* full link address */ 476 u16 rsid; /* reporting source id */ 477 u32 reserved5; 478 u32 reserved6; 479 u32 ccdf[96]; /* content-code dependent field */ 480 /* ccdf has to be big enough for a link-incident record */ 481 } *sei_area; 482 483 if (!sei_page) 484 return 0; 485 /* 486 * build the chsc request block for store event information 487 * and do the call 488 * This function is only called by the machine check handler thread, 489 * so we don't need locking for the sei_page. 490 */ 491 sei_area = sei_page; 492 493 CIO_TRACE_EVENT( 2, "prcss"); 494 ret = 0; 495 do { 496 int ccode, status; 497 struct device *dev; 498 memset(sei_area, 0, sizeof(*sei_area)); 499 memset(&res_data, 0, sizeof(struct res_acc_data)); 500 sei_area->request.length = 0x0010; 501 sei_area->request.code = 0x000e; 502 503 ccode = chsc(sei_area); 504 if (ccode > 0) 505 return 0; 506 507 switch (sei_area->response.code) { 508 /* for debug purposes, check for problems */ 509 case 0x0001: 510 CIO_CRW_EVENT(4, "chsc_process_crw: event information " 511 "successfully stored\n"); 512 break; /* everything ok */ 513 case 0x0002: 514 CIO_CRW_EVENT(2, 515 "chsc_process_crw: invalid command!\n"); 516 return 0; 517 case 0x0003: 518 CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc " 519 "request block!\n"); 520 return 0; 521 case 0x0005: 522 CIO_CRW_EVENT(2, "chsc_process_crw: no event " 523 "information stored\n"); 524 return 0; 525 default: 526 CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n", 527 sei_area->response.code); 528 return 0; 529 } 530 531 /* Check if we might have lost some information. */ 532 if (sei_area->flags & 0x40) 533 CIO_CRW_EVENT(2, "chsc_process_crw: Event information " 534 "has been lost due to overflow!\n"); 535 536 if (sei_area->rs != 4) { 537 CIO_CRW_EVENT(2, "chsc_process_crw: reporting source " 538 "(%04X) isn't a chpid!\n", 539 sei_area->rsid); 540 continue; 541 } 542 543 /* which kind of information was stored? */ 544 switch (sei_area->cc) { 545 case 1: /* link incident*/ 546 CIO_CRW_EVENT(4, "chsc_process_crw: " 547 "channel subsystem reports link incident," 548 " reporting source is chpid %x\n", 549 sei_area->rsid); 550 chpid = __get_chpid_from_lir(sei_area->ccdf); 551 if (chpid < 0) 552 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n", 553 __FUNCTION__); 554 else 555 s390_set_chpid_offline(chpid); 556 break; 557 558 case 2: /* i/o resource accessibiliy */ 559 CIO_CRW_EVENT(4, "chsc_process_crw: " 560 "channel subsystem reports some I/O " 561 "devices may have become accessible\n"); 562 pr_debug("Data received after sei: \n"); 563 pr_debug("Validity flags: %x\n", sei_area->vf); 564 565 /* allocate a new channel path structure, if needed */ 566 status = get_chp_status(sei_area->rsid); 567 if (status < 0) 568 new_channel_path(sei_area->rsid); 569 else if (!status) 570 break; 571 dev = get_device(&css[0]->chps[sei_area->rsid]->dev); 572 res_data.chp = to_channelpath(dev); 573 pr_debug("chpid: %x", sei_area->rsid); 574 if ((sei_area->vf & 0xc0) != 0) { 575 res_data.fla = sei_area->fla; 576 if ((sei_area->vf & 0xc0) == 0xc0) { 577 pr_debug(" full link addr: %x", 578 sei_area->fla); 579 res_data.fla_mask = 0xffff; 580 } else { 581 pr_debug(" link addr: %x", 582 sei_area->fla); 583 res_data.fla_mask = 0xff00; 584 } 585 } 586 ret = s390_process_res_acc(&res_data); 587 pr_debug("\n\n"); 588 put_device(dev); 589 break; 590 591 default: /* other stuff */ 592 CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n", 593 sei_area->cc); 594 break; 595 } 596 } while (sei_area->flags & 0x80); 597 return ret; 598 } 599 600 static inline int 601 __chp_add_new_sch(struct subchannel_id schid) 602 { 603 struct schib schib; 604 int ret; 605 606 if (stsch(schid, &schib)) 607 /* We're through */ 608 return need_rescan ? -EAGAIN : -ENXIO; 609 610 /* Put it on the slow path. */ 611 ret = css_enqueue_subchannel_slow(schid); 612 if (ret) { 613 css_clear_subchannel_slow_list(); 614 need_rescan = 1; 615 return -EAGAIN; 616 } 617 return 0; 618 } 619 620 621 static int 622 __chp_add(struct subchannel_id schid, void *data) 623 { 624 int i; 625 struct channel_path *chp; 626 struct subchannel *sch; 627 628 chp = (struct channel_path *)data; 629 sch = get_subchannel_by_schid(schid); 630 if (!sch) 631 /* Check if the subchannel is now available. */ 632 return __chp_add_new_sch(schid); 633 spin_lock_irq(&sch->lock); 634 for (i=0; i<8; i++) 635 if (sch->schib.pmcw.chpid[i] == chp->id) { 636 if (stsch(sch->schid, &sch->schib) != 0) { 637 /* Endgame. */ 638 spin_unlock_irq(&sch->lock); 639 return -ENXIO; 640 } 641 break; 642 } 643 if (i==8) { 644 spin_unlock_irq(&sch->lock); 645 return 0; 646 } 647 sch->lpm = ((sch->schib.pmcw.pim & 648 sch->schib.pmcw.pam & 649 sch->schib.pmcw.pom) 650 | 0x80 >> i) & sch->opm; 651 652 if (sch->driver && sch->driver->verify) 653 sch->driver->verify(&sch->dev); 654 655 spin_unlock_irq(&sch->lock); 656 put_device(&sch->dev); 657 return 0; 658 } 659 660 static int 661 chp_add(int chpid) 662 { 663 int rc; 664 char dbf_txt[15]; 665 struct device *dev; 666 667 if (!get_chp_status(chpid)) 668 return 0; /* no need to do the rest */ 669 670 sprintf(dbf_txt, "cadd%x", chpid); 671 CIO_TRACE_EVENT(2, dbf_txt); 672 673 dev = get_device(&css[0]->chps[chpid]->dev); 674 rc = for_each_subchannel(__chp_add, to_channelpath(dev)); 675 if (css_slow_subchannels_exist()) 676 rc = -EAGAIN; 677 if (rc != -EAGAIN) 678 rc = 0; 679 put_device(dev); 680 return rc; 681 } 682 683 /* 684 * Handling of crw machine checks with channel path source. 685 */ 686 int 687 chp_process_crw(int chpid, int on) 688 { 689 if (on == 0) { 690 /* Path has gone. We use the link incident routine.*/ 691 s390_set_chpid_offline(chpid); 692 return 0; /* De-register is async anyway. */ 693 } 694 /* 695 * Path has come. Allocate a new channel path structure, 696 * if needed. 697 */ 698 if (get_chp_status(chpid) < 0) 699 new_channel_path(chpid); 700 /* Avoid the extra overhead in process_rec_acc. */ 701 return chp_add(chpid); 702 } 703 704 static inline int 705 __check_for_io_and_kill(struct subchannel *sch, int index) 706 { 707 int cc; 708 709 if (!device_is_online(sch)) 710 /* cio could be doing I/O. */ 711 return 0; 712 cc = stsch(sch->schid, &sch->schib); 713 if (cc) 714 return 0; 715 if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index)) { 716 device_set_waiting(sch); 717 return 1; 718 } 719 return 0; 720 } 721 722 static inline void 723 __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on) 724 { 725 int chp, old_lpm; 726 unsigned long flags; 727 728 if (!sch->ssd_info.valid) 729 return; 730 731 spin_lock_irqsave(&sch->lock, flags); 732 old_lpm = sch->lpm; 733 for (chp = 0; chp < 8; chp++) { 734 if (sch->ssd_info.chpid[chp] != chpid) 735 continue; 736 737 if (on) { 738 sch->opm |= (0x80 >> chp); 739 sch->lpm |= (0x80 >> chp); 740 if (!old_lpm) 741 device_trigger_reprobe(sch); 742 else if (sch->driver && sch->driver->verify) 743 sch->driver->verify(&sch->dev); 744 } else { 745 sch->opm &= ~(0x80 >> chp); 746 sch->lpm &= ~(0x80 >> chp); 747 /* 748 * Give running I/O a grace period in which it 749 * can successfully terminate, even using the 750 * just varied off path. Then kill it. 751 */ 752 if (!__check_for_io_and_kill(sch, chp) && !sch->lpm) { 753 if (css_enqueue_subchannel_slow(sch->schid)) { 754 css_clear_subchannel_slow_list(); 755 need_rescan = 1; 756 } 757 } else if (sch->driver && sch->driver->verify) 758 sch->driver->verify(&sch->dev); 759 } 760 break; 761 } 762 spin_unlock_irqrestore(&sch->lock, flags); 763 } 764 765 static int 766 s390_subchannel_vary_chpid_off(struct device *dev, void *data) 767 { 768 struct subchannel *sch; 769 __u8 *chpid; 770 771 sch = to_subchannel(dev); 772 chpid = data; 773 774 __s390_subchannel_vary_chpid(sch, *chpid, 0); 775 return 0; 776 } 777 778 static int 779 s390_subchannel_vary_chpid_on(struct device *dev, void *data) 780 { 781 struct subchannel *sch; 782 __u8 *chpid; 783 784 sch = to_subchannel(dev); 785 chpid = data; 786 787 __s390_subchannel_vary_chpid(sch, *chpid, 1); 788 return 0; 789 } 790 791 static int 792 __s390_vary_chpid_on(struct subchannel_id schid, void *data) 793 { 794 struct schib schib; 795 struct subchannel *sch; 796 797 sch = get_subchannel_by_schid(schid); 798 if (sch) { 799 put_device(&sch->dev); 800 return 0; 801 } 802 if (stsch_err(schid, &schib)) 803 /* We're through */ 804 return -ENXIO; 805 /* Put it on the slow path. */ 806 if (css_enqueue_subchannel_slow(schid)) { 807 css_clear_subchannel_slow_list(); 808 need_rescan = 1; 809 return -EAGAIN; 810 } 811 return 0; 812 } 813 814 /* 815 * Function: s390_vary_chpid 816 * Varies the specified chpid online or offline 817 */ 818 static int 819 s390_vary_chpid( __u8 chpid, int on) 820 { 821 char dbf_text[15]; 822 int status; 823 824 sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid); 825 CIO_TRACE_EVENT( 2, dbf_text); 826 827 status = get_chp_status(chpid); 828 if (status < 0) { 829 printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid); 830 return -EINVAL; 831 } 832 833 if (!on && !status) { 834 printk(KERN_ERR "chpid %x is already offline\n", chpid); 835 return -EINVAL; 836 } 837 838 set_chp_logically_online(chpid, on); 839 840 /* 841 * Redo PathVerification on the devices the chpid connects to 842 */ 843 844 bus_for_each_dev(&css_bus_type, NULL, &chpid, on ? 845 s390_subchannel_vary_chpid_on : 846 s390_subchannel_vary_chpid_off); 847 if (on) 848 /* Scan for new devices on varied on path. */ 849 for_each_subchannel(__s390_vary_chpid_on, NULL); 850 if (need_rescan || css_slow_subchannels_exist()) 851 queue_work(slow_path_wq, &slow_path_work); 852 return 0; 853 } 854 855 /* 856 * Channel measurement related functions 857 */ 858 static ssize_t 859 chp_measurement_chars_read(struct kobject *kobj, char *buf, loff_t off, 860 size_t count) 861 { 862 struct channel_path *chp; 863 unsigned int size; 864 865 chp = to_channelpath(container_of(kobj, struct device, kobj)); 866 if (!chp->cmg_chars) 867 return 0; 868 869 size = sizeof(struct cmg_chars); 870 871 if (off > size) 872 return 0; 873 if (off + count > size) 874 count = size - off; 875 memcpy(buf, chp->cmg_chars + off, count); 876 return count; 877 } 878 879 static struct bin_attribute chp_measurement_chars_attr = { 880 .attr = { 881 .name = "measurement_chars", 882 .mode = S_IRUSR, 883 .owner = THIS_MODULE, 884 }, 885 .size = sizeof(struct cmg_chars), 886 .read = chp_measurement_chars_read, 887 }; 888 889 static void 890 chp_measurement_copy_block(struct cmg_entry *buf, 891 struct channel_subsystem *css, int chpid) 892 { 893 void *area; 894 struct cmg_entry *entry, reference_buf; 895 int idx; 896 897 if (chpid < 128) { 898 area = css->cub_addr1; 899 idx = chpid; 900 } else { 901 area = css->cub_addr2; 902 idx = chpid - 128; 903 } 904 entry = area + (idx * sizeof(struct cmg_entry)); 905 do { 906 memcpy(buf, entry, sizeof(*entry)); 907 memcpy(&reference_buf, entry, sizeof(*entry)); 908 } while (reference_buf.values[0] != buf->values[0]); 909 } 910 911 static ssize_t 912 chp_measurement_read(struct kobject *kobj, char *buf, loff_t off, size_t count) 913 { 914 struct channel_path *chp; 915 struct channel_subsystem *css; 916 unsigned int size; 917 918 chp = to_channelpath(container_of(kobj, struct device, kobj)); 919 css = to_css(chp->dev.parent); 920 921 size = sizeof(struct cmg_chars); 922 923 /* Only allow single reads. */ 924 if (off || count < size) 925 return 0; 926 chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->id); 927 return count; 928 } 929 930 static struct bin_attribute chp_measurement_attr = { 931 .attr = { 932 .name = "measurement", 933 .mode = S_IRUSR, 934 .owner = THIS_MODULE, 935 }, 936 .size = sizeof(struct cmg_entry), 937 .read = chp_measurement_read, 938 }; 939 940 static void 941 chsc_remove_chp_cmg_attr(struct channel_path *chp) 942 { 943 sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr); 944 sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr); 945 } 946 947 static int 948 chsc_add_chp_cmg_attr(struct channel_path *chp) 949 { 950 int ret; 951 952 ret = sysfs_create_bin_file(&chp->dev.kobj, 953 &chp_measurement_chars_attr); 954 if (ret) 955 return ret; 956 ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr); 957 if (ret) 958 sysfs_remove_bin_file(&chp->dev.kobj, 959 &chp_measurement_chars_attr); 960 return ret; 961 } 962 963 static void 964 chsc_remove_cmg_attr(struct channel_subsystem *css) 965 { 966 int i; 967 968 for (i = 0; i <= __MAX_CHPID; i++) { 969 if (!css->chps[i]) 970 continue; 971 chsc_remove_chp_cmg_attr(css->chps[i]); 972 } 973 } 974 975 static int 976 chsc_add_cmg_attr(struct channel_subsystem *css) 977 { 978 int i, ret; 979 980 ret = 0; 981 for (i = 0; i <= __MAX_CHPID; i++) { 982 if (!css->chps[i]) 983 continue; 984 ret = chsc_add_chp_cmg_attr(css->chps[i]); 985 if (ret) 986 goto cleanup; 987 } 988 return ret; 989 cleanup: 990 for (--i; i >= 0; i--) { 991 if (!css->chps[i]) 992 continue; 993 chsc_remove_chp_cmg_attr(css->chps[i]); 994 } 995 return ret; 996 } 997 998 999 static int 1000 __chsc_do_secm(struct channel_subsystem *css, int enable, void *page) 1001 { 1002 struct { 1003 struct chsc_header request; 1004 u32 operation_code : 2; 1005 u32 : 30; 1006 u32 key : 4; 1007 u32 : 28; 1008 u32 zeroes1; 1009 u32 cub_addr1; 1010 u32 zeroes2; 1011 u32 cub_addr2; 1012 u32 reserved[13]; 1013 struct chsc_header response; 1014 u32 status : 8; 1015 u32 : 4; 1016 u32 fmt : 4; 1017 u32 : 16; 1018 } *secm_area; 1019 int ret, ccode; 1020 1021 secm_area = page; 1022 secm_area->request.length = 0x0050; 1023 secm_area->request.code = 0x0016; 1024 1025 secm_area->key = PAGE_DEFAULT_KEY; 1026 secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1; 1027 secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2; 1028 1029 secm_area->operation_code = enable ? 0 : 1; 1030 1031 ccode = chsc(secm_area); 1032 if (ccode > 0) 1033 return (ccode == 3) ? -ENODEV : -EBUSY; 1034 1035 switch (secm_area->response.code) { 1036 case 0x0001: /* Success. */ 1037 ret = 0; 1038 break; 1039 case 0x0003: /* Invalid block. */ 1040 case 0x0007: /* Invalid format. */ 1041 case 0x0008: /* Other invalid block. */ 1042 CIO_CRW_EVENT(2, "Error in chsc request block!\n"); 1043 ret = -EINVAL; 1044 break; 1045 case 0x0004: /* Command not provided in model. */ 1046 CIO_CRW_EVENT(2, "Model does not provide secm\n"); 1047 ret = -EOPNOTSUPP; 1048 break; 1049 case 0x0102: /* cub adresses incorrect */ 1050 CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n"); 1051 ret = -EINVAL; 1052 break; 1053 case 0x0103: /* key error */ 1054 CIO_CRW_EVENT(2, "Access key error in secm\n"); 1055 ret = -EINVAL; 1056 break; 1057 case 0x0105: /* error while starting */ 1058 CIO_CRW_EVENT(2, "Error while starting channel measurement\n"); 1059 ret = -EIO; 1060 break; 1061 default: 1062 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n", 1063 secm_area->response.code); 1064 ret = -EIO; 1065 } 1066 return ret; 1067 } 1068 1069 int 1070 chsc_secm(struct channel_subsystem *css, int enable) 1071 { 1072 void *secm_area; 1073 int ret; 1074 1075 secm_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1076 if (!secm_area) 1077 return -ENOMEM; 1078 1079 mutex_lock(&css->mutex); 1080 if (enable && !css->cm_enabled) { 1081 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1082 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1083 if (!css->cub_addr1 || !css->cub_addr2) { 1084 free_page((unsigned long)css->cub_addr1); 1085 free_page((unsigned long)css->cub_addr2); 1086 free_page((unsigned long)secm_area); 1087 mutex_unlock(&css->mutex); 1088 return -ENOMEM; 1089 } 1090 } 1091 ret = __chsc_do_secm(css, enable, secm_area); 1092 if (!ret) { 1093 css->cm_enabled = enable; 1094 if (css->cm_enabled) { 1095 ret = chsc_add_cmg_attr(css); 1096 if (ret) { 1097 memset(secm_area, 0, PAGE_SIZE); 1098 __chsc_do_secm(css, 0, secm_area); 1099 css->cm_enabled = 0; 1100 } 1101 } else 1102 chsc_remove_cmg_attr(css); 1103 } 1104 if (enable && !css->cm_enabled) { 1105 free_page((unsigned long)css->cub_addr1); 1106 free_page((unsigned long)css->cub_addr2); 1107 } 1108 mutex_unlock(&css->mutex); 1109 free_page((unsigned long)secm_area); 1110 return ret; 1111 } 1112 1113 /* 1114 * Files for the channel path entries. 1115 */ 1116 static ssize_t 1117 chp_status_show(struct device *dev, struct device_attribute *attr, char *buf) 1118 { 1119 struct channel_path *chp = container_of(dev, struct channel_path, dev); 1120 1121 if (!chp) 1122 return 0; 1123 return (get_chp_status(chp->id) ? sprintf(buf, "online\n") : 1124 sprintf(buf, "offline\n")); 1125 } 1126 1127 static ssize_t 1128 chp_status_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) 1129 { 1130 struct channel_path *cp = container_of(dev, struct channel_path, dev); 1131 char cmd[10]; 1132 int num_args; 1133 int error; 1134 1135 num_args = sscanf(buf, "%5s", cmd); 1136 if (!num_args) 1137 return count; 1138 1139 if (!strnicmp(cmd, "on", 2)) 1140 error = s390_vary_chpid(cp->id, 1); 1141 else if (!strnicmp(cmd, "off", 3)) 1142 error = s390_vary_chpid(cp->id, 0); 1143 else 1144 error = -EINVAL; 1145 1146 return error < 0 ? error : count; 1147 1148 } 1149 1150 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write); 1151 1152 static ssize_t 1153 chp_type_show(struct device *dev, struct device_attribute *attr, char *buf) 1154 { 1155 struct channel_path *chp = container_of(dev, struct channel_path, dev); 1156 1157 if (!chp) 1158 return 0; 1159 return sprintf(buf, "%x\n", chp->desc.desc); 1160 } 1161 1162 static DEVICE_ATTR(type, 0444, chp_type_show, NULL); 1163 1164 static ssize_t 1165 chp_cmg_show(struct device *dev, struct device_attribute *attr, char *buf) 1166 { 1167 struct channel_path *chp = to_channelpath(dev); 1168 1169 if (!chp) 1170 return 0; 1171 if (chp->cmg == -1) /* channel measurements not available */ 1172 return sprintf(buf, "unknown\n"); 1173 return sprintf(buf, "%x\n", chp->cmg); 1174 } 1175 1176 static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL); 1177 1178 static ssize_t 1179 chp_shared_show(struct device *dev, struct device_attribute *attr, char *buf) 1180 { 1181 struct channel_path *chp = to_channelpath(dev); 1182 1183 if (!chp) 1184 return 0; 1185 if (chp->shared == -1) /* channel measurements not available */ 1186 return sprintf(buf, "unknown\n"); 1187 return sprintf(buf, "%x\n", chp->shared); 1188 } 1189 1190 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL); 1191 1192 static struct attribute * chp_attrs[] = { 1193 &dev_attr_status.attr, 1194 &dev_attr_type.attr, 1195 &dev_attr_cmg.attr, 1196 &dev_attr_shared.attr, 1197 NULL, 1198 }; 1199 1200 static struct attribute_group chp_attr_group = { 1201 .attrs = chp_attrs, 1202 }; 1203 1204 static void 1205 chp_release(struct device *dev) 1206 { 1207 struct channel_path *cp; 1208 1209 cp = container_of(dev, struct channel_path, dev); 1210 kfree(cp); 1211 } 1212 1213 static int 1214 chsc_determine_channel_path_description(int chpid, 1215 struct channel_path_desc *desc) 1216 { 1217 int ccode, ret; 1218 1219 struct { 1220 struct chsc_header request; 1221 u32 : 24; 1222 u32 first_chpid : 8; 1223 u32 : 24; 1224 u32 last_chpid : 8; 1225 u32 zeroes1; 1226 struct chsc_header response; 1227 u32 zeroes2; 1228 struct channel_path_desc desc; 1229 } *scpd_area; 1230 1231 scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1232 if (!scpd_area) 1233 return -ENOMEM; 1234 1235 scpd_area->request.length = 0x0010; 1236 scpd_area->request.code = 0x0002; 1237 1238 scpd_area->first_chpid = chpid; 1239 scpd_area->last_chpid = chpid; 1240 1241 ccode = chsc(scpd_area); 1242 if (ccode > 0) { 1243 ret = (ccode == 3) ? -ENODEV : -EBUSY; 1244 goto out; 1245 } 1246 1247 switch (scpd_area->response.code) { 1248 case 0x0001: /* Success. */ 1249 memcpy(desc, &scpd_area->desc, 1250 sizeof(struct channel_path_desc)); 1251 ret = 0; 1252 break; 1253 case 0x0003: /* Invalid block. */ 1254 case 0x0007: /* Invalid format. */ 1255 case 0x0008: /* Other invalid block. */ 1256 CIO_CRW_EVENT(2, "Error in chsc request block!\n"); 1257 ret = -EINVAL; 1258 break; 1259 case 0x0004: /* Command not provided in model. */ 1260 CIO_CRW_EVENT(2, "Model does not provide scpd\n"); 1261 ret = -EOPNOTSUPP; 1262 break; 1263 default: 1264 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n", 1265 scpd_area->response.code); 1266 ret = -EIO; 1267 } 1268 out: 1269 free_page((unsigned long)scpd_area); 1270 return ret; 1271 } 1272 1273 static void 1274 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv, 1275 struct cmg_chars *chars) 1276 { 1277 switch (chp->cmg) { 1278 case 2: 1279 case 3: 1280 chp->cmg_chars = kmalloc(sizeof(struct cmg_chars), 1281 GFP_KERNEL); 1282 if (chp->cmg_chars) { 1283 int i, mask; 1284 struct cmg_chars *cmg_chars; 1285 1286 cmg_chars = chp->cmg_chars; 1287 for (i = 0; i < NR_MEASUREMENT_CHARS; i++) { 1288 mask = 0x80 >> (i + 3); 1289 if (cmcv & mask) 1290 cmg_chars->values[i] = chars->values[i]; 1291 else 1292 cmg_chars->values[i] = 0; 1293 } 1294 } 1295 break; 1296 default: 1297 /* No cmg-dependent data. */ 1298 break; 1299 } 1300 } 1301 1302 static int 1303 chsc_get_channel_measurement_chars(struct channel_path *chp) 1304 { 1305 int ccode, ret; 1306 1307 struct { 1308 struct chsc_header request; 1309 u32 : 24; 1310 u32 first_chpid : 8; 1311 u32 : 24; 1312 u32 last_chpid : 8; 1313 u32 zeroes1; 1314 struct chsc_header response; 1315 u32 zeroes2; 1316 u32 not_valid : 1; 1317 u32 shared : 1; 1318 u32 : 22; 1319 u32 chpid : 8; 1320 u32 cmcv : 5; 1321 u32 : 11; 1322 u32 cmgq : 8; 1323 u32 cmg : 8; 1324 u32 zeroes3; 1325 u32 data[NR_MEASUREMENT_CHARS]; 1326 } *scmc_area; 1327 1328 scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1329 if (!scmc_area) 1330 return -ENOMEM; 1331 1332 scmc_area->request.length = 0x0010; 1333 scmc_area->request.code = 0x0022; 1334 1335 scmc_area->first_chpid = chp->id; 1336 scmc_area->last_chpid = chp->id; 1337 1338 ccode = chsc(scmc_area); 1339 if (ccode > 0) { 1340 ret = (ccode == 3) ? -ENODEV : -EBUSY; 1341 goto out; 1342 } 1343 1344 switch (scmc_area->response.code) { 1345 case 0x0001: /* Success. */ 1346 if (!scmc_area->not_valid) { 1347 chp->cmg = scmc_area->cmg; 1348 chp->shared = scmc_area->shared; 1349 chsc_initialize_cmg_chars(chp, scmc_area->cmcv, 1350 (struct cmg_chars *) 1351 &scmc_area->data); 1352 } else { 1353 chp->cmg = -1; 1354 chp->shared = -1; 1355 } 1356 ret = 0; 1357 break; 1358 case 0x0003: /* Invalid block. */ 1359 case 0x0007: /* Invalid format. */ 1360 case 0x0008: /* Invalid bit combination. */ 1361 CIO_CRW_EVENT(2, "Error in chsc request block!\n"); 1362 ret = -EINVAL; 1363 break; 1364 case 0x0004: /* Command not provided. */ 1365 CIO_CRW_EVENT(2, "Model does not provide scmc\n"); 1366 ret = -EOPNOTSUPP; 1367 break; 1368 default: 1369 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n", 1370 scmc_area->response.code); 1371 ret = -EIO; 1372 } 1373 out: 1374 free_page((unsigned long)scmc_area); 1375 return ret; 1376 } 1377 1378 /* 1379 * Entries for chpids on the system bus. 1380 * This replaces /proc/chpids. 1381 */ 1382 static int 1383 new_channel_path(int chpid) 1384 { 1385 struct channel_path *chp; 1386 int ret; 1387 1388 chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL); 1389 if (!chp) 1390 return -ENOMEM; 1391 1392 /* fill in status, etc. */ 1393 chp->id = chpid; 1394 chp->state = 1; 1395 chp->dev = (struct device) { 1396 .parent = &css[0]->device, 1397 .release = chp_release, 1398 }; 1399 snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid); 1400 1401 /* Obtain channel path description and fill it in. */ 1402 ret = chsc_determine_channel_path_description(chpid, &chp->desc); 1403 if (ret) 1404 goto out_free; 1405 /* Get channel-measurement characteristics. */ 1406 if (css_characteristics_avail && css_chsc_characteristics.scmc 1407 && css_chsc_characteristics.secm) { 1408 ret = chsc_get_channel_measurement_chars(chp); 1409 if (ret) 1410 goto out_free; 1411 } else { 1412 static int msg_done; 1413 1414 if (!msg_done) { 1415 printk(KERN_WARNING "cio: Channel measurements not " 1416 "available, continuing.\n"); 1417 msg_done = 1; 1418 } 1419 chp->cmg = -1; 1420 } 1421 1422 /* make it known to the system */ 1423 ret = device_register(&chp->dev); 1424 if (ret) { 1425 printk(KERN_WARNING "%s: could not register %02x\n", 1426 __func__, chpid); 1427 goto out_free; 1428 } 1429 ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group); 1430 if (ret) { 1431 device_unregister(&chp->dev); 1432 goto out_free; 1433 } 1434 mutex_lock(&css[0]->mutex); 1435 if (css[0]->cm_enabled) { 1436 ret = chsc_add_chp_cmg_attr(chp); 1437 if (ret) { 1438 sysfs_remove_group(&chp->dev.kobj, &chp_attr_group); 1439 device_unregister(&chp->dev); 1440 mutex_unlock(&css[0]->mutex); 1441 goto out_free; 1442 } 1443 } 1444 css[0]->chps[chpid] = chp; 1445 mutex_unlock(&css[0]->mutex); 1446 return ret; 1447 out_free: 1448 kfree(chp); 1449 return ret; 1450 } 1451 1452 void * 1453 chsc_get_chp_desc(struct subchannel *sch, int chp_no) 1454 { 1455 struct channel_path *chp; 1456 struct channel_path_desc *desc; 1457 1458 chp = css[0]->chps[sch->schib.pmcw.chpid[chp_no]]; 1459 if (!chp) 1460 return NULL; 1461 desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL); 1462 if (!desc) 1463 return NULL; 1464 memcpy(desc, &chp->desc, sizeof(struct channel_path_desc)); 1465 return desc; 1466 } 1467 1468 1469 static int __init 1470 chsc_alloc_sei_area(void) 1471 { 1472 sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1473 if (!sei_page) 1474 printk(KERN_WARNING"Can't allocate page for processing of " \ 1475 "chsc machine checks!\n"); 1476 return (sei_page ? 0 : -ENOMEM); 1477 } 1478 1479 int __init 1480 chsc_enable_facility(int operation_code) 1481 { 1482 int ret; 1483 struct { 1484 struct chsc_header request; 1485 u8 reserved1:4; 1486 u8 format:4; 1487 u8 reserved2; 1488 u16 operation_code; 1489 u32 reserved3; 1490 u32 reserved4; 1491 u32 operation_data_area[252]; 1492 struct chsc_header response; 1493 u32 reserved5:4; 1494 u32 format2:4; 1495 u32 reserved6:24; 1496 } *sda_area; 1497 1498 sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA); 1499 if (!sda_area) 1500 return -ENOMEM; 1501 sda_area->request.length = 0x0400; 1502 sda_area->request.code = 0x0031; 1503 sda_area->operation_code = operation_code; 1504 1505 ret = chsc(sda_area); 1506 if (ret > 0) { 1507 ret = (ret == 3) ? -ENODEV : -EBUSY; 1508 goto out; 1509 } 1510 switch (sda_area->response.code) { 1511 case 0x0001: /* everything ok */ 1512 ret = 0; 1513 break; 1514 case 0x0003: /* invalid request block */ 1515 case 0x0007: 1516 ret = -EINVAL; 1517 break; 1518 case 0x0004: /* command not provided */ 1519 case 0x0101: /* facility not provided */ 1520 ret = -EOPNOTSUPP; 1521 break; 1522 default: /* something went wrong */ 1523 ret = -EIO; 1524 } 1525 out: 1526 free_page((unsigned long)sda_area); 1527 return ret; 1528 } 1529 1530 subsys_initcall(chsc_alloc_sei_area); 1531 1532 struct css_general_char css_general_characteristics; 1533 struct css_chsc_char css_chsc_characteristics; 1534 1535 int __init 1536 chsc_determine_css_characteristics(void) 1537 { 1538 int result; 1539 struct { 1540 struct chsc_header request; 1541 u32 reserved1; 1542 u32 reserved2; 1543 u32 reserved3; 1544 struct chsc_header response; 1545 u32 reserved4; 1546 u32 general_char[510]; 1547 u32 chsc_char[518]; 1548 } *scsc_area; 1549 1550 scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA); 1551 if (!scsc_area) { 1552 printk(KERN_WARNING"cio: Was not able to determine available" \ 1553 "CHSCs due to no memory.\n"); 1554 return -ENOMEM; 1555 } 1556 1557 scsc_area->request.length = 0x0010; 1558 scsc_area->request.code = 0x0010; 1559 1560 result = chsc(scsc_area); 1561 if (result) { 1562 printk(KERN_WARNING"cio: Was not able to determine " \ 1563 "available CHSCs, cc=%i.\n", result); 1564 result = -EIO; 1565 goto exit; 1566 } 1567 1568 if (scsc_area->response.code != 1) { 1569 printk(KERN_WARNING"cio: Was not able to determine " \ 1570 "available CHSCs.\n"); 1571 result = -EIO; 1572 goto exit; 1573 } 1574 memcpy(&css_general_characteristics, scsc_area->general_char, 1575 sizeof(css_general_characteristics)); 1576 memcpy(&css_chsc_characteristics, scsc_area->chsc_char, 1577 sizeof(css_chsc_characteristics)); 1578 exit: 1579 free_page ((unsigned long) scsc_area); 1580 return result; 1581 } 1582 1583 EXPORT_SYMBOL_GPL(css_general_characteristics); 1584 EXPORT_SYMBOL_GPL(css_chsc_characteristics); 1585