1/* SPDX-License-Identifier: GPL-2.0 */ 2/* 3 * Helper functions for scsw access. 4 * 5 * Copyright IBM Corp. 2008, 2012 6 * Author(s): Peter Oberparleiter <peter.oberparleiter@de.ibm.com> 7 */ 8 9#ifndef _ASM_S390_SCSW_H_ 10#define _ASM_S390_SCSW_H_ 11 12#include <linux/types.h> 13#include <asm/css_chars.h> 14#include <asm/dma-types.h> 15#include <asm/cio.h> 16 17/** 18 * struct cmd_scsw - command-mode subchannel status word 19 * @key: subchannel key 20 * @sctl: suspend control 21 * @eswf: esw format 22 * @cc: deferred condition code 23 * @fmt: format 24 * @pfch: prefetch 25 * @isic: initial-status interruption control 26 * @alcc: address-limit checking control 27 * @ssi: suppress-suspended interruption 28 * @zcc: zero condition code 29 * @ectl: extended control 30 * @pno: path not operational 31 * @res: reserved 32 * @fctl: function control 33 * @actl: activity control 34 * @stctl: status control 35 * @cpa: channel program address 36 * @dstat: device status 37 * @cstat: subchannel status 38 * @count: residual count 39 */ 40struct cmd_scsw { 41 __u32 key : 4; 42 __u32 sctl : 1; 43 __u32 eswf : 1; 44 __u32 cc : 2; 45 __u32 fmt : 1; 46 __u32 pfch : 1; 47 __u32 isic : 1; 48 __u32 alcc : 1; 49 __u32 ssi : 1; 50 __u32 zcc : 1; 51 __u32 ectl : 1; 52 __u32 pno : 1; 53 __u32 res : 1; 54 __u32 fctl : 3; 55 __u32 actl : 7; 56 __u32 stctl : 5; 57 dma32_t cpa; 58 __u32 dstat : 8; 59 __u32 cstat : 8; 60 __u32 count : 16; 61} __attribute__ ((packed)); 62 63/** 64 * struct tm_scsw - transport-mode subchannel status word 65 * @key: subchannel key 66 * @eswf: esw format 67 * @cc: deferred condition code 68 * @fmt: format 69 * @x: IRB-format control 70 * @q: interrogate-complete 71 * @ectl: extended control 72 * @pno: path not operational 73 * @fctl: function control 74 * @actl: activity control 75 * @stctl: status control 76 * @tcw: TCW address 77 * @dstat: device status 78 * @cstat: subchannel status 79 * @fcxs: FCX status 80 * @schxs: subchannel-extended status 81 */ 82struct tm_scsw { 83 u32 key:4; 84 u32 :1; 85 u32 eswf:1; 86 u32 cc:2; 87 u32 fmt:3; 88 u32 x:1; 89 u32 q:1; 90 u32 :1; 91 u32 ectl:1; 92 u32 pno:1; 93 u32 :1; 94 u32 fctl:3; 95 u32 actl:7; 96 u32 stctl:5; 97 dma32_t tcw; 98 u32 dstat:8; 99 u32 cstat:8; 100 u32 fcxs:8; 101 u32 ifob:1; 102 u32 sesq:7; 103} __attribute__ ((packed)); 104 105/** 106 * struct eadm_scsw - subchannel status word for eadm subchannels 107 * @key: subchannel key 108 * @eswf: esw format 109 * @cc: deferred condition code 110 * @ectl: extended control 111 * @fctl: function control 112 * @actl: activity control 113 * @stctl: status control 114 * @aob: AOB address 115 * @dstat: device status 116 * @cstat: subchannel status 117 */ 118struct eadm_scsw { 119 u32 key:4; 120 u32:1; 121 u32 eswf:1; 122 u32 cc:2; 123 u32:6; 124 u32 ectl:1; 125 u32:2; 126 u32 fctl:3; 127 u32 actl:7; 128 u32 stctl:5; 129 dma32_t aob; 130 u32 dstat:8; 131 u32 cstat:8; 132 u32:16; 133} __packed; 134 135/** 136 * union scsw - subchannel status word 137 * @cmd: command-mode SCSW 138 * @tm: transport-mode SCSW 139 * @eadm: eadm SCSW 140 */ 141union scsw { 142 struct cmd_scsw cmd; 143 struct tm_scsw tm; 144 struct eadm_scsw eadm; 145} __packed; 146 147#define SCSW_FCTL_CLEAR_FUNC 0x1 148#define SCSW_FCTL_HALT_FUNC 0x2 149#define SCSW_FCTL_START_FUNC 0x4 150 151#define SCSW_ACTL_SUSPENDED 0x1 152#define SCSW_ACTL_DEVACT 0x2 153#define SCSW_ACTL_SCHACT 0x4 154#define SCSW_ACTL_CLEAR_PEND 0x8 155#define SCSW_ACTL_HALT_PEND 0x10 156#define SCSW_ACTL_START_PEND 0x20 157#define SCSW_ACTL_RESUME_PEND 0x40 158 159#define SCSW_STCTL_STATUS_PEND 0x1 160#define SCSW_STCTL_SEC_STATUS 0x2 161#define SCSW_STCTL_PRIM_STATUS 0x4 162#define SCSW_STCTL_INTER_STATUS 0x8 163#define SCSW_STCTL_ALERT_STATUS 0x10 164 165#define DEV_STAT_ATTENTION 0x80 166#define DEV_STAT_STAT_MOD 0x40 167#define DEV_STAT_CU_END 0x20 168#define DEV_STAT_BUSY 0x10 169#define DEV_STAT_CHN_END 0x08 170#define DEV_STAT_DEV_END 0x04 171#define DEV_STAT_UNIT_CHECK 0x02 172#define DEV_STAT_UNIT_EXCEP 0x01 173 174#define SCHN_STAT_PCI 0x80 175#define SCHN_STAT_INCORR_LEN 0x40 176#define SCHN_STAT_PROG_CHECK 0x20 177#define SCHN_STAT_PROT_CHECK 0x10 178#define SCHN_STAT_CHN_DATA_CHK 0x08 179#define SCHN_STAT_CHN_CTRL_CHK 0x04 180#define SCHN_STAT_INTF_CTRL_CHK 0x02 181#define SCHN_STAT_CHAIN_CHECK 0x01 182 183#define SCSW_SESQ_DEV_NOFCX 3 184#define SCSW_SESQ_PATH_NOFCX 4 185 186/* 187 * architectured values for first sense byte 188 */ 189#define SNS0_CMD_REJECT 0x80 190#define SNS_CMD_REJECT SNS0_CMD_REJEC 191#define SNS0_INTERVENTION_REQ 0x40 192#define SNS0_BUS_OUT_CHECK 0x20 193#define SNS0_EQUIPMENT_CHECK 0x10 194#define SNS0_DATA_CHECK 0x08 195#define SNS0_OVERRUN 0x04 196#define SNS0_INCOMPL_DOMAIN 0x01 197 198/* 199 * architectured values for second sense byte 200 */ 201#define SNS1_PERM_ERR 0x80 202#define SNS1_INV_TRACK_FORMAT 0x40 203#define SNS1_EOC 0x20 204#define SNS1_MESSAGE_TO_OPER 0x10 205#define SNS1_NO_REC_FOUND 0x08 206#define SNS1_FILE_PROTECTED 0x04 207#define SNS1_WRITE_INHIBITED 0x02 208#define SNS1_INPRECISE_END 0x01 209 210/* 211 * architectured values for third sense byte 212 */ 213#define SNS2_REQ_INH_WRITE 0x80 214#define SNS2_CORRECTABLE 0x40 215#define SNS2_FIRST_LOG_ERR 0x20 216#define SNS2_ENV_DATA_PRESENT 0x10 217#define SNS2_INPRECISE_END 0x04 218 219/* 220 * architectured values for PPRC errors 221 */ 222#define SNS7_INVALID_ON_SEC 0x0e 223 224/** 225 * scsw_is_tm - check for transport mode scsw 226 * @scsw: pointer to scsw 227 * 228 * Return non-zero if the specified scsw is a transport mode scsw, zero 229 * otherwise. 230 */ 231static inline int scsw_is_tm(union scsw *scsw) 232{ 233 return css_general_characteristics.fcx && (scsw->tm.x == 1); 234} 235 236/** 237 * scsw_key - return scsw key field 238 * @scsw: pointer to scsw 239 * 240 * Return the value of the key field of the specified scsw, regardless of 241 * whether it is a transport mode or command mode scsw. 242 */ 243static inline u32 scsw_key(union scsw *scsw) 244{ 245 if (scsw_is_tm(scsw)) 246 return scsw->tm.key; 247 else 248 return scsw->cmd.key; 249} 250 251/** 252 * scsw_eswf - return scsw eswf field 253 * @scsw: pointer to scsw 254 * 255 * Return the value of the eswf field of the specified scsw, regardless of 256 * whether it is a transport mode or command mode scsw. 257 */ 258static inline u32 scsw_eswf(union scsw *scsw) 259{ 260 if (scsw_is_tm(scsw)) 261 return scsw->tm.eswf; 262 else 263 return scsw->cmd.eswf; 264} 265 266/** 267 * scsw_cc - return scsw cc field 268 * @scsw: pointer to scsw 269 * 270 * Return the value of the cc field of the specified scsw, regardless of 271 * whether it is a transport mode or command mode scsw. 272 */ 273static inline u32 scsw_cc(union scsw *scsw) 274{ 275 if (scsw_is_tm(scsw)) 276 return scsw->tm.cc; 277 else 278 return scsw->cmd.cc; 279} 280 281/** 282 * scsw_ectl - return scsw ectl field 283 * @scsw: pointer to scsw 284 * 285 * Return the value of the ectl field of the specified scsw, regardless of 286 * whether it is a transport mode or command mode scsw. 287 */ 288static inline u32 scsw_ectl(union scsw *scsw) 289{ 290 if (scsw_is_tm(scsw)) 291 return scsw->tm.ectl; 292 else 293 return scsw->cmd.ectl; 294} 295 296/** 297 * scsw_pno - return scsw pno field 298 * @scsw: pointer to scsw 299 * 300 * Return the value of the pno field of the specified scsw, regardless of 301 * whether it is a transport mode or command mode scsw. 302 */ 303static inline u32 scsw_pno(union scsw *scsw) 304{ 305 if (scsw_is_tm(scsw)) 306 return scsw->tm.pno; 307 else 308 return scsw->cmd.pno; 309} 310 311/** 312 * scsw_fctl - return scsw fctl field 313 * @scsw: pointer to scsw 314 * 315 * Return the value of the fctl field of the specified scsw, regardless of 316 * whether it is a transport mode or command mode scsw. 317 */ 318static inline u32 scsw_fctl(union scsw *scsw) 319{ 320 if (scsw_is_tm(scsw)) 321 return scsw->tm.fctl; 322 else 323 return scsw->cmd.fctl; 324} 325 326/** 327 * scsw_actl - return scsw actl field 328 * @scsw: pointer to scsw 329 * 330 * Return the value of the actl field of the specified scsw, regardless of 331 * whether it is a transport mode or command mode scsw. 332 */ 333static inline u32 scsw_actl(union scsw *scsw) 334{ 335 if (scsw_is_tm(scsw)) 336 return scsw->tm.actl; 337 else 338 return scsw->cmd.actl; 339} 340 341/** 342 * scsw_stctl - return scsw stctl field 343 * @scsw: pointer to scsw 344 * 345 * Return the value of the stctl field of the specified scsw, regardless of 346 * whether it is a transport mode or command mode scsw. 347 */ 348static inline u32 scsw_stctl(union scsw *scsw) 349{ 350 if (scsw_is_tm(scsw)) 351 return scsw->tm.stctl; 352 else 353 return scsw->cmd.stctl; 354} 355 356/** 357 * scsw_dstat - return scsw dstat field 358 * @scsw: pointer to scsw 359 * 360 * Return the value of the dstat field of the specified scsw, regardless of 361 * whether it is a transport mode or command mode scsw. 362 */ 363static inline u32 scsw_dstat(union scsw *scsw) 364{ 365 if (scsw_is_tm(scsw)) 366 return scsw->tm.dstat; 367 else 368 return scsw->cmd.dstat; 369} 370 371/** 372 * scsw_cstat - return scsw cstat field 373 * @scsw: pointer to scsw 374 * 375 * Return the value of the cstat field of the specified scsw, regardless of 376 * whether it is a transport mode or command mode scsw. 377 */ 378static inline u32 scsw_cstat(union scsw *scsw) 379{ 380 if (scsw_is_tm(scsw)) 381 return scsw->tm.cstat; 382 else 383 return scsw->cmd.cstat; 384} 385 386/** 387 * scsw_cmd_is_valid_key - check key field validity 388 * @scsw: pointer to scsw 389 * 390 * Return non-zero if the key field of the specified command mode scsw is 391 * valid, zero otherwise. 392 */ 393static inline int scsw_cmd_is_valid_key(union scsw *scsw) 394{ 395 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 396} 397 398/** 399 * scsw_cmd_is_valid_sctl - check sctl field validity 400 * @scsw: pointer to scsw 401 * 402 * Return non-zero if the sctl field of the specified command mode scsw is 403 * valid, zero otherwise. 404 */ 405static inline int scsw_cmd_is_valid_sctl(union scsw *scsw) 406{ 407 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 408} 409 410/** 411 * scsw_cmd_is_valid_eswf - check eswf field validity 412 * @scsw: pointer to scsw 413 * 414 * Return non-zero if the eswf field of the specified command mode scsw is 415 * valid, zero otherwise. 416 */ 417static inline int scsw_cmd_is_valid_eswf(union scsw *scsw) 418{ 419 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND); 420} 421 422/** 423 * scsw_cmd_is_valid_cc - check cc field validity 424 * @scsw: pointer to scsw 425 * 426 * Return non-zero if the cc field of the specified command mode scsw is 427 * valid, zero otherwise. 428 */ 429static inline int scsw_cmd_is_valid_cc(union scsw *scsw) 430{ 431 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && 432 (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND); 433} 434 435/** 436 * scsw_cmd_is_valid_fmt - check fmt field validity 437 * @scsw: pointer to scsw 438 * 439 * Return non-zero if the fmt field of the specified command mode scsw is 440 * valid, zero otherwise. 441 */ 442static inline int scsw_cmd_is_valid_fmt(union scsw *scsw) 443{ 444 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 445} 446 447/** 448 * scsw_cmd_is_valid_pfch - check pfch field validity 449 * @scsw: pointer to scsw 450 * 451 * Return non-zero if the pfch field of the specified command mode scsw is 452 * valid, zero otherwise. 453 */ 454static inline int scsw_cmd_is_valid_pfch(union scsw *scsw) 455{ 456 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 457} 458 459/** 460 * scsw_cmd_is_valid_isic - check isic field validity 461 * @scsw: pointer to scsw 462 * 463 * Return non-zero if the isic field of the specified command mode scsw is 464 * valid, zero otherwise. 465 */ 466static inline int scsw_cmd_is_valid_isic(union scsw *scsw) 467{ 468 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 469} 470 471/** 472 * scsw_cmd_is_valid_alcc - check alcc field validity 473 * @scsw: pointer to scsw 474 * 475 * Return non-zero if the alcc field of the specified command mode scsw is 476 * valid, zero otherwise. 477 */ 478static inline int scsw_cmd_is_valid_alcc(union scsw *scsw) 479{ 480 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 481} 482 483/** 484 * scsw_cmd_is_valid_ssi - check ssi field validity 485 * @scsw: pointer to scsw 486 * 487 * Return non-zero if the ssi field of the specified command mode scsw is 488 * valid, zero otherwise. 489 */ 490static inline int scsw_cmd_is_valid_ssi(union scsw *scsw) 491{ 492 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 493} 494 495/** 496 * scsw_cmd_is_valid_zcc - check zcc field validity 497 * @scsw: pointer to scsw 498 * 499 * Return non-zero if the zcc field of the specified command mode scsw is 500 * valid, zero otherwise. 501 */ 502static inline int scsw_cmd_is_valid_zcc(union scsw *scsw) 503{ 504 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && 505 (scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS); 506} 507 508/** 509 * scsw_cmd_is_valid_ectl - check ectl field validity 510 * @scsw: pointer to scsw 511 * 512 * Return non-zero if the ectl field of the specified command mode scsw is 513 * valid, zero otherwise. 514 */ 515static inline int scsw_cmd_is_valid_ectl(union scsw *scsw) 516{ 517 /* Must be status pending. */ 518 if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND)) 519 return 0; 520 521 /* Must have alert status. */ 522 if (!(scsw->cmd.stctl & SCSW_STCTL_ALERT_STATUS)) 523 return 0; 524 525 /* Must be alone or together with primary, secondary or both, 526 * => no intermediate status. 527 */ 528 if (scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS) 529 return 0; 530 531 return 1; 532} 533 534/** 535 * scsw_cmd_is_valid_pno - check pno field validity 536 * @scsw: pointer to scsw 537 * 538 * Return non-zero if the pno field of the specified command mode scsw is 539 * valid, zero otherwise. 540 */ 541static inline int scsw_cmd_is_valid_pno(union scsw *scsw) 542{ 543 /* Must indicate at least one I/O function. */ 544 if (!scsw->cmd.fctl) 545 return 0; 546 547 /* Must be status pending. */ 548 if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND)) 549 return 0; 550 551 /* Can be status pending alone, or with any combination of primary, 552 * secondary and alert => no intermediate status. 553 */ 554 if (!(scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS)) 555 return 1; 556 557 /* If intermediate, must be suspended. */ 558 if (scsw->cmd.actl & SCSW_ACTL_SUSPENDED) 559 return 1; 560 561 return 0; 562} 563 564/** 565 * scsw_cmd_is_valid_fctl - check fctl field validity 566 * @scsw: pointer to scsw 567 * 568 * Return non-zero if the fctl field of the specified command mode scsw is 569 * valid, zero otherwise. 570 */ 571static inline int scsw_cmd_is_valid_fctl(union scsw *scsw) 572{ 573 /* Only valid if pmcw.dnv == 1*/ 574 return 1; 575} 576 577/** 578 * scsw_cmd_is_valid_actl - check actl field validity 579 * @scsw: pointer to scsw 580 * 581 * Return non-zero if the actl field of the specified command mode scsw is 582 * valid, zero otherwise. 583 */ 584static inline int scsw_cmd_is_valid_actl(union scsw *scsw) 585{ 586 /* Only valid if pmcw.dnv == 1*/ 587 return 1; 588} 589 590/** 591 * scsw_cmd_is_valid_stctl - check stctl field validity 592 * @scsw: pointer to scsw 593 * 594 * Return non-zero if the stctl field of the specified command mode scsw is 595 * valid, zero otherwise. 596 */ 597static inline int scsw_cmd_is_valid_stctl(union scsw *scsw) 598{ 599 /* Only valid if pmcw.dnv == 1*/ 600 return 1; 601} 602 603/** 604 * scsw_cmd_is_valid_dstat - check dstat field validity 605 * @scsw: pointer to scsw 606 * 607 * Return non-zero if the dstat field of the specified command mode scsw is 608 * valid, zero otherwise. 609 */ 610static inline int scsw_cmd_is_valid_dstat(union scsw *scsw) 611{ 612 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) && 613 (scsw->cmd.cc != 3); 614} 615 616/** 617 * scsw_cmd_is_valid_cstat - check cstat field validity 618 * @scsw: pointer to scsw 619 * 620 * Return non-zero if the cstat field of the specified command mode scsw is 621 * valid, zero otherwise. 622 */ 623static inline int scsw_cmd_is_valid_cstat(union scsw *scsw) 624{ 625 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) && 626 (scsw->cmd.cc != 3); 627} 628 629/** 630 * scsw_tm_is_valid_key - check key field validity 631 * @scsw: pointer to scsw 632 * 633 * Return non-zero if the key field of the specified transport mode scsw is 634 * valid, zero otherwise. 635 */ 636static inline int scsw_tm_is_valid_key(union scsw *scsw) 637{ 638 return (scsw->tm.fctl & SCSW_FCTL_START_FUNC); 639} 640 641/** 642 * scsw_tm_is_valid_eswf - check eswf field validity 643 * @scsw: pointer to scsw 644 * 645 * Return non-zero if the eswf field of the specified transport mode scsw is 646 * valid, zero otherwise. 647 */ 648static inline int scsw_tm_is_valid_eswf(union scsw *scsw) 649{ 650 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND); 651} 652 653/** 654 * scsw_tm_is_valid_cc - check cc field validity 655 * @scsw: pointer to scsw 656 * 657 * Return non-zero if the cc field of the specified transport mode scsw is 658 * valid, zero otherwise. 659 */ 660static inline int scsw_tm_is_valid_cc(union scsw *scsw) 661{ 662 return (scsw->tm.fctl & SCSW_FCTL_START_FUNC) && 663 (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND); 664} 665 666/** 667 * scsw_tm_is_valid_fmt - check fmt field validity 668 * @scsw: pointer to scsw 669 * 670 * Return non-zero if the fmt field of the specified transport mode scsw is 671 * valid, zero otherwise. 672 */ 673static inline int scsw_tm_is_valid_fmt(union scsw *scsw) 674{ 675 return 1; 676} 677 678/** 679 * scsw_tm_is_valid_x - check x field validity 680 * @scsw: pointer to scsw 681 * 682 * Return non-zero if the x field of the specified transport mode scsw is 683 * valid, zero otherwise. 684 */ 685static inline int scsw_tm_is_valid_x(union scsw *scsw) 686{ 687 return 1; 688} 689 690/** 691 * scsw_tm_is_valid_q - check q field validity 692 * @scsw: pointer to scsw 693 * 694 * Return non-zero if the q field of the specified transport mode scsw is 695 * valid, zero otherwise. 696 */ 697static inline int scsw_tm_is_valid_q(union scsw *scsw) 698{ 699 return 1; 700} 701 702/** 703 * scsw_tm_is_valid_ectl - check ectl field validity 704 * @scsw: pointer to scsw 705 * 706 * Return non-zero if the ectl field of the specified transport mode scsw is 707 * valid, zero otherwise. 708 */ 709static inline int scsw_tm_is_valid_ectl(union scsw *scsw) 710{ 711 /* Must be status pending. */ 712 if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND)) 713 return 0; 714 715 /* Must have alert status. */ 716 if (!(scsw->tm.stctl & SCSW_STCTL_ALERT_STATUS)) 717 return 0; 718 719 /* Must be alone or together with primary, secondary or both, 720 * => no intermediate status. 721 */ 722 if (scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) 723 return 0; 724 725 return 1; 726} 727 728/** 729 * scsw_tm_is_valid_pno - check pno field validity 730 * @scsw: pointer to scsw 731 * 732 * Return non-zero if the pno field of the specified transport mode scsw is 733 * valid, zero otherwise. 734 */ 735static inline int scsw_tm_is_valid_pno(union scsw *scsw) 736{ 737 /* Must indicate at least one I/O function. */ 738 if (!scsw->tm.fctl) 739 return 0; 740 741 /* Must be status pending. */ 742 if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND)) 743 return 0; 744 745 /* Can be status pending alone, or with any combination of primary, 746 * secondary and alert => no intermediate status. 747 */ 748 if (!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS)) 749 return 1; 750 751 /* If intermediate, must be suspended. */ 752 if (scsw->tm.actl & SCSW_ACTL_SUSPENDED) 753 return 1; 754 755 return 0; 756} 757 758/** 759 * scsw_tm_is_valid_fctl - check fctl field validity 760 * @scsw: pointer to scsw 761 * 762 * Return non-zero if the fctl field of the specified transport mode scsw is 763 * valid, zero otherwise. 764 */ 765static inline int scsw_tm_is_valid_fctl(union scsw *scsw) 766{ 767 /* Only valid if pmcw.dnv == 1*/ 768 return 1; 769} 770 771/** 772 * scsw_tm_is_valid_actl - check actl field validity 773 * @scsw: pointer to scsw 774 * 775 * Return non-zero if the actl field of the specified transport mode scsw is 776 * valid, zero otherwise. 777 */ 778static inline int scsw_tm_is_valid_actl(union scsw *scsw) 779{ 780 /* Only valid if pmcw.dnv == 1*/ 781 return 1; 782} 783 784/** 785 * scsw_tm_is_valid_stctl - check stctl field validity 786 * @scsw: pointer to scsw 787 * 788 * Return non-zero if the stctl field of the specified transport mode scsw is 789 * valid, zero otherwise. 790 */ 791static inline int scsw_tm_is_valid_stctl(union scsw *scsw) 792{ 793 /* Only valid if pmcw.dnv == 1*/ 794 return 1; 795} 796 797/** 798 * scsw_tm_is_valid_dstat - check dstat field validity 799 * @scsw: pointer to scsw 800 * 801 * Return non-zero if the dstat field of the specified transport mode scsw is 802 * valid, zero otherwise. 803 */ 804static inline int scsw_tm_is_valid_dstat(union scsw *scsw) 805{ 806 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) && 807 (scsw->tm.cc != 3); 808} 809 810/** 811 * scsw_tm_is_valid_cstat - check cstat field validity 812 * @scsw: pointer to scsw 813 * 814 * Return non-zero if the cstat field of the specified transport mode scsw is 815 * valid, zero otherwise. 816 */ 817static inline int scsw_tm_is_valid_cstat(union scsw *scsw) 818{ 819 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) && 820 (scsw->tm.cc != 3); 821} 822 823/** 824 * scsw_tm_is_valid_fcxs - check fcxs field validity 825 * @scsw: pointer to scsw 826 * 827 * Return non-zero if the fcxs field of the specified transport mode scsw is 828 * valid, zero otherwise. 829 */ 830static inline int scsw_tm_is_valid_fcxs(union scsw *scsw) 831{ 832 return 1; 833} 834 835/** 836 * scsw_tm_is_valid_schxs - check schxs field validity 837 * @scsw: pointer to scsw 838 * 839 * Return non-zero if the schxs field of the specified transport mode scsw is 840 * valid, zero otherwise. 841 */ 842static inline int scsw_tm_is_valid_schxs(union scsw *scsw) 843{ 844 return (scsw->tm.cstat & (SCHN_STAT_PROG_CHECK | 845 SCHN_STAT_INTF_CTRL_CHK | 846 SCHN_STAT_PROT_CHECK | 847 SCHN_STAT_CHN_DATA_CHK)); 848} 849 850/** 851 * scsw_is_valid_actl - check actl field validity 852 * @scsw: pointer to scsw 853 * 854 * Return non-zero if the actl field of the specified scsw is valid, 855 * regardless of whether it is a transport mode or command mode scsw. 856 * Return zero if the field does not contain a valid value. 857 */ 858static inline int scsw_is_valid_actl(union scsw *scsw) 859{ 860 if (scsw_is_tm(scsw)) 861 return scsw_tm_is_valid_actl(scsw); 862 else 863 return scsw_cmd_is_valid_actl(scsw); 864} 865 866/** 867 * scsw_is_valid_cc - check cc field validity 868 * @scsw: pointer to scsw 869 * 870 * Return non-zero if the cc field of the specified scsw is valid, 871 * regardless of whether it is a transport mode or command mode scsw. 872 * Return zero if the field does not contain a valid value. 873 */ 874static inline int scsw_is_valid_cc(union scsw *scsw) 875{ 876 if (scsw_is_tm(scsw)) 877 return scsw_tm_is_valid_cc(scsw); 878 else 879 return scsw_cmd_is_valid_cc(scsw); 880} 881 882/** 883 * scsw_is_valid_cstat - check cstat field validity 884 * @scsw: pointer to scsw 885 * 886 * Return non-zero if the cstat field of the specified scsw is valid, 887 * regardless of whether it is a transport mode or command mode scsw. 888 * Return zero if the field does not contain a valid value. 889 */ 890static inline int scsw_is_valid_cstat(union scsw *scsw) 891{ 892 if (scsw_is_tm(scsw)) 893 return scsw_tm_is_valid_cstat(scsw); 894 else 895 return scsw_cmd_is_valid_cstat(scsw); 896} 897 898/** 899 * scsw_is_valid_dstat - check dstat field validity 900 * @scsw: pointer to scsw 901 * 902 * Return non-zero if the dstat field of the specified scsw is valid, 903 * regardless of whether it is a transport mode or command mode scsw. 904 * Return zero if the field does not contain a valid value. 905 */ 906static inline int scsw_is_valid_dstat(union scsw *scsw) 907{ 908 if (scsw_is_tm(scsw)) 909 return scsw_tm_is_valid_dstat(scsw); 910 else 911 return scsw_cmd_is_valid_dstat(scsw); 912} 913 914/** 915 * scsw_is_valid_ectl - check ectl field validity 916 * @scsw: pointer to scsw 917 * 918 * Return non-zero if the ectl field of the specified scsw is valid, 919 * regardless of whether it is a transport mode or command mode scsw. 920 * Return zero if the field does not contain a valid value. 921 */ 922static inline int scsw_is_valid_ectl(union scsw *scsw) 923{ 924 if (scsw_is_tm(scsw)) 925 return scsw_tm_is_valid_ectl(scsw); 926 else 927 return scsw_cmd_is_valid_ectl(scsw); 928} 929 930/** 931 * scsw_is_valid_eswf - check eswf field validity 932 * @scsw: pointer to scsw 933 * 934 * Return non-zero if the eswf field of the specified scsw is valid, 935 * regardless of whether it is a transport mode or command mode scsw. 936 * Return zero if the field does not contain a valid value. 937 */ 938static inline int scsw_is_valid_eswf(union scsw *scsw) 939{ 940 if (scsw_is_tm(scsw)) 941 return scsw_tm_is_valid_eswf(scsw); 942 else 943 return scsw_cmd_is_valid_eswf(scsw); 944} 945 946/** 947 * scsw_is_valid_fctl - check fctl field validity 948 * @scsw: pointer to scsw 949 * 950 * Return non-zero if the fctl field of the specified scsw is valid, 951 * regardless of whether it is a transport mode or command mode scsw. 952 * Return zero if the field does not contain a valid value. 953 */ 954static inline int scsw_is_valid_fctl(union scsw *scsw) 955{ 956 if (scsw_is_tm(scsw)) 957 return scsw_tm_is_valid_fctl(scsw); 958 else 959 return scsw_cmd_is_valid_fctl(scsw); 960} 961 962/** 963 * scsw_is_valid_key - check key field validity 964 * @scsw: pointer to scsw 965 * 966 * Return non-zero if the key field of the specified scsw is valid, 967 * regardless of whether it is a transport mode or command mode scsw. 968 * Return zero if the field does not contain a valid value. 969 */ 970static inline int scsw_is_valid_key(union scsw *scsw) 971{ 972 if (scsw_is_tm(scsw)) 973 return scsw_tm_is_valid_key(scsw); 974 else 975 return scsw_cmd_is_valid_key(scsw); 976} 977 978/** 979 * scsw_is_valid_pno - check pno field validity 980 * @scsw: pointer to scsw 981 * 982 * Return non-zero if the pno field of the specified scsw is valid, 983 * regardless of whether it is a transport mode or command mode scsw. 984 * Return zero if the field does not contain a valid value. 985 */ 986static inline int scsw_is_valid_pno(union scsw *scsw) 987{ 988 if (scsw_is_tm(scsw)) 989 return scsw_tm_is_valid_pno(scsw); 990 else 991 return scsw_cmd_is_valid_pno(scsw); 992} 993 994/** 995 * scsw_is_valid_stctl - check stctl field validity 996 * @scsw: pointer to scsw 997 * 998 * Return non-zero if the stctl field of the specified scsw is valid, 999 * regardless of whether it is a transport mode or command mode scsw. 1000 * Return zero if the field does not contain a valid value. 1001 */ 1002static inline int scsw_is_valid_stctl(union scsw *scsw) 1003{ 1004 if (scsw_is_tm(scsw)) 1005 return scsw_tm_is_valid_stctl(scsw); 1006 else 1007 return scsw_cmd_is_valid_stctl(scsw); 1008} 1009 1010/** 1011 * scsw_cmd_is_solicited - check for solicited scsw 1012 * @scsw: pointer to scsw 1013 * 1014 * Return non-zero if the command mode scsw indicates that the associated 1015 * status condition is solicited, zero if it is unsolicited. 1016 */ 1017static inline int scsw_cmd_is_solicited(union scsw *scsw) 1018{ 1019 return (scsw->cmd.cc != 0) || (scsw->cmd.stctl != 1020 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)); 1021} 1022 1023/** 1024 * scsw_tm_is_solicited - check for solicited scsw 1025 * @scsw: pointer to scsw 1026 * 1027 * Return non-zero if the transport mode scsw indicates that the associated 1028 * status condition is solicited, zero if it is unsolicited. 1029 */ 1030static inline int scsw_tm_is_solicited(union scsw *scsw) 1031{ 1032 return (scsw->tm.cc != 0) || (scsw->tm.stctl != 1033 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)); 1034} 1035 1036/** 1037 * scsw_is_solicited - check for solicited scsw 1038 * @scsw: pointer to scsw 1039 * 1040 * Return non-zero if the transport or command mode scsw indicates that the 1041 * associated status condition is solicited, zero if it is unsolicited. 1042 */ 1043static inline int scsw_is_solicited(union scsw *scsw) 1044{ 1045 if (scsw_is_tm(scsw)) 1046 return scsw_tm_is_solicited(scsw); 1047 else 1048 return scsw_cmd_is_solicited(scsw); 1049} 1050 1051#endif /* _ASM_S390_SCSW_H_ */ 1052