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