arch/s390/include/asm/scsw.h

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