arch/s390/include/asm/scsw.h

   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  */
  39 struct 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  */
  81 struct 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  */
 117 struct 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  */
 140 union 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  */
 225 static 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  */
 237 static 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  */
 252 static 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  */
 267 static 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  */
 282 static 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  */
 297 static 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  */
 312 static 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  */
 327 static 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  */
 342 static 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  */
 357 static 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  */
 372 static 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  */
 387 static 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  */
 399 static 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  */
 411 static 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  */
 423 static 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  */
 436 static 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  */
 448 static 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  */
 460 static 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  */
 472 static 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  */
 484 static 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  */
 496 static 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  */
 509 static 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  */
 523 static 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.actl & SCSW_ACTL_SUSPENDED));
 529 }
 530
 531 /**
 532  * scsw_cmd_is_valid_fctl - check fctl field validity
 533  * @scsw: pointer to scsw
 534  *
 535  * Return non-zero if the fctl field of the specified command mode scsw is
 536  * valid, zero otherwise.
 537  */
 538 static inline int scsw_cmd_is_valid_fctl(union scsw *scsw)
 539 {
 540         /* Only valid if pmcw.dnv == 1*/
 541         return 1;
 542 }
 543
 544 /**
 545  * scsw_cmd_is_valid_actl - check actl field validity
 546  * @scsw: pointer to scsw
 547  *
 548  * Return non-zero if the actl field of the specified command mode scsw is
 549  * valid, zero otherwise.
 550  */
 551 static inline int scsw_cmd_is_valid_actl(union scsw *scsw)
 552 {
 553         /* Only valid if pmcw.dnv == 1*/
 554         return 1;
 555 }
 556
 557 /**
 558  * scsw_cmd_is_valid_stctl - check stctl field validity
 559  * @scsw: pointer to scsw
 560  *
 561  * Return non-zero if the stctl field of the specified command mode scsw is
 562  * valid, zero otherwise.
 563  */
 564 static inline int scsw_cmd_is_valid_stctl(union scsw *scsw)
 565 {
 566         /* Only valid if pmcw.dnv == 1*/
 567         return 1;
 568 }
 569
 570 /**
 571  * scsw_cmd_is_valid_dstat - check dstat field validity
 572  * @scsw: pointer to scsw
 573  *
 574  * Return non-zero if the dstat field of the specified command mode scsw is
 575  * valid, zero otherwise.
 576  */
 577 static inline int scsw_cmd_is_valid_dstat(union scsw *scsw)
 578 {
 579         return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) &&
 580                (scsw->cmd.cc != 3);
 581 }
 582
 583 /**
 584  * scsw_cmd_is_valid_cstat - check cstat field validity
 585  * @scsw: pointer to scsw
 586  *
 587  * Return non-zero if the cstat field of the specified command mode scsw is
 588  * valid, zero otherwise.
 589  */
 590 static inline int scsw_cmd_is_valid_cstat(union scsw *scsw)
 591 {
 592         return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) &&
 593                (scsw->cmd.cc != 3);
 594 }
 595
 596 /**
 597  * scsw_tm_is_valid_key - check key field validity
 598  * @scsw: pointer to scsw
 599  *
 600  * Return non-zero if the key field of the specified transport mode scsw is
 601  * valid, zero otherwise.
 602  */
 603 static inline int scsw_tm_is_valid_key(union scsw *scsw)
 604 {
 605         return (scsw->tm.fctl & SCSW_FCTL_START_FUNC);
 606 }
 607
 608 /**
 609  * scsw_tm_is_valid_eswf - check eswf field validity
 610  * @scsw: pointer to scsw
 611  *
 612  * Return non-zero if the eswf field of the specified transport mode scsw is
 613  * valid, zero otherwise.
 614  */
 615 static inline int scsw_tm_is_valid_eswf(union scsw *scsw)
 616 {
 617         return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND);
 618 }
 619
 620 /**
 621  * scsw_tm_is_valid_cc - check cc field validity
 622  * @scsw: pointer to scsw
 623  *
 624  * Return non-zero if the cc field of the specified transport mode scsw is
 625  * valid, zero otherwise.
 626  */
 627 static inline int scsw_tm_is_valid_cc(union scsw *scsw)
 628 {
 629         return (scsw->tm.fctl & SCSW_FCTL_START_FUNC) &&
 630                (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND);
 631 }
 632
 633 /**
 634  * scsw_tm_is_valid_fmt - check fmt field validity
 635  * @scsw: pointer to scsw
 636  *
 637  * Return non-zero if the fmt field of the specified transport mode scsw is
 638  * valid, zero otherwise.
 639  */
 640 static inline int scsw_tm_is_valid_fmt(union scsw *scsw)
 641 {
 642         return 1;
 643 }
 644
 645 /**
 646  * scsw_tm_is_valid_x - check x field validity
 647  * @scsw: pointer to scsw
 648  *
 649  * Return non-zero if the x field of the specified transport mode scsw is
 650  * valid, zero otherwise.
 651  */
 652 static inline int scsw_tm_is_valid_x(union scsw *scsw)
 653 {
 654         return 1;
 655 }
 656
 657 /**
 658  * scsw_tm_is_valid_q - check q field validity
 659  * @scsw: pointer to scsw
 660  *
 661  * Return non-zero if the q field of the specified transport mode scsw is
 662  * valid, zero otherwise.
 663  */
 664 static inline int scsw_tm_is_valid_q(union scsw *scsw)
 665 {
 666         return 1;
 667 }
 668
 669 /**
 670  * scsw_tm_is_valid_ectl - check ectl field validity
 671  * @scsw: pointer to scsw
 672  *
 673  * Return non-zero if the ectl field of the specified transport mode scsw is
 674  * valid, zero otherwise.
 675  */
 676 static inline int scsw_tm_is_valid_ectl(union scsw *scsw)
 677 {
 678         return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&
 679                !(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) &&
 680                (scsw->tm.stctl & SCSW_STCTL_ALERT_STATUS);
 681 }
 682
 683 /**
 684  * scsw_tm_is_valid_pno - check pno field validity
 685  * @scsw: pointer to scsw
 686  *
 687  * Return non-zero if the pno field of the specified transport mode scsw is
 688  * valid, zero otherwise.
 689  */
 690 static inline int scsw_tm_is_valid_pno(union scsw *scsw)
 691 {
 692         return (scsw->tm.fctl != 0) &&
 693                (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&
 694                (!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) ||
 695                  ((scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) &&
 696                   (scsw->tm.actl & SCSW_ACTL_SUSPENDED)));
 697 }
 698
 699 /**
 700  * scsw_tm_is_valid_fctl - check fctl field validity
 701  * @scsw: pointer to scsw
 702  *
 703  * Return non-zero if the fctl field of the specified transport mode scsw is
 704  * valid, zero otherwise.
 705  */
 706 static inline int scsw_tm_is_valid_fctl(union scsw *scsw)
 707 {
 708         /* Only valid if pmcw.dnv == 1*/
 709         return 1;
 710 }
 711
 712 /**
 713  * scsw_tm_is_valid_actl - check actl field validity
 714  * @scsw: pointer to scsw
 715  *
 716  * Return non-zero if the actl field of the specified transport mode scsw is
 717  * valid, zero otherwise.
 718  */
 719 static inline int scsw_tm_is_valid_actl(union scsw *scsw)
 720 {
 721         /* Only valid if pmcw.dnv == 1*/
 722         return 1;
 723 }
 724
 725 /**
 726  * scsw_tm_is_valid_stctl - check stctl field validity
 727  * @scsw: pointer to scsw
 728  *
 729  * Return non-zero if the stctl field of the specified transport mode scsw is
 730  * valid, zero otherwise.
 731  */
 732 static inline int scsw_tm_is_valid_stctl(union scsw *scsw)
 733 {
 734         /* Only valid if pmcw.dnv == 1*/
 735         return 1;
 736 }
 737
 738 /**
 739  * scsw_tm_is_valid_dstat - check dstat field validity
 740  * @scsw: pointer to scsw
 741  *
 742  * Return non-zero if the dstat field of the specified transport mode scsw is
 743  * valid, zero otherwise.
 744  */
 745 static inline int scsw_tm_is_valid_dstat(union scsw *scsw)
 746 {
 747         return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&
 748                (scsw->tm.cc != 3);
 749 }
 750
 751 /**
 752  * scsw_tm_is_valid_cstat - check cstat field validity
 753  * @scsw: pointer to scsw
 754  *
 755  * Return non-zero if the cstat field of the specified transport mode scsw is
 756  * valid, zero otherwise.
 757  */
 758 static inline int scsw_tm_is_valid_cstat(union scsw *scsw)
 759 {
 760         return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&
 761                (scsw->tm.cc != 3);
 762 }
 763
 764 /**
 765  * scsw_tm_is_valid_fcxs - check fcxs field validity
 766  * @scsw: pointer to scsw
 767  *
 768  * Return non-zero if the fcxs field of the specified transport mode scsw is
 769  * valid, zero otherwise.
 770  */
 771 static inline int scsw_tm_is_valid_fcxs(union scsw *scsw)
 772 {
 773         return 1;
 774 }
 775
 776 /**
 777  * scsw_tm_is_valid_schxs - check schxs field validity
 778  * @scsw: pointer to scsw
 779  *
 780  * Return non-zero if the schxs field of the specified transport mode scsw is
 781  * valid, zero otherwise.
 782  */
 783 static inline int scsw_tm_is_valid_schxs(union scsw *scsw)
 784 {
 785         return (scsw->tm.cstat & (SCHN_STAT_PROG_CHECK |
 786                                   SCHN_STAT_INTF_CTRL_CHK |
 787                                   SCHN_STAT_PROT_CHECK |
 788                                   SCHN_STAT_CHN_DATA_CHK));
 789 }
 790
 791 /**
 792  * scsw_is_valid_actl - check actl field validity
 793  * @scsw: pointer to scsw
 794  *
 795  * Return non-zero if the actl field of the specified scsw is valid,
 796  * regardless of whether it is a transport mode or command mode scsw.
 797  * Return zero if the field does not contain a valid value.
 798  */
 799 static inline int scsw_is_valid_actl(union scsw *scsw)
 800 {
 801         if (scsw_is_tm(scsw))
 802                 return scsw_tm_is_valid_actl(scsw);
 803         else
 804                 return scsw_cmd_is_valid_actl(scsw);
 805 }
 806
 807 /**
 808  * scsw_is_valid_cc - check cc field validity
 809  * @scsw: pointer to scsw
 810  *
 811  * Return non-zero if the cc field of the specified scsw is valid,
 812  * regardless of whether it is a transport mode or command mode scsw.
 813  * Return zero if the field does not contain a valid value.
 814  */
 815 static inline int scsw_is_valid_cc(union scsw *scsw)
 816 {
 817         if (scsw_is_tm(scsw))
 818                 return scsw_tm_is_valid_cc(scsw);
 819         else
 820                 return scsw_cmd_is_valid_cc(scsw);
 821 }
 822
 823 /**
 824  * scsw_is_valid_cstat - check cstat field validity
 825  * @scsw: pointer to scsw
 826  *
 827  * Return non-zero if the cstat field of the specified scsw is valid,
 828  * regardless of whether it is a transport mode or command mode scsw.
 829  * Return zero if the field does not contain a valid value.
 830  */
 831 static inline int scsw_is_valid_cstat(union scsw *scsw)
 832 {
 833         if (scsw_is_tm(scsw))
 834                 return scsw_tm_is_valid_cstat(scsw);
 835         else
 836                 return scsw_cmd_is_valid_cstat(scsw);
 837 }
 838
 839 /**
 840  * scsw_is_valid_dstat - check dstat field validity
 841  * @scsw: pointer to scsw
 842  *
 843  * Return non-zero if the dstat field of the specified scsw is valid,
 844  * regardless of whether it is a transport mode or command mode scsw.
 845  * Return zero if the field does not contain a valid value.
 846  */
 847 static inline int scsw_is_valid_dstat(union scsw *scsw)
 848 {
 849         if (scsw_is_tm(scsw))
 850                 return scsw_tm_is_valid_dstat(scsw);
 851         else
 852                 return scsw_cmd_is_valid_dstat(scsw);
 853 }
 854
 855 /**
 856  * scsw_is_valid_ectl - check ectl field validity
 857  * @scsw: pointer to scsw
 858  *
 859  * Return non-zero if the ectl field of the specified scsw is valid,
 860  * regardless of whether it is a transport mode or command mode scsw.
 861  * Return zero if the field does not contain a valid value.
 862  */
 863 static inline int scsw_is_valid_ectl(union scsw *scsw)
 864 {
 865         if (scsw_is_tm(scsw))
 866                 return scsw_tm_is_valid_ectl(scsw);
 867         else
 868                 return scsw_cmd_is_valid_ectl(scsw);
 869 }
 870
 871 /**
 872  * scsw_is_valid_eswf - check eswf field validity
 873  * @scsw: pointer to scsw
 874  *
 875  * Return non-zero if the eswf field of the specified scsw is valid,
 876  * regardless of whether it is a transport mode or command mode scsw.
 877  * Return zero if the field does not contain a valid value.
 878  */
 879 static inline int scsw_is_valid_eswf(union scsw *scsw)
 880 {
 881         if (scsw_is_tm(scsw))
 882                 return scsw_tm_is_valid_eswf(scsw);
 883         else
 884                 return scsw_cmd_is_valid_eswf(scsw);
 885 }
 886
 887 /**
 888  * scsw_is_valid_fctl - check fctl field validity
 889  * @scsw: pointer to scsw
 890  *
 891  * Return non-zero if the fctl field of the specified scsw is valid,
 892  * regardless of whether it is a transport mode or command mode scsw.
 893  * Return zero if the field does not contain a valid value.
 894  */
 895 static inline int scsw_is_valid_fctl(union scsw *scsw)
 896 {
 897         if (scsw_is_tm(scsw))
 898                 return scsw_tm_is_valid_fctl(scsw);
 899         else
 900                 return scsw_cmd_is_valid_fctl(scsw);
 901 }
 902
 903 /**
 904  * scsw_is_valid_key - check key field validity
 905  * @scsw: pointer to scsw
 906  *
 907  * Return non-zero if the key field of the specified scsw is valid,
 908  * regardless of whether it is a transport mode or command mode scsw.
 909  * Return zero if the field does not contain a valid value.
 910  */
 911 static inline int scsw_is_valid_key(union scsw *scsw)
 912 {
 913         if (scsw_is_tm(scsw))
 914                 return scsw_tm_is_valid_key(scsw);
 915         else
 916                 return scsw_cmd_is_valid_key(scsw);
 917 }
 918
 919 /**
 920  * scsw_is_valid_pno - check pno field validity
 921  * @scsw: pointer to scsw
 922  *
 923  * Return non-zero if the pno field of the specified scsw is valid,
 924  * regardless of whether it is a transport mode or command mode scsw.
 925  * Return zero if the field does not contain a valid value.
 926  */
 927 static inline int scsw_is_valid_pno(union scsw *scsw)
 928 {
 929         if (scsw_is_tm(scsw))
 930                 return scsw_tm_is_valid_pno(scsw);
 931         else
 932                 return scsw_cmd_is_valid_pno(scsw);
 933 }
 934
 935 /**
 936  * scsw_is_valid_stctl - check stctl field validity
 937  * @scsw: pointer to scsw
 938  *
 939  * Return non-zero if the stctl field of the specified scsw is valid,
 940  * regardless of whether it is a transport mode or command mode scsw.
 941  * Return zero if the field does not contain a valid value.
 942  */
 943 static inline int scsw_is_valid_stctl(union scsw *scsw)
 944 {
 945         if (scsw_is_tm(scsw))
 946                 return scsw_tm_is_valid_stctl(scsw);
 947         else
 948                 return scsw_cmd_is_valid_stctl(scsw);
 949 }
 950
 951 /**
 952  * scsw_cmd_is_solicited - check for solicited scsw
 953  * @scsw: pointer to scsw
 954  *
 955  * Return non-zero if the command mode scsw indicates that the associated
 956  * status condition is solicited, zero if it is unsolicited.
 957  */
 958 static inline int scsw_cmd_is_solicited(union scsw *scsw)
 959 {
 960         return (scsw->cmd.cc != 0) || (scsw->cmd.stctl !=
 961                 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS));
 962 }
 963
 964 /**
 965  * scsw_tm_is_solicited - check for solicited scsw
 966  * @scsw: pointer to scsw
 967  *
 968  * Return non-zero if the transport mode scsw indicates that the associated
 969  * status condition is solicited, zero if it is unsolicited.
 970  */
 971 static inline int scsw_tm_is_solicited(union scsw *scsw)
 972 {
 973         return (scsw->tm.cc != 0) || (scsw->tm.stctl !=
 974                 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS));
 975 }
 976
 977 /**
 978  * scsw_is_solicited - check for solicited scsw
 979  * @scsw: pointer to scsw
 980  *
 981  * Return non-zero if the transport or command mode scsw indicates that the
 982  * associated status condition is solicited, zero if it is unsolicited.
 983  */
 984 static inline int scsw_is_solicited(union scsw *scsw)
 985 {
 986         if (scsw_is_tm(scsw))
 987                 return scsw_tm_is_solicited(scsw);
 988         else
 989                 return scsw_cmd_is_solicited(scsw);
 990 }
 991
 992 #endif /* _ASM_S390_SCSW_H_ */