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 <linux/irq.h> 22 #include <asm/cio.h> 23 #include <asm/delay.h> 24 #include <asm/irq.h> 25 #include <asm/irq_regs.h> 26 #include <asm/setup.h> 27 #include <asm/reset.h> 28 #include <asm/ipl.h> 29 #include <asm/chpid.h> 30 #include <asm/airq.h> 31 #include <asm/isc.h> 32 #include <linux/cputime.h> 33 #include <asm/fcx.h> 34 #include <asm/nmi.h> 35 #include <asm/crw.h> 36 #include "cio.h" 37 #include "css.h" 38 #include "chsc.h" 39 #include "ioasm.h" 40 #include "io_sch.h" 41 #include "blacklist.h" 42 #include "cio_debug.h" 43 #include "chp.h" 44 #include "trace.h" 45 46 debug_info_t *cio_debug_msg_id; 47 debug_info_t *cio_debug_trace_id; 48 debug_info_t *cio_debug_crw_id; 49 50 DEFINE_PER_CPU_ALIGNED(struct irb, cio_irb); 51 EXPORT_PER_CPU_SYMBOL(cio_irb); 52 53 /* 54 * Function: cio_debug_init 55 * Initializes three debug logs for common I/O: 56 * - cio_msg logs generic cio messages 57 * - cio_trace logs the calling of different functions 58 * - cio_crw logs machine check related cio messages 59 */ 60 static int __init cio_debug_init(void) 61 { 62 cio_debug_msg_id = debug_register("cio_msg", 16, 1, 11 * sizeof(long)); 63 if (!cio_debug_msg_id) 64 goto out_unregister; 65 debug_register_view(cio_debug_msg_id, &debug_sprintf_view); 66 debug_set_level(cio_debug_msg_id, 2); 67 cio_debug_trace_id = debug_register("cio_trace", 16, 1, 16); 68 if (!cio_debug_trace_id) 69 goto out_unregister; 70 debug_register_view(cio_debug_trace_id, &debug_hex_ascii_view); 71 debug_set_level(cio_debug_trace_id, 2); 72 cio_debug_crw_id = debug_register("cio_crw", 8, 1, 8 * sizeof(long)); 73 if (!cio_debug_crw_id) 74 goto out_unregister; 75 debug_register_view(cio_debug_crw_id, &debug_sprintf_view); 76 debug_set_level(cio_debug_crw_id, 4); 77 return 0; 78 79 out_unregister: 80 debug_unregister(cio_debug_msg_id); 81 debug_unregister(cio_debug_trace_id); 82 debug_unregister(cio_debug_crw_id); 83 return -1; 84 } 85 86 arch_initcall (cio_debug_init); 87 88 int cio_set_options(struct subchannel *sch, int flags) 89 { 90 struct io_subchannel_private *priv = to_io_private(sch); 91 92 priv->options.suspend = (flags & DOIO_ALLOW_SUSPEND) != 0; 93 priv->options.prefetch = (flags & DOIO_DENY_PREFETCH) != 0; 94 priv->options.inter = (flags & DOIO_SUPPRESS_INTER) != 0; 95 return 0; 96 } 97 98 static int 99 cio_start_handle_notoper(struct subchannel *sch, __u8 lpm) 100 { 101 char dbf_text[15]; 102 103 if (lpm != 0) 104 sch->lpm &= ~lpm; 105 else 106 sch->lpm = 0; 107 108 CIO_MSG_EVENT(2, "cio_start: 'not oper' status for " 109 "subchannel 0.%x.%04x!\n", sch->schid.ssid, 110 sch->schid.sch_no); 111 112 if (cio_update_schib(sch)) 113 return -ENODEV; 114 115 sprintf(dbf_text, "no%s", dev_name(&sch->dev)); 116 CIO_TRACE_EVENT(0, dbf_text); 117 CIO_HEX_EVENT(0, &sch->schib, sizeof (struct schib)); 118 119 return (sch->lpm ? -EACCES : -ENODEV); 120 } 121 122 int 123 cio_start_key (struct subchannel *sch, /* subchannel structure */ 124 struct ccw1 * cpa, /* logical channel prog addr */ 125 __u8 lpm, /* logical path mask */ 126 __u8 key) /* storage key */ 127 { 128 struct io_subchannel_private *priv = to_io_private(sch); 129 union orb *orb = &priv->orb; 130 int ccode; 131 132 CIO_TRACE_EVENT(5, "stIO"); 133 CIO_TRACE_EVENT(5, dev_name(&sch->dev)); 134 135 memset(orb, 0, sizeof(union orb)); 136 /* sch is always under 2G. */ 137 orb->cmd.intparm = (u32)(addr_t)sch; 138 orb->cmd.fmt = 1; 139 140 orb->cmd.pfch = priv->options.prefetch == 0; 141 orb->cmd.spnd = priv->options.suspend; 142 orb->cmd.ssic = priv->options.suspend && priv->options.inter; 143 orb->cmd.lpm = (lpm != 0) ? lpm : sch->lpm; 144 /* 145 * for 64 bit we always support 64 bit IDAWs with 4k page size only 146 */ 147 orb->cmd.c64 = 1; 148 orb->cmd.i2k = 0; 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 int ccode, retry, ret = 0; 346 struct schib schib; 347 struct irb irb; 348 349 if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib)) 350 return -ENODEV; 351 352 for (retry = 0; retry < 5; retry++) { 353 /* copy desired changes to local schib */ 354 cio_apply_config(sch, &schib); 355 ccode = msch(sch->schid, &schib); 356 if (ccode < 0) /* -EIO if msch gets a program check. */ 357 return ccode; 358 switch (ccode) { 359 case 0: /* successful */ 360 if (stsch(sch->schid, &schib) || 361 !css_sch_is_valid(&schib)) 362 return -ENODEV; 363 if (cio_check_config(sch, &schib)) { 364 /* commit changes from local schib */ 365 memcpy(&sch->schib, &schib, sizeof(schib)); 366 return 0; 367 } 368 ret = -EAGAIN; 369 break; 370 case 1: /* status pending */ 371 ret = -EBUSY; 372 if (tsch(sch->schid, &irb)) 373 return ret; 374 break; 375 case 2: /* busy */ 376 udelay(100); /* allow for recovery */ 377 ret = -EBUSY; 378 break; 379 case 3: /* not operational */ 380 return -ENODEV; 381 } 382 } 383 return ret; 384 } 385 386 /** 387 * cio_update_schib - Perform stsch and update schib if subchannel is valid. 388 * @sch: subchannel on which to perform stsch 389 * Return zero on success, -ENODEV otherwise. 390 */ 391 int cio_update_schib(struct subchannel *sch) 392 { 393 struct schib schib; 394 395 if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib)) 396 return -ENODEV; 397 398 memcpy(&sch->schib, &schib, sizeof(schib)); 399 return 0; 400 } 401 EXPORT_SYMBOL_GPL(cio_update_schib); 402 403 /** 404 * cio_enable_subchannel - enable a subchannel. 405 * @sch: subchannel to be enabled 406 * @intparm: interruption parameter to set 407 */ 408 int cio_enable_subchannel(struct subchannel *sch, u32 intparm) 409 { 410 int ret; 411 412 CIO_TRACE_EVENT(2, "ensch"); 413 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 414 415 if (sch_is_pseudo_sch(sch)) 416 return -EINVAL; 417 if (cio_update_schib(sch)) 418 return -ENODEV; 419 420 sch->config.ena = 1; 421 sch->config.isc = sch->isc; 422 sch->config.intparm = intparm; 423 424 ret = cio_commit_config(sch); 425 if (ret == -EIO) { 426 /* 427 * Got a program check in msch. Try without 428 * the concurrent sense bit the next time. 429 */ 430 sch->config.csense = 0; 431 ret = cio_commit_config(sch); 432 } 433 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 434 return ret; 435 } 436 EXPORT_SYMBOL_GPL(cio_enable_subchannel); 437 438 /** 439 * cio_disable_subchannel - disable a subchannel. 440 * @sch: subchannel to disable 441 */ 442 int cio_disable_subchannel(struct subchannel *sch) 443 { 444 int ret; 445 446 CIO_TRACE_EVENT(2, "dissch"); 447 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 448 449 if (sch_is_pseudo_sch(sch)) 450 return 0; 451 if (cio_update_schib(sch)) 452 return -ENODEV; 453 454 sch->config.ena = 0; 455 ret = cio_commit_config(sch); 456 457 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 458 return ret; 459 } 460 EXPORT_SYMBOL_GPL(cio_disable_subchannel); 461 462 static int cio_check_devno_blacklisted(struct subchannel *sch) 463 { 464 if (is_blacklisted(sch->schid.ssid, sch->schib.pmcw.dev)) { 465 /* 466 * This device must not be known to Linux. So we simply 467 * say that there is no device and return ENODEV. 468 */ 469 CIO_MSG_EVENT(6, "Blacklisted device detected " 470 "at devno %04X, subchannel set %x\n", 471 sch->schib.pmcw.dev, sch->schid.ssid); 472 return -ENODEV; 473 } 474 return 0; 475 } 476 477 /** 478 * cio_validate_subchannel - basic validation of subchannel 479 * @sch: subchannel structure to be filled out 480 * @schid: subchannel id 481 * 482 * Find out subchannel type and initialize struct subchannel. 483 * Return codes: 484 * 0 on success 485 * -ENXIO for non-defined subchannels 486 * -ENODEV for invalid subchannels or blacklisted devices 487 * -EIO for subchannels in an invalid subchannel set 488 */ 489 int cio_validate_subchannel(struct subchannel *sch, struct subchannel_id schid) 490 { 491 char dbf_txt[15]; 492 int ccode; 493 int err; 494 495 sprintf(dbf_txt, "valsch%x", schid.sch_no); 496 CIO_TRACE_EVENT(4, dbf_txt); 497 498 /* 499 * The first subchannel that is not-operational (ccode==3) 500 * indicates that there aren't any more devices available. 501 * If stsch gets an exception, it means the current subchannel set 502 * is not valid. 503 */ 504 ccode = stsch(schid, &sch->schib); 505 if (ccode) { 506 err = (ccode == 3) ? -ENXIO : ccode; 507 goto out; 508 } 509 sch->st = sch->schib.pmcw.st; 510 sch->schid = schid; 511 512 switch (sch->st) { 513 case SUBCHANNEL_TYPE_IO: 514 case SUBCHANNEL_TYPE_MSG: 515 if (!css_sch_is_valid(&sch->schib)) 516 err = -ENODEV; 517 else 518 err = cio_check_devno_blacklisted(sch); 519 break; 520 default: 521 err = 0; 522 } 523 if (err) 524 goto out; 525 526 CIO_MSG_EVENT(4, "Subchannel 0.%x.%04x reports subchannel type %04X\n", 527 sch->schid.ssid, sch->schid.sch_no, sch->st); 528 out: 529 return err; 530 } 531 532 /* 533 * do_cio_interrupt() handles all normal I/O device IRQ's 534 */ 535 static irqreturn_t do_cio_interrupt(int irq, void *dummy) 536 { 537 struct tpi_info *tpi_info; 538 struct subchannel *sch; 539 struct irb *irb; 540 541 set_cpu_flag(CIF_NOHZ_DELAY); 542 tpi_info = (struct tpi_info *) &get_irq_regs()->int_code; 543 trace_s390_cio_interrupt(tpi_info); 544 irb = this_cpu_ptr(&cio_irb); 545 sch = (struct subchannel *)(unsigned long) tpi_info->intparm; 546 if (!sch) { 547 /* Clear pending interrupt condition. */ 548 inc_irq_stat(IRQIO_CIO); 549 tsch(tpi_info->schid, irb); 550 return IRQ_HANDLED; 551 } 552 spin_lock(sch->lock); 553 /* Store interrupt response block to lowcore. */ 554 if (tsch(tpi_info->schid, irb) == 0) { 555 /* Keep subchannel information word up to date. */ 556 memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw)); 557 /* Call interrupt handler if there is one. */ 558 if (sch->driver && sch->driver->irq) 559 sch->driver->irq(sch); 560 else 561 inc_irq_stat(IRQIO_CIO); 562 } else 563 inc_irq_stat(IRQIO_CIO); 564 spin_unlock(sch->lock); 565 566 return IRQ_HANDLED; 567 } 568 569 static struct irqaction io_interrupt = { 570 .name = "IO", 571 .handler = do_cio_interrupt, 572 }; 573 574 void __init init_cio_interrupts(void) 575 { 576 irq_set_chip_and_handler(IO_INTERRUPT, 577 &dummy_irq_chip, handle_percpu_irq); 578 setup_irq(IO_INTERRUPT, &io_interrupt); 579 } 580 581 #ifdef CONFIG_CCW_CONSOLE 582 static struct subchannel *console_sch; 583 static struct lock_class_key console_sch_key; 584 585 /* 586 * Use cio_tsch to update the subchannel status and call the interrupt handler 587 * if status had been pending. Called with the subchannel's lock held. 588 */ 589 void cio_tsch(struct subchannel *sch) 590 { 591 struct irb *irb; 592 int irq_context; 593 594 irb = this_cpu_ptr(&cio_irb); 595 /* Store interrupt response block to lowcore. */ 596 if (tsch(sch->schid, irb) != 0) 597 /* Not status pending or not operational. */ 598 return; 599 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw)); 600 /* Call interrupt handler with updated status. */ 601 irq_context = in_interrupt(); 602 if (!irq_context) { 603 local_bh_disable(); 604 irq_enter(); 605 } 606 kstat_incr_irq_this_cpu(IO_INTERRUPT); 607 if (sch->driver && sch->driver->irq) 608 sch->driver->irq(sch); 609 else 610 inc_irq_stat(IRQIO_CIO); 611 if (!irq_context) { 612 irq_exit(); 613 _local_bh_enable(); 614 } 615 } 616 617 static int cio_test_for_console(struct subchannel_id schid, void *data) 618 { 619 struct schib schib; 620 621 if (stsch(schid, &schib) != 0) 622 return -ENXIO; 623 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 624 (schib.pmcw.dev == console_devno)) { 625 console_irq = schid.sch_no; 626 return 1; /* found */ 627 } 628 return 0; 629 } 630 631 static int cio_get_console_sch_no(void) 632 { 633 struct subchannel_id schid; 634 struct schib schib; 635 636 init_subchannel_id(&schid); 637 if (console_irq != -1) { 638 /* VM provided us with the irq number of the console. */ 639 schid.sch_no = console_irq; 640 if (stsch(schid, &schib) != 0 || 641 (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv) 642 return -1; 643 console_devno = schib.pmcw.dev; 644 } else if (console_devno != -1) { 645 /* At least the console device number is known. */ 646 for_each_subchannel(cio_test_for_console, NULL); 647 } 648 return console_irq; 649 } 650 651 struct subchannel *cio_probe_console(void) 652 { 653 struct subchannel_id schid; 654 struct subchannel *sch; 655 int sch_no, ret; 656 657 sch_no = cio_get_console_sch_no(); 658 if (sch_no == -1) { 659 pr_warn("No CCW console was found\n"); 660 return ERR_PTR(-ENODEV); 661 } 662 init_subchannel_id(&schid); 663 schid.sch_no = sch_no; 664 sch = css_alloc_subchannel(schid); 665 if (IS_ERR(sch)) 666 return sch; 667 668 lockdep_set_class(sch->lock, &console_sch_key); 669 isc_register(CONSOLE_ISC); 670 sch->config.isc = CONSOLE_ISC; 671 sch->config.intparm = (u32)(addr_t)sch; 672 ret = cio_commit_config(sch); 673 if (ret) { 674 isc_unregister(CONSOLE_ISC); 675 put_device(&sch->dev); 676 return ERR_PTR(ret); 677 } 678 console_sch = sch; 679 return sch; 680 } 681 682 int cio_is_console(struct subchannel_id schid) 683 { 684 if (!console_sch) 685 return 0; 686 return schid_equal(&schid, &console_sch->schid); 687 } 688 689 void cio_register_early_subchannels(void) 690 { 691 int ret; 692 693 if (!console_sch) 694 return; 695 696 ret = css_register_subchannel(console_sch); 697 if (ret) 698 put_device(&console_sch->dev); 699 } 700 #endif /* CONFIG_CCW_CONSOLE */ 701 702 static int 703 __disable_subchannel_easy(struct subchannel_id schid, struct schib *schib) 704 { 705 int retry, cc; 706 707 cc = 0; 708 for (retry=0;retry<3;retry++) { 709 schib->pmcw.ena = 0; 710 cc = msch(schid, schib); 711 if (cc) 712 return (cc==3?-ENODEV:-EBUSY); 713 if (stsch(schid, schib) || !css_sch_is_valid(schib)) 714 return -ENODEV; 715 if (!schib->pmcw.ena) 716 return 0; 717 } 718 return -EBUSY; /* uhm... */ 719 } 720 721 static int 722 __clear_io_subchannel_easy(struct subchannel_id schid) 723 { 724 int retry; 725 726 if (csch(schid)) 727 return -ENODEV; 728 for (retry=0;retry<20;retry++) { 729 struct tpi_info ti; 730 731 if (tpi(&ti)) { 732 tsch(ti.schid, this_cpu_ptr(&cio_irb)); 733 if (schid_equal(&ti.schid, &schid)) 734 return 0; 735 } 736 udelay_simple(100); 737 } 738 return -EBUSY; 739 } 740 741 static void __clear_chsc_subchannel_easy(void) 742 { 743 /* It seems we can only wait for a bit here :/ */ 744 udelay_simple(100); 745 } 746 747 static int pgm_check_occured; 748 749 static void cio_reset_pgm_check_handler(void) 750 { 751 pgm_check_occured = 1; 752 } 753 754 static int stsch_reset(struct subchannel_id schid, struct schib *addr) 755 { 756 int rc; 757 758 pgm_check_occured = 0; 759 s390_base_pgm_handler_fn = cio_reset_pgm_check_handler; 760 rc = stsch(schid, addr); 761 s390_base_pgm_handler_fn = NULL; 762 763 /* The program check handler could have changed pgm_check_occured. */ 764 barrier(); 765 766 if (pgm_check_occured) 767 return -EIO; 768 else 769 return rc; 770 } 771 772 static int __shutdown_subchannel_easy(struct subchannel_id schid, void *data) 773 { 774 struct schib schib; 775 776 if (stsch_reset(schid, &schib)) 777 return -ENXIO; 778 if (!schib.pmcw.ena) 779 return 0; 780 switch(__disable_subchannel_easy(schid, &schib)) { 781 case 0: 782 case -ENODEV: 783 break; 784 default: /* -EBUSY */ 785 switch (schib.pmcw.st) { 786 case SUBCHANNEL_TYPE_IO: 787 if (__clear_io_subchannel_easy(schid)) 788 goto out; /* give up... */ 789 break; 790 case SUBCHANNEL_TYPE_CHSC: 791 __clear_chsc_subchannel_easy(); 792 break; 793 default: 794 /* No default clear strategy */ 795 break; 796 } 797 stsch(schid, &schib); 798 __disable_subchannel_easy(schid, &schib); 799 } 800 out: 801 return 0; 802 } 803 804 static atomic_t chpid_reset_count; 805 806 static void s390_reset_chpids_mcck_handler(void) 807 { 808 struct crw crw; 809 union mci mci; 810 811 /* Check for pending channel report word. */ 812 mci.val = S390_lowcore.mcck_interruption_code; 813 if (!mci.cp) 814 return; 815 /* Process channel report words. */ 816 while (stcrw(&crw) == 0) { 817 /* Check for responses to RCHP. */ 818 if (crw.slct && crw.rsc == CRW_RSC_CPATH) 819 atomic_dec(&chpid_reset_count); 820 } 821 } 822 823 #define RCHP_TIMEOUT (30 * USEC_PER_SEC) 824 static void css_reset(void) 825 { 826 int i, ret; 827 unsigned long long timeout; 828 struct chp_id chpid; 829 830 /* Reset subchannels. */ 831 for_each_subchannel(__shutdown_subchannel_easy, NULL); 832 /* Reset channel paths. */ 833 s390_base_mcck_handler_fn = s390_reset_chpids_mcck_handler; 834 /* Enable channel report machine checks. */ 835 __ctl_set_bit(14, 28); 836 /* Temporarily reenable machine checks. */ 837 local_mcck_enable(); 838 chp_id_init(&chpid); 839 for (i = 0; i <= __MAX_CHPID; i++) { 840 chpid.id = i; 841 ret = rchp(chpid); 842 if ((ret == 0) || (ret == 2)) 843 /* 844 * rchp either succeeded, or another rchp is already 845 * in progress. In either case, we'll get a crw. 846 */ 847 atomic_inc(&chpid_reset_count); 848 } 849 /* Wait for machine check for all channel paths. */ 850 timeout = get_tod_clock_fast() + (RCHP_TIMEOUT << 12); 851 while (atomic_read(&chpid_reset_count) != 0) { 852 if (get_tod_clock_fast() > timeout) 853 break; 854 cpu_relax(); 855 } 856 /* Disable machine checks again. */ 857 local_mcck_disable(); 858 /* Disable channel report machine checks. */ 859 __ctl_clear_bit(14, 28); 860 s390_base_mcck_handler_fn = NULL; 861 } 862 863 static struct reset_call css_reset_call = { 864 .fn = css_reset, 865 }; 866 867 static int __init init_css_reset_call(void) 868 { 869 atomic_set(&chpid_reset_count, 0); 870 register_reset_call(&css_reset_call); 871 return 0; 872 } 873 874 arch_initcall(init_css_reset_call); 875 876 struct sch_match_id { 877 struct subchannel_id schid; 878 struct ccw_dev_id devid; 879 int rc; 880 }; 881 882 static int __reipl_subchannel_match(struct subchannel_id schid, void *data) 883 { 884 struct schib schib; 885 struct sch_match_id *match_id = data; 886 887 if (stsch_reset(schid, &schib)) 888 return -ENXIO; 889 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 890 (schib.pmcw.dev == match_id->devid.devno) && 891 (schid.ssid == match_id->devid.ssid)) { 892 match_id->schid = schid; 893 match_id->rc = 0; 894 return 1; 895 } 896 return 0; 897 } 898 899 static int reipl_find_schid(struct ccw_dev_id *devid, 900 struct subchannel_id *schid) 901 { 902 struct sch_match_id match_id; 903 904 match_id.devid = *devid; 905 match_id.rc = -ENODEV; 906 for_each_subchannel(__reipl_subchannel_match, &match_id); 907 if (match_id.rc == 0) 908 *schid = match_id.schid; 909 return match_id.rc; 910 } 911 912 extern void do_reipl_asm(__u32 schid); 913 914 /* Make sure all subchannels are quiet before we re-ipl an lpar. */ 915 void reipl_ccw_dev(struct ccw_dev_id *devid) 916 { 917 struct subchannel_id uninitialized_var(schid); 918 919 s390_reset_system(); 920 if (reipl_find_schid(devid, &schid) != 0) 921 panic("IPL Device not found\n"); 922 do_reipl_asm(*((__u32*)&schid)); 923 } 924 925 int __init cio_get_iplinfo(struct cio_iplinfo *iplinfo) 926 { 927 static struct chsc_sda_area sda_area __initdata; 928 struct subchannel_id schid; 929 struct schib schib; 930 931 schid = *(struct subchannel_id *)&S390_lowcore.subchannel_id; 932 if (!schid.one) 933 return -ENODEV; 934 935 if (schid.ssid) { 936 /* 937 * Firmware should have already enabled MSS but whoever started 938 * the kernel might have initiated a channel subsystem reset. 939 * Ensure that MSS is enabled. 940 */ 941 memset(&sda_area, 0, sizeof(sda_area)); 942 if (__chsc_enable_facility(&sda_area, CHSC_SDA_OC_MSS)) 943 return -ENODEV; 944 } 945 if (stsch(schid, &schib)) 946 return -ENODEV; 947 if (schib.pmcw.st != SUBCHANNEL_TYPE_IO) 948 return -ENODEV; 949 if (!schib.pmcw.dnv) 950 return -ENODEV; 951 952 iplinfo->ssid = schid.ssid; 953 iplinfo->devno = schib.pmcw.dev; 954 iplinfo->is_qdio = schib.pmcw.qf; 955 return 0; 956 } 957 958 /** 959 * cio_tm_start_key - perform start function 960 * @sch: subchannel on which to perform the start function 961 * @tcw: transport-command word to be started 962 * @lpm: mask of paths to use 963 * @key: storage key to use for storage access 964 * 965 * Start the tcw on the given subchannel. Return zero on success, non-zero 966 * otherwise. 967 */ 968 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key) 969 { 970 int cc; 971 union orb *orb = &to_io_private(sch)->orb; 972 973 memset(orb, 0, sizeof(union orb)); 974 orb->tm.intparm = (u32) (addr_t) sch; 975 orb->tm.key = key >> 4; 976 orb->tm.b = 1; 977 orb->tm.lpm = lpm ? lpm : sch->lpm; 978 orb->tm.tcw = (u32) (addr_t) tcw; 979 cc = ssch(sch->schid, orb); 980 switch (cc) { 981 case 0: 982 return 0; 983 case 1: 984 case 2: 985 return -EBUSY; 986 default: 987 return cio_start_handle_notoper(sch, lpm); 988 } 989 } 990 991 /** 992 * cio_tm_intrg - perform interrogate function 993 * @sch - subchannel on which to perform the interrogate function 994 * 995 * If the specified subchannel is running in transport-mode, perform the 996 * interrogate function. Return zero on success, non-zero otherwie. 997 */ 998 int cio_tm_intrg(struct subchannel *sch) 999 { 1000 int cc; 1001 1002 if (!to_io_private(sch)->orb.tm.b) 1003 return -EINVAL; 1004 cc = xsch(sch->schid); 1005 switch (cc) { 1006 case 0: 1007 case 2: 1008 return 0; 1009 case 1: 1010 return -EBUSY; 1011 default: 1012 return -ENODEV; 1013 } 1014 } 1015