1 /* 2 * S/390 common I/O routines -- low level i/o calls 3 * 4 * Copyright IBM Corp. 1999, 2008 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 * Martin Schwidefsky (schwidefsky@de.ibm.com) 9 */ 10 11 #define KMSG_COMPONENT "cio" 12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 13 14 #include <linux/ftrace.h> 15 #include <linux/module.h> 16 #include <linux/init.h> 17 #include <linux/slab.h> 18 #include <linux/device.h> 19 #include <linux/kernel_stat.h> 20 #include <linux/interrupt.h> 21 #include <asm/cio.h> 22 #include <asm/delay.h> 23 #include <asm/irq.h> 24 #include <asm/irq_regs.h> 25 #include <asm/setup.h> 26 #include <asm/reset.h> 27 #include <asm/ipl.h> 28 #include <asm/chpid.h> 29 #include <asm/airq.h> 30 #include <asm/isc.h> 31 #include <asm/cputime.h> 32 #include <asm/fcx.h> 33 #include <asm/nmi.h> 34 #include <asm/crw.h> 35 #include "cio.h" 36 #include "css.h" 37 #include "chsc.h" 38 #include "ioasm.h" 39 #include "io_sch.h" 40 #include "blacklist.h" 41 #include "cio_debug.h" 42 #include "chp.h" 43 44 debug_info_t *cio_debug_msg_id; 45 debug_info_t *cio_debug_trace_id; 46 debug_info_t *cio_debug_crw_id; 47 48 /* 49 * Function: cio_debug_init 50 * Initializes three debug logs for common I/O: 51 * - cio_msg logs generic cio messages 52 * - cio_trace logs the calling of different functions 53 * - cio_crw logs machine check related cio messages 54 */ 55 static int __init cio_debug_init(void) 56 { 57 cio_debug_msg_id = debug_register("cio_msg", 16, 1, 16 * sizeof(long)); 58 if (!cio_debug_msg_id) 59 goto out_unregister; 60 debug_register_view(cio_debug_msg_id, &debug_sprintf_view); 61 debug_set_level(cio_debug_msg_id, 2); 62 cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16); 63 if (!cio_debug_trace_id) 64 goto out_unregister; 65 debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view); 66 debug_set_level(cio_debug_trace_id, 2); 67 cio_debug_crw_id = debug_register("cio_crw", 16, 1, 16 * sizeof(long)); 68 if (!cio_debug_crw_id) 69 goto out_unregister; 70 debug_register_view(cio_debug_crw_id, &debug_sprintf_view); 71 debug_set_level(cio_debug_crw_id, 4); 72 return 0; 73 74 out_unregister: 75 if (cio_debug_msg_id) 76 debug_unregister(cio_debug_msg_id); 77 if (cio_debug_trace_id) 78 debug_unregister(cio_debug_trace_id); 79 if (cio_debug_crw_id) 80 debug_unregister(cio_debug_crw_id); 81 return -1; 82 } 83 84 arch_initcall (cio_debug_init); 85 86 int cio_set_options(struct subchannel *sch, int flags) 87 { 88 struct io_subchannel_private *priv = to_io_private(sch); 89 90 priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0; 91 priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0; 92 priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0; 93 return 0; 94 } 95 96 static int 97 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm) 98 { 99 char dbf_text[15]; 100 101 if (lpm != 0) 102 sch->lpm &= ~lpm; 103 else 104 sch->lpm = 0; 105 106 CIO_MSG_EVENT(2, "cio_start: 'not oper' status for " 107 "subchannel 0.%x.%04x!\n", sch->schid.ssid, 108 sch->schid.sch_no); 109 110 if (cio_update_schib(sch)) 111 return -ENODEV; 112 113 sprintf(dbf_text, "no%s", dev_name(&sch->dev)); 114 CIO_TRACE_EVENT(0, dbf_text); 115 CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib)); 116 117 return (sch->lpm ? -EACCES : -ENODEV); 118 } 119 120 int 121 cio_start_key (struct subchannel *sch, /* subchannel structure */ 122 struct ccw1 * cpa, /* logical channel prog addr */ 123 __u8 lpm, /* logical path mask */ 124 __u8 key) /* storage key */ 125 { 126 struct io_subchannel_private *priv = to_io_private(sch); 127 union orb *orb = &priv->orb; 128 int ccode; 129 130 CIO_TRACE_EVENT(5, "stIO"); 131 CIO_TRACE_EVENT(5, dev_name(&sch->dev)); 132 133 memset(orb, 0, sizeof(union orb)); 134 /* sch is always under 2G. */ 135 orb->cmd.intparm = (u32)(addr_t)sch; 136 orb->cmd.fmt = 1; 137 138 orb->cmd.pfch = priv->options.prefetch == 0; 139 orb->cmd.spnd = priv->options.suspend; 140 orb->cmd.ssic = priv->options.suspend && priv->options.inter; 141 orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm; 142 #ifdef CONFIG_64BIT 143 /* 144 * for 64 bit we always support 64 bit IDAWs with 4k page size only 145 */ 146 orb->cmd.c64 = 1; 147 orb->cmd.i2k = 0; 148 #endif 149 orb->cmd.key = key >> 4; 150 /* issue "Start Subchannel" */ 151 orb->cmd.cpa = (__u32) __pa(cpa); 152 ccode = ssch(sch->schid, orb); 153 154 /* process condition code */ 155 CIO_HEX_EVENT(5, &ccode, sizeof(ccode)); 156 157 switch (ccode) { 158 case 0: 159 /* 160 * initialize device status information 161 */ 162 sch->schib.scsw.cmd.actl |= SCSW_ACTL_START_PEND; 163 return 0; 164 case 1: /* status pending */ 165 case 2: /* busy */ 166 return -EBUSY; 167 case 3: /* device/path not operational */ 168 return cio_start_handle_notoper(sch, lpm); 169 default: 170 return ccode; 171 } 172 } 173 174 int 175 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm) 176 { 177 return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY); 178 } 179 180 /* 181 * resume suspended I/O operation 182 */ 183 int 184 cio_resume (struct subchannel *sch) 185 { 186 int ccode; 187 188 CIO_TRACE_EVENT(4, "resIO"); 189 CIO_TRACE_EVENT(4, dev_name(&sch->dev)); 190 191 ccode = rsch (sch->schid); 192 193 CIO_HEX_EVENT(4, &ccode, sizeof(ccode)); 194 195 switch (ccode) { 196 case 0: 197 sch->schib.scsw.cmd.actl |= SCSW_ACTL_RESUME_PEND; 198 return 0; 199 case 1: 200 return -EBUSY; 201 case 2: 202 return -EINVAL; 203 default: 204 /* 205 * useless to wait for request completion 206 * as device is no longer operational ! 207 */ 208 return -ENODEV; 209 } 210 } 211 212 /* 213 * halt I/O operation 214 */ 215 int 216 cio_halt(struct subchannel *sch) 217 { 218 int ccode; 219 220 if (!sch) 221 return -ENODEV; 222 223 CIO_TRACE_EVENT(2, "haltIO"); 224 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 225 226 /* 227 * Issue "Halt subchannel" and process condition code 228 */ 229 ccode = hsch (sch->schid); 230 231 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 232 233 switch (ccode) { 234 case 0: 235 sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND; 236 return 0; 237 case 1: /* status pending */ 238 case 2: /* busy */ 239 return -EBUSY; 240 default: /* device not operational */ 241 return -ENODEV; 242 } 243 } 244 245 /* 246 * Clear I/O operation 247 */ 248 int 249 cio_clear(struct subchannel *sch) 250 { 251 int ccode; 252 253 if (!sch) 254 return -ENODEV; 255 256 CIO_TRACE_EVENT(2, "clearIO"); 257 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 258 259 /* 260 * Issue "Clear subchannel" and process condition code 261 */ 262 ccode = csch (sch->schid); 263 264 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 265 266 switch (ccode) { 267 case 0: 268 sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND; 269 return 0; 270 default: /* device not operational */ 271 return -ENODEV; 272 } 273 } 274 275 /* 276 * Function: cio_cancel 277 * Issues a "Cancel Subchannel" on the specified subchannel 278 * Note: We don't need any fancy intparms and flags here 279 * since xsch is executed synchronously. 280 * Only for common I/O internal use as for now. 281 */ 282 int 283 cio_cancel (struct subchannel *sch) 284 { 285 int ccode; 286 287 if (!sch) 288 return -ENODEV; 289 290 CIO_TRACE_EVENT(2, "cancelIO"); 291 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 292 293 ccode = xsch (sch->schid); 294 295 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 296 297 switch (ccode) { 298 case 0: /* success */ 299 /* Update information in scsw. */ 300 if (cio_update_schib(sch)) 301 return -ENODEV; 302 return 0; 303 case 1: /* status pending */ 304 return -EBUSY; 305 case 2: /* not applicable */ 306 return -EINVAL; 307 default: /* not oper */ 308 return -ENODEV; 309 } 310 } 311 312 313 static void cio_apply_config(struct subchannel *sch, struct schib *schib) 314 { 315 schib->pmcw.intparm = sch->config.intparm; 316 schib->pmcw.mbi = sch->config.mbi; 317 schib->pmcw.isc = sch->config.isc; 318 schib->pmcw.ena = sch->config.ena; 319 schib->pmcw.mme = sch->config.mme; 320 schib->pmcw.mp = sch->config.mp; 321 schib->pmcw.csense = sch->config.csense; 322 schib->pmcw.mbfc = sch->config.mbfc; 323 if (sch->config.mbfc) 324 schib->mba = sch->config.mba; 325 } 326 327 static int cio_check_config(struct subchannel *sch, struct schib *schib) 328 { 329 return (schib->pmcw.intparm == sch->config.intparm) && 330 (schib->pmcw.mbi == sch->config.mbi) && 331 (schib->pmcw.isc == sch->config.isc) && 332 (schib->pmcw.ena == sch->config.ena) && 333 (schib->pmcw.mme == sch->config.mme) && 334 (schib->pmcw.mp == sch->config.mp) && 335 (schib->pmcw.csense == sch->config.csense) && 336 (schib->pmcw.mbfc == sch->config.mbfc) && 337 (!sch->config.mbfc || (schib->mba == sch->config.mba)); 338 } 339 340 /* 341 * cio_commit_config - apply configuration to the subchannel 342 */ 343 int cio_commit_config(struct subchannel *sch) 344 { 345 struct schib schib; 346 int ccode, retry, ret = 0; 347 348 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib)) 349 return -ENODEV; 350 351 for (retry = 0; retry < 5; retry++) { 352 /* copy desired changes to local schib */ 353 cio_apply_config(sch, &schib); 354 ccode = msch_err(sch->schid, &schib); 355 if (ccode < 0) /* -EIO if msch gets a program check. */ 356 return ccode; 357 switch (ccode) { 358 case 0: /* successful */ 359 if (stsch_err(sch->schid, &schib) || 360 !css_sch_is_valid(&schib)) 361 return -ENODEV; 362 if (cio_check_config(sch, &schib)) { 363 /* commit changes from local schib */ 364 memcpy(&sch->schib, &schib, sizeof(schib)); 365 return 0; 366 } 367 ret = -EAGAIN; 368 break; 369 case 1: /* status pending */ 370 return -EBUSY; 371 case 2: /* busy */ 372 udelay(100); /* allow for recovery */ 373 ret = -EBUSY; 374 break; 375 case 3: /* not operational */ 376 return -ENODEV; 377 } 378 } 379 return ret; 380 } 381 382 /** 383 * cio_update_schib - Perform stsch and update schib if subchannel is valid. 384 * @sch: subchannel on which to perform stsch 385 * Return zero on success, -ENODEV otherwise. 386 */ 387 int cio_update_schib(struct subchannel *sch) 388 { 389 struct schib schib; 390 391 if (stsch_err(sch->schid, &schib) || !css_sch_is_valid(&schib)) 392 return -ENODEV; 393 394 memcpy(&sch->schib, &schib, sizeof(schib)); 395 return 0; 396 } 397 EXPORT_SYMBOL_GPL(cio_update_schib); 398 399 /** 400 * cio_enable_subchannel - enable a subchannel. 401 * @sch: subchannel to be enabled 402 * @intparm: interruption parameter to set 403 */ 404 int cio_enable_subchannel(struct subchannel *sch, u32 intparm) 405 { 406 int retry; 407 int ret; 408 409 CIO_TRACE_EVENT(2, "ensch"); 410 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 411 412 if (sch_is_pseudo_sch(sch)) 413 return -EINVAL; 414 if (cio_update_schib(sch)) 415 return -ENODEV; 416 417 sch->config.ena = 1; 418 sch->config.isc = sch->isc; 419 sch->config.intparm = intparm; 420 421 for (retry = 0; retry < 3; retry++) { 422 ret = cio_commit_config(sch); 423 if (ret == -EIO) { 424 /* 425 * Got a program check in msch. Try without 426 * the concurrent sense bit the next time. 427 */ 428 sch->config.csense = 0; 429 } else if (ret == -EBUSY) { 430 struct irb irb; 431 if (tsch(sch->schid, &irb) != 0) 432 break; 433 } else 434 break; 435 } 436 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 437 return ret; 438 } 439 EXPORT_SYMBOL_GPL(cio_enable_subchannel); 440 441 /** 442 * cio_disable_subchannel - disable a subchannel. 443 * @sch: subchannel to disable 444 */ 445 int cio_disable_subchannel(struct subchannel *sch) 446 { 447 int retry; 448 int ret; 449 450 CIO_TRACE_EVENT(2, "dissch"); 451 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 452 453 if (sch_is_pseudo_sch(sch)) 454 return 0; 455 if (cio_update_schib(sch)) 456 return -ENODEV; 457 458 sch->config.ena = 0; 459 460 for (retry = 0; retry < 3; retry++) { 461 ret = cio_commit_config(sch); 462 if (ret == -EBUSY) { 463 struct irb irb; 464 if (tsch(sch->schid, &irb) != 0) 465 break; 466 } else 467 break; 468 } 469 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 470 return ret; 471 } 472 EXPORT_SYMBOL_GPL(cio_disable_subchannel); 473 474 static int cio_check_devno_blacklisted(struct subchannel *sch) 475 { 476 if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) { 477 /* 478 * This device must not be known to Linux. So we simply 479 * say that there is no device and return ENODEV. 480 */ 481 CIO_MSG_EVENT(6, "Blacklisted device detected " 482 "at devno %04X, subchannel set %x\n", 483 sch->schib.pmcw.dev, sch->schid.ssid); 484 return -ENODEV; 485 } 486 return 0; 487 } 488 489 static int cio_validate_io_subchannel(struct subchannel *sch) 490 { 491 /* Initialization for io subchannels. */ 492 if (!css_sch_is_valid(&sch->schib)) 493 return -ENODEV; 494 495 /* Devno is valid. */ 496 return cio_check_devno_blacklisted(sch); 497 } 498 499 static int cio_validate_msg_subchannel(struct subchannel *sch) 500 { 501 /* Initialization for message subchannels. */ 502 if (!css_sch_is_valid(&sch->schib)) 503 return -ENODEV; 504 505 /* Devno is valid. */ 506 return cio_check_devno_blacklisted(sch); 507 } 508 509 /** 510 * cio_validate_subchannel - basic validation of subchannel 511 * @sch: subchannel structure to be filled out 512 * @schid: subchannel id 513 * 514 * Find out subchannel type and initialize struct subchannel. 515 * Return codes: 516 * 0 on success 517 * -ENXIO for non-defined subchannels 518 * -ENODEV for invalid subchannels or blacklisted devices 519 * -EIO for subchannels in an invalid subchannel set 520 */ 521 int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid) 522 { 523 char dbf_txt[15]; 524 int ccode; 525 int err; 526 527 sprintf(dbf_txt, "valsch%x", schid.sch_no); 528 CIO_TRACE_EVENT(4, dbf_txt); 529 530 /* 531 * The first subchannel that is not-operational (ccode==3) 532 * indicates that there aren't any more devices available. 533 * If stsch gets an exception, it means the current subchannel set 534 * is not valid. 535 */ 536 ccode = stsch_err(schid, &sch->schib); 537 if (ccode) { 538 err = (ccode == 3) ? -ENXIO : ccode; 539 goto out; 540 } 541 sch->st = sch->schib.pmcw.st; 542 sch->schid = schid; 543 544 switch (sch->st) { 545 case SUBCHANNEL_TYPE_IO: 546 err = cio_validate_io_subchannel(sch); 547 break; 548 case SUBCHANNEL_TYPE_MSG: 549 err = cio_validate_msg_subchannel(sch); 550 break; 551 default: 552 err = 0; 553 } 554 if (err) 555 goto out; 556 557 CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n", 558 sch->schid.ssid, sch->schid.sch_no, sch->st); 559 out: 560 return err; 561 } 562 563 /* 564 * do_cio_interrupt() handles all normal I/O device IRQ's 565 */ 566 static irqreturn_t do_cio_interrupt(int irq, void *dummy) 567 { 568 struct tpi_info *tpi_info; 569 struct subchannel *sch; 570 struct irb *irb; 571 572 __this_cpu_write(s390_idle.nohz_delay, 1); 573 tpi_info = (struct tpi_info *) &get_irq_regs()->int_code; 574 irb = (struct irb *) &S390_lowcore.irb; 575 sch = (struct subchannel *)(unsigned long) tpi_info->intparm; 576 if (!sch) { 577 /* Clear pending interrupt condition. */ 578 inc_irq_stat(IRQIO_CIO); 579 tsch(tpi_info->schid, irb); 580 return IRQ_HANDLED; 581 } 582 spin_lock(sch->lock); 583 /* Store interrupt response block to lowcore. */ 584 if (tsch(tpi_info->schid, irb) == 0) { 585 /* Keep subchannel information word up to date. */ 586 memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw)); 587 /* Call interrupt handler if there is one. */ 588 if (sch->driver && sch->driver->irq) 589 sch->driver->irq(sch); 590 else 591 inc_irq_stat(IRQIO_CIO); 592 } else 593 inc_irq_stat(IRQIO_CIO); 594 spin_unlock(sch->lock); 595 596 return IRQ_HANDLED; 597 } 598 599 static struct irq_desc *irq_desc_io; 600 601 static struct irqaction io_interrupt = { 602 .name = "IO", 603 .handler = do_cio_interrupt, 604 }; 605 606 void __init init_cio_interrupts(void) 607 { 608 irq_set_chip_and_handler(IO_INTERRUPT, 609 &dummy_irq_chip, handle_percpu_irq); 610 setup_irq(IO_INTERRUPT, &io_interrupt); 611 irq_desc_io = irq_to_desc(IO_INTERRUPT); 612 } 613 614 #ifdef CONFIG_CCW_CONSOLE 615 static struct subchannel *console_sch; 616 617 /* 618 * Use cio_tsch to update the subchannel status and call the interrupt handler 619 * if status had been pending. Called with the subchannel's lock held. 620 */ 621 void cio_tsch(struct subchannel *sch) 622 { 623 struct irb *irb; 624 int irq_context; 625 626 irb = (struct irb *)&S390_lowcore.irb; 627 /* Store interrupt response block to lowcore. */ 628 if (tsch(sch->schid, irb) != 0) 629 /* Not status pending or not operational. */ 630 return; 631 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw)); 632 /* Call interrupt handler with updated status. */ 633 irq_context = in_interrupt(); 634 if (!irq_context) { 635 local_bh_disable(); 636 irq_enter(); 637 } 638 kstat_incr_irqs_this_cpu(IO_INTERRUPT, irq_desc_io); 639 if (sch->driver && sch->driver->irq) 640 sch->driver->irq(sch); 641 else 642 inc_irq_stat(IRQIO_CIO); 643 if (!irq_context) { 644 irq_exit(); 645 _local_bh_enable(); 646 } 647 } 648 649 static int cio_test_for_console(struct subchannel_id schid, void *data) 650 { 651 struct schib schib; 652 653 if (stsch_err(schid, &schib) != 0) 654 return -ENXIO; 655 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 656 (schib.pmcw.dev == console_devno)) { 657 console_irq = schid.sch_no; 658 return 1; /* found */ 659 } 660 return 0; 661 } 662 663 static int cio_get_console_sch_no(void) 664 { 665 struct subchannel_id schid; 666 struct schib schib; 667 668 init_subchannel_id(&schid); 669 if (console_irq != -1) { 670 /* VM provided us with the irq number of the console. */ 671 schid.sch_no = console_irq; 672 if (stsch_err(schid, &schib) != 0 || 673 (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv) 674 return -1; 675 console_devno = schib.pmcw.dev; 676 } else if (console_devno != -1) { 677 /* At least the console device number is known. */ 678 for_each_subchannel(cio_test_for_console, NULL); 679 } 680 return console_irq; 681 } 682 683 struct subchannel *cio_probe_console(void) 684 { 685 struct subchannel_id schid; 686 struct subchannel *sch; 687 int sch_no, ret; 688 689 sch_no = cio_get_console_sch_no(); 690 if (sch_no == -1) { 691 pr_warning("No CCW console was found\n"); 692 return ERR_PTR(-ENODEV); 693 } 694 init_subchannel_id(&schid); 695 schid.sch_no = sch_no; 696 sch = css_alloc_subchannel(schid); 697 if (IS_ERR(sch)) 698 return sch; 699 700 isc_register(CONSOLE_ISC); 701 sch->config.isc = CONSOLE_ISC; 702 sch->config.intparm = (u32)(addr_t)sch; 703 ret = cio_commit_config(sch); 704 if (ret) { 705 isc_unregister(CONSOLE_ISC); 706 put_device(&sch->dev); 707 return ERR_PTR(ret); 708 } 709 console_sch = sch; 710 return sch; 711 } 712 713 int cio_is_console(struct subchannel_id schid) 714 { 715 if (!console_sch) 716 return 0; 717 return schid_equal(&schid, &console_sch->schid); 718 } 719 720 void cio_register_early_subchannels(void) 721 { 722 int ret; 723 724 if (!console_sch) 725 return; 726 727 ret = css_register_subchannel(console_sch); 728 if (ret) 729 put_device(&console_sch->dev); 730 } 731 #endif /* CONFIG_CCW_CONSOLE */ 732 733 static int 734 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib) 735 { 736 int retry, cc; 737 738 cc = 0; 739 for (retry=0;retry<3;retry++) { 740 schib->pmcw.ena = 0; 741 cc = msch_err(schid, schib); 742 if (cc) 743 return (cc==3?-ENODEV:-EBUSY); 744 if (stsch_err(schid, schib) || !css_sch_is_valid(schib)) 745 return -ENODEV; 746 if (!schib->pmcw.ena) 747 return 0; 748 } 749 return -EBUSY; /* uhm... */ 750 } 751 752 static int 753 __clear_io_subchannel_easy(struct subchannel_id schid) 754 { 755 int retry; 756 757 if (csch(schid)) 758 return -ENODEV; 759 for (retry=0;retry<20;retry++) { 760 struct tpi_info ti; 761 762 if (tpi(&ti)) { 763 tsch(ti.schid, (struct irb *)&S390_lowcore.irb); 764 if (schid_equal(&ti.schid, &schid)) 765 return 0; 766 } 767 udelay_simple(100); 768 } 769 return -EBUSY; 770 } 771 772 static void __clear_chsc_subchannel_easy(void) 773 { 774 /* It seems we can only wait for a bit here :/ */ 775 udelay_simple(100); 776 } 777 778 static int pgm_check_occured; 779 780 static void cio_reset_pgm_check_handler(void) 781 { 782 pgm_check_occured = 1; 783 } 784 785 static int stsch_reset(struct subchannel_id schid, struct schib *addr) 786 { 787 int rc; 788 789 pgm_check_occured = 0; 790 s390_base_pgm_handler_fn = cio_reset_pgm_check_handler; 791 rc = stsch_err(schid, addr); 792 s390_base_pgm_handler_fn = NULL; 793 794 /* The program check handler could have changed pgm_check_occured. */ 795 barrier(); 796 797 if (pgm_check_occured) 798 return -EIO; 799 else 800 return rc; 801 } 802 803 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data) 804 { 805 struct schib schib; 806 807 if (stsch_reset(schid, &schib)) 808 return -ENXIO; 809 if (!schib.pmcw.ena) 810 return 0; 811 switch(__disable_subchannel_easy(schid, &schib)) { 812 case 0: 813 case -ENODEV: 814 break; 815 default: /* -EBUSY */ 816 switch (schib.pmcw.st) { 817 case SUBCHANNEL_TYPE_IO: 818 if (__clear_io_subchannel_easy(schid)) 819 goto out; /* give up... */ 820 break; 821 case SUBCHANNEL_TYPE_CHSC: 822 __clear_chsc_subchannel_easy(); 823 break; 824 default: 825 /* No default clear strategy */ 826 break; 827 } 828 stsch_err(schid, &schib); 829 __disable_subchannel_easy(schid, &schib); 830 } 831 out: 832 return 0; 833 } 834 835 static atomic_t chpid_reset_count; 836 837 static void s390_reset_chpids_mcck_handler(void) 838 { 839 struct crw crw; 840 struct mci *mci; 841 842 /* Check for pending channel report word. */ 843 mci = (struct mci *)&S390_lowcore.mcck_interruption_code; 844 if (!mci->cp) 845 return; 846 /* Process channel report words. */ 847 while (stcrw(&crw) == 0) { 848 /* Check for responses to RCHP. */ 849 if (crw.slct && crw.rsc == CRW_RSC_CPATH) 850 atomic_dec(&chpid_reset_count); 851 } 852 } 853 854 #define RCHP_TIMEOUT (30 * USEC_PER_SEC) 855 static void css_reset(void) 856 { 857 int i, ret; 858 unsigned long long timeout; 859 struct chp_id chpid; 860 861 /* Reset subchannels. */ 862 for_each_subchannel(__shutdown_subchannel_easy, NULL); 863 /* Reset channel paths. */ 864 s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler; 865 /* Enable channel report machine checks. */ 866 __ctl_set_bit(14, 28); 867 /* Temporarily reenable machine checks. */ 868 local_mcck_enable(); 869 chp_id_init(&chpid); 870 for (i = 0; i <= __MAX_CHPID; i++) { 871 chpid.id = i; 872 ret = rchp(chpid); 873 if ((ret == 0) || (ret == 2)) 874 /* 875 * rchp either succeeded, or another rchp is already 876 * in progress. In either case, we'll get a crw. 877 */ 878 atomic_inc(&chpid_reset_count); 879 } 880 /* Wait for machine check for all channel paths. */ 881 timeout = get_tod_clock_fast() + (RCHP_TIMEOUT << 12); 882 while (atomic_read(&chpid_reset_count) != 0) { 883 if (get_tod_clock_fast() > timeout) 884 break; 885 cpu_relax(); 886 } 887 /* Disable machine checks again. */ 888 local_mcck_disable(); 889 /* Disable channel report machine checks. */ 890 __ctl_clear_bit(14, 28); 891 s390_base_mcck_handler_fn = NULL; 892 } 893 894 static struct reset_call css_reset_call = { 895 .fn = css_reset, 896 }; 897 898 static int __init init_css_reset_call(void) 899 { 900 atomic_set(&chpid_reset_count, 0); 901 register_reset_call(&css_reset_call); 902 return 0; 903 } 904 905 arch_initcall(init_css_reset_call); 906 907 struct sch_match_id { 908 struct subchannel_id schid; 909 struct ccw_dev_id devid; 910 int rc; 911 }; 912 913 static int __reipl_subchannel_match(struct subchannel_id schid, void *data) 914 { 915 struct schib schib; 916 struct sch_match_id *match_id = data; 917 918 if (stsch_reset(schid, &schib)) 919 return -ENXIO; 920 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 921 (schib.pmcw.dev == match_id->devid.devno) && 922 (schid.ssid == match_id->devid.ssid)) { 923 match_id->schid = schid; 924 match_id->rc = 0; 925 return 1; 926 } 927 return 0; 928 } 929 930 static int reipl_find_schid(struct ccw_dev_id *devid, 931 struct subchannel_id *schid) 932 { 933 struct sch_match_id match_id; 934 935 match_id.devid = *devid; 936 match_id.rc = -ENODEV; 937 for_each_subchannel(__reipl_subchannel_match, &match_id); 938 if (match_id.rc == 0) 939 *schid = match_id.schid; 940 return match_id.rc; 941 } 942 943 extern void do_reipl_asm(__u32 schid); 944 945 /* Make sure all subchannels are quiet before we re-ipl an lpar. */ 946 void reipl_ccw_dev(struct ccw_dev_id *devid) 947 { 948 struct subchannel_id uninitialized_var(schid); 949 950 s390_reset_system(NULL, NULL); 951 if (reipl_find_schid(devid, &schid) != 0) 952 panic("IPL Device not found\n"); 953 do_reipl_asm(*((__u32*)&schid)); 954 } 955 956 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo) 957 { 958 struct subchannel_id schid; 959 struct schib schib; 960 961 schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id; 962 if (!schid.one) 963 return -ENODEV; 964 if (stsch_err(schid, &schib)) 965 return -ENODEV; 966 if (schib.pmcw.st != SUBCHANNEL_TYPE_IO) 967 return -ENODEV; 968 if (!schib.pmcw.dnv) 969 return -ENODEV; 970 iplinfo->devno = schib.pmcw.dev; 971 iplinfo->is_qdio = schib.pmcw.qf; 972 return 0; 973 } 974 975 /** 976 * cio_tm_start_key - perform start function 977 * @sch: subchannel on which to perform the start function 978 * @tcw: transport-command word to be started 979 * @lpm: mask of paths to use 980 * @key: storage key to use for storage access 981 * 982 * Start the tcw on the given subchannel. Return zero on success, non-zero 983 * otherwise. 984 */ 985 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key) 986 { 987 int cc; 988 union orb *orb = &to_io_private(sch)->orb; 989 990 memset(orb, 0, sizeof(union orb)); 991 orb->tm.intparm = (u32) (addr_t) sch; 992 orb->tm.key = key >> 4; 993 orb->tm.b = 1; 994 orb->tm.lpm = lpm ? lpm : sch->lpm; 995 orb->tm.tcw = (u32) (addr_t) tcw; 996 cc = ssch(sch->schid, orb); 997 switch (cc) { 998 case 0: 999 return 0; 1000 case 1: 1001 case 2: 1002 return -EBUSY; 1003 default: 1004 return cio_start_handle_notoper(sch, lpm); 1005 } 1006 } 1007 1008 /** 1009 * cio_tm_intrg - perform interrogate function 1010 * @sch - subchannel on which to perform the interrogate function 1011 * 1012 * If the specified subchannel is running in transport-mode, perform the 1013 * interrogate function. Return zero on success, non-zero otherwie. 1014 */ 1015 int cio_tm_intrg(struct subchannel *sch) 1016 { 1017 int cc; 1018 1019 if (!to_io_private(sch)->orb.tm.b) 1020 return -EINVAL; 1021 cc = xsch(sch->schid); 1022 switch (cc) { 1023 case 0: 1024 case 2: 1025 return 0; 1026 case 1: 1027 return -EBUSY; 1028 default: 1029 return -ENODEV; 1030 } 1031 } 1032