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