1 // SPDX-License-Identifier: GPL-2.0 2 /* 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 <linux/irq.h> 23 #include <asm/cio.h> 24 #include <asm/delay.h> 25 #include <asm/irq.h> 26 #include <asm/irq_regs.h> 27 #include <asm/setup.h> 28 #include <asm/ipl.h> 29 #include <asm/chpid.h> 30 #include <asm/airq.h> 31 #include <asm/isc.h> 32 #include <linux/sched/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)virt_to_phys(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 = virt_to_dma32(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 EXPORT_SYMBOL_GPL(cio_start_key); 174 175 int 176 cio_start (struct subchannel *sch, struct ccw1 *cpa, __u8 lpm) 177 { 178 return cio_start_key(sch, cpa, lpm, PAGE_DEFAULT_KEY); 179 } 180 EXPORT_SYMBOL_GPL(cio_start); 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 EXPORT_SYMBOL_GPL(cio_resume); 214 215 /* 216 * halt I/O operation 217 */ 218 int 219 cio_halt(struct subchannel *sch) 220 { 221 int ccode; 222 223 if (!sch) 224 return -ENODEV; 225 226 CIO_TRACE_EVENT(2, "haltIO"); 227 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 228 229 /* 230 * Issue "Halt subchannel" and process condition code 231 */ 232 ccode = hsch (sch->schid); 233 234 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 235 236 switch (ccode) { 237 case 0: 238 sch->schib.scsw.cmd.actl |= SCSW_ACTL_HALT_PEND; 239 return 0; 240 case 1: /* status pending */ 241 case 2: /* busy */ 242 return -EBUSY; 243 default: /* device not operational */ 244 return -ENODEV; 245 } 246 } 247 EXPORT_SYMBOL_GPL(cio_halt); 248 249 /* 250 * Clear I/O operation 251 */ 252 int 253 cio_clear(struct subchannel *sch) 254 { 255 int ccode; 256 257 if (!sch) 258 return -ENODEV; 259 260 CIO_TRACE_EVENT(2, "clearIO"); 261 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 262 263 /* 264 * Issue "Clear subchannel" and process condition code 265 */ 266 ccode = csch (sch->schid); 267 268 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 269 270 switch (ccode) { 271 case 0: 272 sch->schib.scsw.cmd.actl |= SCSW_ACTL_CLEAR_PEND; 273 return 0; 274 default: /* device not operational */ 275 return -ENODEV; 276 } 277 } 278 EXPORT_SYMBOL_GPL(cio_clear); 279 280 /* 281 * Function: cio_cancel 282 * Issues a "Cancel Subchannel" on the specified subchannel 283 * Note: We don't need any fancy intparms and flags here 284 * since xsch is executed synchronously. 285 * Only for common I/O internal use as for now. 286 */ 287 int 288 cio_cancel (struct subchannel *sch) 289 { 290 int ccode; 291 292 if (!sch) 293 return -ENODEV; 294 295 CIO_TRACE_EVENT(2, "cancelIO"); 296 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 297 298 ccode = xsch (sch->schid); 299 300 CIO_HEX_EVENT(2, &ccode, sizeof(ccode)); 301 302 switch (ccode) { 303 case 0: /* success */ 304 /* Update information in scsw. */ 305 if (cio_update_schib(sch)) 306 return -ENODEV; 307 return 0; 308 case 1: /* status pending */ 309 return -EBUSY; 310 case 2: /* not applicable */ 311 return -EINVAL; 312 default: /* not oper */ 313 return -ENODEV; 314 } 315 } 316 EXPORT_SYMBOL_GPL(cio_cancel); 317 318 /** 319 * cio_cancel_halt_clear - Cancel running I/O by performing cancel, halt 320 * and clear ordinally if subchannel is valid. 321 * @sch: subchannel on which to perform the cancel_halt_clear operation 322 * @iretry: the number of the times remained to retry the next operation 323 * 324 * This should be called repeatedly since halt/clear are asynchronous 325 * operations. We do one try with cio_cancel, three tries with cio_halt, 326 * 255 tries with cio_clear. The caller should initialize @iretry with 327 * the value 255 for its first call to this, and keep using the same 328 * @iretry in the subsequent calls until it gets a non -EBUSY return. 329 * 330 * Returns 0 if device now idle, -ENODEV for device not operational, 331 * -EBUSY if an interrupt is expected (either from halt/clear or from a 332 * status pending), and -EIO if out of retries. 333 */ 334 int cio_cancel_halt_clear(struct subchannel *sch, int *iretry) 335 { 336 int ret; 337 338 if (cio_update_schib(sch)) 339 return -ENODEV; 340 if (!sch->schib.pmcw.ena) 341 /* Not operational -> done. */ 342 return 0; 343 /* Stage 1: cancel io. */ 344 if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_HALT_PEND) && 345 !(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) { 346 if (!scsw_is_tm(&sch->schib.scsw)) { 347 ret = cio_cancel(sch); 348 if (ret != -EINVAL) 349 return ret; 350 } 351 /* 352 * Cancel io unsuccessful or not applicable (transport mode). 353 * Continue with asynchronous instructions. 354 */ 355 *iretry = 3; /* 3 halt retries. */ 356 } 357 /* Stage 2: halt io. */ 358 if (!(scsw_actl(&sch->schib.scsw) & SCSW_ACTL_CLEAR_PEND)) { 359 if (*iretry) { 360 *iretry -= 1; 361 ret = cio_halt(sch); 362 if (ret != -EBUSY) 363 return (ret == 0) ? -EBUSY : ret; 364 } 365 /* Halt io unsuccessful. */ 366 *iretry = 255; /* 255 clear retries. */ 367 } 368 /* Stage 3: clear io. */ 369 if (*iretry) { 370 *iretry -= 1; 371 ret = cio_clear(sch); 372 return (ret == 0) ? -EBUSY : ret; 373 } 374 /* Function was unsuccessful */ 375 return -EIO; 376 } 377 EXPORT_SYMBOL_GPL(cio_cancel_halt_clear); 378 379 static void cio_apply_config(struct subchannel *sch, struct schib *schib) 380 { 381 schib->pmcw.intparm = sch->config.intparm; 382 schib->pmcw.mbi = sch->config.mbi; 383 schib->pmcw.isc = sch->config.isc; 384 schib->pmcw.ena = sch->config.ena; 385 schib->pmcw.mme = sch->config.mme; 386 schib->pmcw.mp = sch->config.mp; 387 schib->pmcw.csense = sch->config.csense; 388 schib->pmcw.mbfc = sch->config.mbfc; 389 if (sch->config.mbfc) 390 schib->mba = sch->config.mba; 391 } 392 393 static int cio_check_config(struct subchannel *sch, struct schib *schib) 394 { 395 return (schib->pmcw.intparm == sch->config.intparm) && 396 (schib->pmcw.mbi == sch->config.mbi) && 397 (schib->pmcw.isc == sch->config.isc) && 398 (schib->pmcw.ena == sch->config.ena) && 399 (schib->pmcw.mme == sch->config.mme) && 400 (schib->pmcw.mp == sch->config.mp) && 401 (schib->pmcw.csense == sch->config.csense) && 402 (schib->pmcw.mbfc == sch->config.mbfc) && 403 (!sch->config.mbfc || (schib->mba == sch->config.mba)); 404 } 405 406 /* 407 * cio_commit_config - apply configuration to the subchannel 408 */ 409 int cio_commit_config(struct subchannel *sch) 410 { 411 int ccode, retry, ret = 0; 412 struct schib schib; 413 struct irb irb; 414 415 if (stsch(sch->schid, &schib) || !css_sch_is_valid(&schib)) 416 return -ENODEV; 417 418 for (retry = 0; retry < 5; retry++) { 419 /* copy desired changes to local schib */ 420 cio_apply_config(sch, &schib); 421 ccode = msch(sch->schid, &schib); 422 if (ccode < 0) /* -EIO if msch gets a program check. */ 423 return ccode; 424 switch (ccode) { 425 case 0: /* successful */ 426 if (stsch(sch->schid, &schib) || 427 !css_sch_is_valid(&schib)) 428 return -ENODEV; 429 if (cio_check_config(sch, &schib)) { 430 /* commit changes from local schib */ 431 memcpy(&sch->schib, &schib, sizeof(schib)); 432 return 0; 433 } 434 ret = -EAGAIN; 435 break; 436 case 1: /* status pending */ 437 ret = -EBUSY; 438 if (tsch(sch->schid, &irb)) 439 return ret; 440 break; 441 case 2: /* busy */ 442 udelay(100); /* allow for recovery */ 443 ret = -EBUSY; 444 break; 445 case 3: /* not operational */ 446 return -ENODEV; 447 } 448 } 449 return ret; 450 } 451 EXPORT_SYMBOL_GPL(cio_commit_config); 452 453 /** 454 * cio_update_schib - Perform stsch and update schib if subchannel is valid. 455 * @sch: subchannel on which to perform stsch 456 * Return zero on success, -ENODEV otherwise. 457 */ 458 int cio_update_schib(struct subchannel *sch) 459 { 460 struct schib schib; 461 462 if (stsch(sch->schid, &schib)) 463 return -ENODEV; 464 465 memcpy(&sch->schib, &schib, sizeof(schib)); 466 467 if (!css_sch_is_valid(&schib)) 468 return -EACCES; 469 470 return 0; 471 } 472 EXPORT_SYMBOL_GPL(cio_update_schib); 473 474 /** 475 * cio_enable_subchannel - enable a subchannel. 476 * @sch: subchannel to be enabled 477 * @intparm: interruption parameter to set 478 */ 479 int cio_enable_subchannel(struct subchannel *sch, u32 intparm) 480 { 481 int ret; 482 483 CIO_TRACE_EVENT(2, "ensch"); 484 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 485 486 if (sch_is_pseudo_sch(sch)) 487 return -EINVAL; 488 if (cio_update_schib(sch)) 489 return -ENODEV; 490 491 sch->config.ena = 1; 492 sch->config.isc = sch->isc; 493 sch->config.intparm = intparm; 494 495 ret = cio_commit_config(sch); 496 if (ret == -EIO) { 497 /* 498 * Got a program check in msch. Try without 499 * the concurrent sense bit the next time. 500 */ 501 sch->config.csense = 0; 502 ret = cio_commit_config(sch); 503 } 504 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 505 return ret; 506 } 507 EXPORT_SYMBOL_GPL(cio_enable_subchannel); 508 509 /** 510 * cio_disable_subchannel - disable a subchannel. 511 * @sch: subchannel to disable 512 */ 513 int cio_disable_subchannel(struct subchannel *sch) 514 { 515 int ret; 516 517 CIO_TRACE_EVENT(2, "dissch"); 518 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 519 520 if (sch_is_pseudo_sch(sch)) 521 return 0; 522 if (cio_update_schib(sch)) 523 return -ENODEV; 524 525 sch->config.ena = 0; 526 ret = cio_commit_config(sch); 527 528 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 529 return ret; 530 } 531 EXPORT_SYMBOL_GPL(cio_disable_subchannel); 532 533 /* 534 * do_cio_interrupt() handles all normal I/O device IRQ's 535 */ 536 static irqreturn_t do_cio_interrupt(int irq, void *dummy) 537 { 538 struct tpi_info *tpi_info; 539 struct subchannel *sch; 540 struct irb *irb; 541 542 tpi_info = &get_irq_regs()->tpi_info; 543 trace_s390_cio_interrupt(tpi_info); 544 irb = this_cpu_ptr(&cio_irb); 545 if (!tpi_info->intparm) { 546 /* Clear pending interrupt condition. */ 547 inc_irq_stat(IRQIO_CIO); 548 tsch(tpi_info->schid, irb); 549 return IRQ_HANDLED; 550 } 551 sch = phys_to_virt(tpi_info->intparm); 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 void __init init_cio_interrupts(void) 570 { 571 irq_set_chip_and_handler(IO_INTERRUPT, 572 &dummy_irq_chip, handle_percpu_irq); 573 if (request_irq(IO_INTERRUPT, do_cio_interrupt, 0, "I/O", NULL)) 574 panic("Failed to register I/O interrupt\n"); 575 } 576 577 #ifdef CONFIG_CCW_CONSOLE 578 static struct subchannel *console_sch; 579 static struct lock_class_key console_sch_key; 580 581 /* 582 * Use cio_tsch to update the subchannel status and call the interrupt handler 583 * if status had been pending. Called with the subchannel's lock held. 584 */ 585 void cio_tsch(struct subchannel *sch) 586 { 587 struct irb *irb; 588 int irq_context; 589 590 irb = this_cpu_ptr(&cio_irb); 591 /* Store interrupt response block to lowcore. */ 592 if (tsch(sch->schid, irb) != 0) 593 /* Not status pending or not operational. */ 594 return; 595 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw)); 596 /* Call interrupt handler with updated status. */ 597 irq_context = in_interrupt(); 598 if (!irq_context) { 599 local_bh_disable(); 600 irq_enter(); 601 } 602 kstat_incr_irq_this_cpu(IO_INTERRUPT); 603 if (sch->driver && sch->driver->irq) 604 sch->driver->irq(sch); 605 else 606 inc_irq_stat(IRQIO_CIO); 607 if (!irq_context) { 608 irq_exit(); 609 _local_bh_enable(); 610 } 611 } 612 613 static int cio_test_for_console(struct subchannel_id schid, void *data) 614 { 615 struct schib schib; 616 617 if (stsch(schid, &schib) != 0) 618 return -ENXIO; 619 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 620 (schib.pmcw.dev == console_devno)) { 621 console_irq = schid.sch_no; 622 return 1; /* found */ 623 } 624 return 0; 625 } 626 627 static int cio_get_console_sch_no(void) 628 { 629 struct subchannel_id schid; 630 struct schib schib; 631 632 init_subchannel_id(&schid); 633 if (console_irq != -1) { 634 /* VM provided us with the irq number of the console. */ 635 schid.sch_no = console_irq; 636 if (stsch(schid, &schib) != 0 || 637 (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv) 638 return -1; 639 console_devno = schib.pmcw.dev; 640 } else if (console_devno != -1) { 641 /* At least the console device number is known. */ 642 for_each_subchannel(cio_test_for_console, NULL); 643 } 644 return console_irq; 645 } 646 647 struct subchannel *cio_probe_console(void) 648 { 649 struct subchannel_id schid; 650 struct subchannel *sch; 651 struct schib schib; 652 int sch_no, ret; 653 654 sch_no = cio_get_console_sch_no(); 655 if (sch_no == -1) { 656 pr_warn("No CCW console was found\n"); 657 return ERR_PTR(-ENODEV); 658 } 659 init_subchannel_id(&schid); 660 schid.sch_no = sch_no; 661 ret = stsch(schid, &schib); 662 if (ret) 663 return ERR_PTR(-ENODEV); 664 665 sch = css_alloc_subchannel(schid, &schib); 666 if (IS_ERR(sch)) 667 return sch; 668 669 lockdep_set_class(&sch->lock, &console_sch_key); 670 isc_register(CONSOLE_ISC); 671 sch->config.isc = CONSOLE_ISC; 672 sch->config.intparm = (u32)virt_to_phys(sch); 673 ret = cio_commit_config(sch); 674 if (ret) { 675 isc_unregister(CONSOLE_ISC); 676 put_device(&sch->dev); 677 return ERR_PTR(ret); 678 } 679 console_sch = sch; 680 return sch; 681 } 682 683 int cio_is_console(struct subchannel_id schid) 684 { 685 if (!console_sch) 686 return 0; 687 return schid_equal(&schid, &console_sch->schid); 688 } 689 690 void cio_register_early_subchannels(void) 691 { 692 int ret; 693 694 if (!console_sch) 695 return; 696 697 ret = css_register_subchannel(console_sch); 698 if (ret) 699 put_device(&console_sch->dev); 700 } 701 #endif /* CONFIG_CCW_CONSOLE */ 702 703 /** 704 * cio_tm_start_key - perform start function 705 * @sch: subchannel on which to perform the start function 706 * @tcw: transport-command word to be started 707 * @lpm: mask of paths to use 708 * @key: storage key to use for storage access 709 * 710 * Start the tcw on the given subchannel. Return zero on success, non-zero 711 * otherwise. 712 */ 713 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key) 714 { 715 int cc; 716 union orb *orb = &to_io_private(sch)->orb; 717 718 memset(orb, 0, sizeof(union orb)); 719 orb->tm.intparm = (u32)virt_to_phys(sch); 720 orb->tm.key = key >> 4; 721 orb->tm.b = 1; 722 orb->tm.lpm = lpm ? lpm : sch->lpm; 723 orb->tm.tcw = virt_to_dma32(tcw); 724 cc = ssch(sch->schid, orb); 725 switch (cc) { 726 case 0: 727 return 0; 728 case 1: 729 case 2: 730 return -EBUSY; 731 default: 732 return cio_start_handle_notoper(sch, lpm); 733 } 734 } 735 EXPORT_SYMBOL_GPL(cio_tm_start_key); 736 737 /** 738 * cio_tm_intrg - perform interrogate function 739 * @sch: subchannel on which to perform the interrogate function 740 * 741 * If the specified subchannel is running in transport-mode, perform the 742 * interrogate function. Return zero on success, non-zero otherwie. 743 */ 744 int cio_tm_intrg(struct subchannel *sch) 745 { 746 int cc; 747 748 if (!to_io_private(sch)->orb.tm.b) 749 return -EINVAL; 750 cc = xsch(sch->schid); 751 switch (cc) { 752 case 0: 753 case 2: 754 return 0; 755 case 1: 756 return -EBUSY; 757 default: 758 return -ENODEV; 759 } 760 } 761 EXPORT_SYMBOL_GPL(cio_tm_intrg); 762