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