arch/s390/include/asm/scsw.h

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