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.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  */
 539 static 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  */
 552 static 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  */
 565 static 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  */
 578 static 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  */
 591 static 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  */
 604 static 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  */
 616 static 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  */
 628 static 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  */
 641 static 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  */
 653 static 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  */
 665 static 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  */
 677 static 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  */
 691 static 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  */
 707 static 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  */
 720 static 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  */
 733 static 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  */
 746 static 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  */
 759 static 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  */
 772 static 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  */
 784 static 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  */
 800 static 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  */
 816 static 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  */
 832 static 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  */
 848 static 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  */
 864 static 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  */
 880 static 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  */
 896 static 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  */
 912 static 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  */
 928 static 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  */
 944 static 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  */
 959 static 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  */
 972 static 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  */
 985 static 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_ */