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)(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 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) || !css_sch_is_valid(&schib)) 463 return -ENODEV; 464 465 memcpy(&sch->schib, &schib, sizeof(schib)); 466 return 0; 467 } 468 EXPORT_SYMBOL_GPL(cio_update_schib); 469 470 /** 471 * cio_enable_subchannel - enable a subchannel. 472 * @sch: subchannel to be enabled 473 * @intparm: interruption parameter to set 474 */ 475 int cio_enable_subchannel(struct subchannel *sch, u32 intparm) 476 { 477 int ret; 478 479 CIO_TRACE_EVENT(2, "ensch"); 480 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 481 482 if (sch_is_pseudo_sch(sch)) 483 return -EINVAL; 484 if (cio_update_schib(sch)) 485 return -ENODEV; 486 487 sch->config.ena = 1; 488 sch->config.isc = sch->isc; 489 sch->config.intparm = intparm; 490 491 ret = cio_commit_config(sch); 492 if (ret == -EIO) { 493 /* 494 * Got a program check in msch. Try without 495 * the concurrent sense bit the next time. 496 */ 497 sch->config.csense = 0; 498 ret = cio_commit_config(sch); 499 } 500 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 501 return ret; 502 } 503 EXPORT_SYMBOL_GPL(cio_enable_subchannel); 504 505 /** 506 * cio_disable_subchannel - disable a subchannel. 507 * @sch: subchannel to disable 508 */ 509 int cio_disable_subchannel(struct subchannel *sch) 510 { 511 int ret; 512 513 CIO_TRACE_EVENT(2, "dissch"); 514 CIO_TRACE_EVENT(2, dev_name(&sch->dev)); 515 516 if (sch_is_pseudo_sch(sch)) 517 return 0; 518 if (cio_update_schib(sch)) 519 return -ENODEV; 520 521 sch->config.ena = 0; 522 ret = cio_commit_config(sch); 523 524 CIO_HEX_EVENT(2, &ret, sizeof(ret)); 525 return ret; 526 } 527 EXPORT_SYMBOL_GPL(cio_disable_subchannel); 528 529 /* 530 * do_cio_interrupt() handles all normal I/O device IRQ's 531 */ 532 static irqreturn_t do_cio_interrupt(int irq, void *dummy) 533 { 534 struct tpi_info *tpi_info; 535 struct subchannel *sch; 536 struct irb *irb; 537 538 set_cpu_flag(CIF_NOHZ_DELAY); 539 tpi_info = (struct tpi_info *) &get_irq_regs()->int_code; 540 trace_s390_cio_interrupt(tpi_info); 541 irb = this_cpu_ptr(&cio_irb); 542 sch = (struct subchannel *)(unsigned long) tpi_info->intparm; 543 if (!sch) { 544 /* Clear pending interrupt condition. */ 545 inc_irq_stat(IRQIO_CIO); 546 tsch(tpi_info->schid, irb); 547 return IRQ_HANDLED; 548 } 549 spin_lock(sch->lock); 550 /* Store interrupt response block to lowcore. */ 551 if (tsch(tpi_info->schid, irb) == 0) { 552 /* Keep subchannel information word up to date. */ 553 memcpy (&sch->schib.scsw, &irb->scsw, sizeof (irb->scsw)); 554 /* Call interrupt handler if there is one. */ 555 if (sch->driver && sch->driver->irq) 556 sch->driver->irq(sch); 557 else 558 inc_irq_stat(IRQIO_CIO); 559 } else 560 inc_irq_stat(IRQIO_CIO); 561 spin_unlock(sch->lock); 562 563 return IRQ_HANDLED; 564 } 565 566 static struct irqaction io_interrupt = { 567 .name = "IO", 568 .handler = do_cio_interrupt, 569 }; 570 571 void __init init_cio_interrupts(void) 572 { 573 irq_set_chip_and_handler(IO_INTERRUPT, 574 &dummy_irq_chip, handle_percpu_irq); 575 setup_irq(IO_INTERRUPT, &io_interrupt); 576 } 577 578 #ifdef CONFIG_CCW_CONSOLE 579 static struct subchannel *console_sch; 580 static struct lock_class_key console_sch_key; 581 582 /* 583 * Use cio_tsch to update the subchannel status and call the interrupt handler 584 * if status had been pending. Called with the subchannel's lock held. 585 */ 586 void cio_tsch(struct subchannel *sch) 587 { 588 struct irb *irb; 589 int irq_context; 590 591 irb = this_cpu_ptr(&cio_irb); 592 /* Store interrupt response block to lowcore. */ 593 if (tsch(sch->schid, irb) != 0) 594 /* Not status pending or not operational. */ 595 return; 596 memcpy(&sch->schib.scsw, &irb->scsw, sizeof(union scsw)); 597 /* Call interrupt handler with updated status. */ 598 irq_context = in_interrupt(); 599 if (!irq_context) { 600 local_bh_disable(); 601 irq_enter(); 602 } 603 kstat_incr_irq_this_cpu(IO_INTERRUPT); 604 if (sch->driver && sch->driver->irq) 605 sch->driver->irq(sch); 606 else 607 inc_irq_stat(IRQIO_CIO); 608 if (!irq_context) { 609 irq_exit(); 610 _local_bh_enable(); 611 } 612 } 613 614 static int cio_test_for_console(struct subchannel_id schid, void *data) 615 { 616 struct schib schib; 617 618 if (stsch(schid, &schib) != 0) 619 return -ENXIO; 620 if ((schib.pmcw.st == SUBCHANNEL_TYPE_IO) && schib.pmcw.dnv && 621 (schib.pmcw.dev == console_devno)) { 622 console_irq = schid.sch_no; 623 return 1; /* found */ 624 } 625 return 0; 626 } 627 628 static int cio_get_console_sch_no(void) 629 { 630 struct subchannel_id schid; 631 struct schib schib; 632 633 init_subchannel_id(&schid); 634 if (console_irq != -1) { 635 /* VM provided us with the irq number of the console. */ 636 schid.sch_no = console_irq; 637 if (stsch(schid, &schib) != 0 || 638 (schib.pmcw.st != SUBCHANNEL_TYPE_IO) || !schib.pmcw.dnv) 639 return -1; 640 console_devno = schib.pmcw.dev; 641 } else if (console_devno != -1) { 642 /* At least the console device number is known. */ 643 for_each_subchannel(cio_test_for_console, NULL); 644 } 645 return console_irq; 646 } 647 648 struct subchannel *cio_probe_console(void) 649 { 650 struct subchannel_id schid; 651 struct subchannel *sch; 652 struct schib schib; 653 int sch_no, ret; 654 655 sch_no = cio_get_console_sch_no(); 656 if (sch_no == -1) { 657 pr_warn("No CCW console was found\n"); 658 return ERR_PTR(-ENODEV); 659 } 660 init_subchannel_id(&schid); 661 schid.sch_no = sch_no; 662 ret = stsch(schid, &schib); 663 if (ret) 664 return ERR_PTR(-ENODEV); 665 666 sch = css_alloc_subchannel(schid, &schib); 667 if (IS_ERR(sch)) 668 return sch; 669 670 lockdep_set_class(sch->lock, &console_sch_key); 671 isc_register(CONSOLE_ISC); 672 sch->config.isc = CONSOLE_ISC; 673 sch->config.intparm = (u32)(addr_t)sch; 674 ret = cio_commit_config(sch); 675 if (ret) { 676 isc_unregister(CONSOLE_ISC); 677 put_device(&sch->dev); 678 return ERR_PTR(ret); 679 } 680 console_sch = sch; 681 return sch; 682 } 683 684 int cio_is_console(struct subchannel_id schid) 685 { 686 if (!console_sch) 687 return 0; 688 return schid_equal(&schid, &console_sch->schid); 689 } 690 691 void cio_register_early_subchannels(void) 692 { 693 int ret; 694 695 if (!console_sch) 696 return; 697 698 ret = css_register_subchannel(console_sch); 699 if (ret) 700 put_device(&console_sch->dev); 701 } 702 #endif /* CONFIG_CCW_CONSOLE */ 703 704 /** 705 * cio_tm_start_key - perform start function 706 * @sch: subchannel on which to perform the start function 707 * @tcw: transport-command word to be started 708 * @lpm: mask of paths to use 709 * @key: storage key to use for storage access 710 * 711 * Start the tcw on the given subchannel. Return zero on success, non-zero 712 * otherwise. 713 */ 714 int cio_tm_start_key(struct subchannel *sch, struct tcw *tcw, u8 lpm, u8 key) 715 { 716 int cc; 717 union orb *orb = &to_io_private(sch)->orb; 718 719 memset(orb, 0, sizeof(union orb)); 720 orb->tm.intparm = (u32) (addr_t) sch; 721 orb->tm.key = key >> 4; 722 orb->tm.b = 1; 723 orb->tm.lpm = lpm ? lpm : sch->lpm; 724 orb->tm.tcw = (u32) (addr_t) tcw; 725 cc = ssch(sch->schid, orb); 726 switch (cc) { 727 case 0: 728 return 0; 729 case 1: 730 case 2: 731 return -EBUSY; 732 default: 733 return cio_start_handle_notoper(sch, lpm); 734 } 735 } 736 EXPORT_SYMBOL_GPL(cio_tm_start_key); 737 738 /** 739 * cio_tm_intrg - perform interrogate function 740 * @sch: subchannel on which to perform the interrogate function 741 * 742 * If the specified subchannel is running in transport-mode, perform the 743 * interrogate function. Return zero on success, non-zero otherwie. 744 */ 745 int cio_tm_intrg(struct subchannel *sch) 746 { 747 int cc; 748 749 if (!to_io_private(sch)->orb.tm.b) 750 return -EINVAL; 751 cc = xsch(sch->schid); 752 switch (cc) { 753 case 0: 754 case 2: 755 return 0; 756 case 1: 757 return -EBUSY; 758 default: 759 return -ENODEV; 760 } 761 } 762 EXPORT_SYMBOL_GPL(cio_tm_intrg); 763