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