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 * architectured values for PPRC errors 220 */ 221 #define SNS7_INVALID_ON_SEC 0x0e 222 223 /** 224 * scsw_is_tm - check for transport mode scsw 225 * @scsw: pointer to scsw 226 * 227 * Return non-zero if the specified scsw is a transport mode scsw, zero 228 * otherwise. 229 */ scsw_is_tm(union scsw * scsw)230 static inline int scsw_is_tm(union scsw *scsw) 231 { 232 return css_general_characteristics.fcx && (scsw->tm.x == 1); 233 } 234 235 /** 236 * scsw_key - return scsw key field 237 * @scsw: pointer to scsw 238 * 239 * Return the value of the key field of the specified scsw, regardless of 240 * whether it is a transport mode or command mode scsw. 241 */ scsw_key(union scsw * scsw)242 static inline u32 scsw_key(union scsw *scsw) 243 { 244 if (scsw_is_tm(scsw)) 245 return scsw->tm.key; 246 else 247 return scsw->cmd.key; 248 } 249 250 /** 251 * scsw_eswf - return scsw eswf field 252 * @scsw: pointer to scsw 253 * 254 * Return the value of the eswf field of the specified scsw, regardless of 255 * whether it is a transport mode or command mode scsw. 256 */ scsw_eswf(union scsw * scsw)257 static inline u32 scsw_eswf(union scsw *scsw) 258 { 259 if (scsw_is_tm(scsw)) 260 return scsw->tm.eswf; 261 else 262 return scsw->cmd.eswf; 263 } 264 265 /** 266 * scsw_cc - return scsw cc field 267 * @scsw: pointer to scsw 268 * 269 * Return the value of the cc field of the specified scsw, regardless of 270 * whether it is a transport mode or command mode scsw. 271 */ scsw_cc(union scsw * scsw)272 static inline u32 scsw_cc(union scsw *scsw) 273 { 274 if (scsw_is_tm(scsw)) 275 return scsw->tm.cc; 276 else 277 return scsw->cmd.cc; 278 } 279 280 /** 281 * scsw_ectl - return scsw ectl field 282 * @scsw: pointer to scsw 283 * 284 * Return the value of the ectl field of the specified scsw, regardless of 285 * whether it is a transport mode or command mode scsw. 286 */ scsw_ectl(union scsw * scsw)287 static inline u32 scsw_ectl(union scsw *scsw) 288 { 289 if (scsw_is_tm(scsw)) 290 return scsw->tm.ectl; 291 else 292 return scsw->cmd.ectl; 293 } 294 295 /** 296 * scsw_pno - return scsw pno field 297 * @scsw: pointer to scsw 298 * 299 * Return the value of the pno field of the specified scsw, regardless of 300 * whether it is a transport mode or command mode scsw. 301 */ scsw_pno(union scsw * scsw)302 static inline u32 scsw_pno(union scsw *scsw) 303 { 304 if (scsw_is_tm(scsw)) 305 return scsw->tm.pno; 306 else 307 return scsw->cmd.pno; 308 } 309 310 /** 311 * scsw_fctl - return scsw fctl field 312 * @scsw: pointer to scsw 313 * 314 * Return the value of the fctl field of the specified scsw, regardless of 315 * whether it is a transport mode or command mode scsw. 316 */ scsw_fctl(union scsw * scsw)317 static inline u32 scsw_fctl(union scsw *scsw) 318 { 319 if (scsw_is_tm(scsw)) 320 return scsw->tm.fctl; 321 else 322 return scsw->cmd.fctl; 323 } 324 325 /** 326 * scsw_actl - return scsw actl field 327 * @scsw: pointer to scsw 328 * 329 * Return the value of the actl field of the specified scsw, regardless of 330 * whether it is a transport mode or command mode scsw. 331 */ scsw_actl(union scsw * scsw)332 static inline u32 scsw_actl(union scsw *scsw) 333 { 334 if (scsw_is_tm(scsw)) 335 return scsw->tm.actl; 336 else 337 return scsw->cmd.actl; 338 } 339 340 /** 341 * scsw_stctl - return scsw stctl field 342 * @scsw: pointer to scsw 343 * 344 * Return the value of the stctl field of the specified scsw, regardless of 345 * whether it is a transport mode or command mode scsw. 346 */ scsw_stctl(union scsw * scsw)347 static inline u32 scsw_stctl(union scsw *scsw) 348 { 349 if (scsw_is_tm(scsw)) 350 return scsw->tm.stctl; 351 else 352 return scsw->cmd.stctl; 353 } 354 355 /** 356 * scsw_dstat - return scsw dstat field 357 * @scsw: pointer to scsw 358 * 359 * Return the value of the dstat field of the specified scsw, regardless of 360 * whether it is a transport mode or command mode scsw. 361 */ scsw_dstat(union scsw * scsw)362 static inline u32 scsw_dstat(union scsw *scsw) 363 { 364 if (scsw_is_tm(scsw)) 365 return scsw->tm.dstat; 366 else 367 return scsw->cmd.dstat; 368 } 369 370 /** 371 * scsw_cstat - return scsw cstat field 372 * @scsw: pointer to scsw 373 * 374 * Return the value of the cstat field of the specified scsw, regardless of 375 * whether it is a transport mode or command mode scsw. 376 */ scsw_cstat(union scsw * scsw)377 static inline u32 scsw_cstat(union scsw *scsw) 378 { 379 if (scsw_is_tm(scsw)) 380 return scsw->tm.cstat; 381 else 382 return scsw->cmd.cstat; 383 } 384 385 /** 386 * scsw_cmd_is_valid_key - check key field validity 387 * @scsw: pointer to scsw 388 * 389 * Return non-zero if the key field of the specified command mode scsw is 390 * valid, zero otherwise. 391 */ scsw_cmd_is_valid_key(union scsw * scsw)392 static inline int scsw_cmd_is_valid_key(union scsw *scsw) 393 { 394 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 395 } 396 397 /** 398 * scsw_cmd_is_valid_sctl - check sctl field validity 399 * @scsw: pointer to scsw 400 * 401 * Return non-zero if the sctl field of the specified command mode scsw is 402 * valid, zero otherwise. 403 */ scsw_cmd_is_valid_sctl(union scsw * scsw)404 static inline int scsw_cmd_is_valid_sctl(union scsw *scsw) 405 { 406 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 407 } 408 409 /** 410 * scsw_cmd_is_valid_eswf - check eswf field validity 411 * @scsw: pointer to scsw 412 * 413 * Return non-zero if the eswf field of the specified command mode scsw is 414 * valid, zero otherwise. 415 */ scsw_cmd_is_valid_eswf(union scsw * scsw)416 static inline int scsw_cmd_is_valid_eswf(union scsw *scsw) 417 { 418 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND); 419 } 420 421 /** 422 * scsw_cmd_is_valid_cc - check cc field validity 423 * @scsw: pointer to scsw 424 * 425 * Return non-zero if the cc field of the specified command mode scsw is 426 * valid, zero otherwise. 427 */ scsw_cmd_is_valid_cc(union scsw * scsw)428 static inline int scsw_cmd_is_valid_cc(union scsw *scsw) 429 { 430 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && 431 (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND); 432 } 433 434 /** 435 * scsw_cmd_is_valid_fmt - check fmt field validity 436 * @scsw: pointer to scsw 437 * 438 * Return non-zero if the fmt field of the specified command mode scsw is 439 * valid, zero otherwise. 440 */ scsw_cmd_is_valid_fmt(union scsw * scsw)441 static inline int scsw_cmd_is_valid_fmt(union scsw *scsw) 442 { 443 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 444 } 445 446 /** 447 * scsw_cmd_is_valid_pfch - check pfch field validity 448 * @scsw: pointer to scsw 449 * 450 * Return non-zero if the pfch field of the specified command mode scsw is 451 * valid, zero otherwise. 452 */ scsw_cmd_is_valid_pfch(union scsw * scsw)453 static inline int scsw_cmd_is_valid_pfch(union scsw *scsw) 454 { 455 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 456 } 457 458 /** 459 * scsw_cmd_is_valid_isic - check isic field validity 460 * @scsw: pointer to scsw 461 * 462 * Return non-zero if the isic field of the specified command mode scsw is 463 * valid, zero otherwise. 464 */ scsw_cmd_is_valid_isic(union scsw * scsw)465 static inline int scsw_cmd_is_valid_isic(union scsw *scsw) 466 { 467 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 468 } 469 470 /** 471 * scsw_cmd_is_valid_alcc - check alcc field validity 472 * @scsw: pointer to scsw 473 * 474 * Return non-zero if the alcc field of the specified command mode scsw is 475 * valid, zero otherwise. 476 */ scsw_cmd_is_valid_alcc(union scsw * scsw)477 static inline int scsw_cmd_is_valid_alcc(union scsw *scsw) 478 { 479 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 480 } 481 482 /** 483 * scsw_cmd_is_valid_ssi - check ssi field validity 484 * @scsw: pointer to scsw 485 * 486 * Return non-zero if the ssi field of the specified command mode scsw is 487 * valid, zero otherwise. 488 */ scsw_cmd_is_valid_ssi(union scsw * scsw)489 static inline int scsw_cmd_is_valid_ssi(union scsw *scsw) 490 { 491 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC); 492 } 493 494 /** 495 * scsw_cmd_is_valid_zcc - check zcc field validity 496 * @scsw: pointer to scsw 497 * 498 * Return non-zero if the zcc field of the specified command mode scsw is 499 * valid, zero otherwise. 500 */ scsw_cmd_is_valid_zcc(union scsw * scsw)501 static inline int scsw_cmd_is_valid_zcc(union scsw *scsw) 502 { 503 return (scsw->cmd.fctl & SCSW_FCTL_START_FUNC) && 504 (scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS); 505 } 506 507 /** 508 * scsw_cmd_is_valid_ectl - check ectl field validity 509 * @scsw: pointer to scsw 510 * 511 * Return non-zero if the ectl field of the specified command mode scsw is 512 * valid, zero otherwise. 513 */ scsw_cmd_is_valid_ectl(union scsw * scsw)514 static inline int scsw_cmd_is_valid_ectl(union scsw *scsw) 515 { 516 /* Must be status pending. */ 517 if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND)) 518 return 0; 519 520 /* Must have alert status. */ 521 if (!(scsw->cmd.stctl & SCSW_STCTL_ALERT_STATUS)) 522 return 0; 523 524 /* Must be alone or together with primary, secondary or both, 525 * => no intermediate status. 526 */ 527 if (scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS) 528 return 0; 529 530 return 1; 531 } 532 533 /** 534 * scsw_cmd_is_valid_pno - check pno field validity 535 * @scsw: pointer to scsw 536 * 537 * Return non-zero if the pno field of the specified command mode scsw is 538 * valid, zero otherwise. 539 */ scsw_cmd_is_valid_pno(union scsw * scsw)540 static inline int scsw_cmd_is_valid_pno(union scsw *scsw) 541 { 542 /* Must indicate at least one I/O function. */ 543 if (!scsw->cmd.fctl) 544 return 0; 545 546 /* Must be status pending. */ 547 if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND)) 548 return 0; 549 550 /* Can be status pending alone, or with any combination of primary, 551 * secondary and alert => no intermediate status. 552 */ 553 if (!(scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS)) 554 return 1; 555 556 /* If intermediate, must be suspended. */ 557 if (scsw->cmd.actl & SCSW_ACTL_SUSPENDED) 558 return 1; 559 560 return 0; 561 } 562 563 /** 564 * scsw_cmd_is_valid_fctl - check fctl field validity 565 * @scsw: pointer to scsw 566 * 567 * Return non-zero if the fctl field of the specified command mode scsw is 568 * valid, zero otherwise. 569 */ scsw_cmd_is_valid_fctl(union scsw * scsw)570 static inline int scsw_cmd_is_valid_fctl(union scsw *scsw) 571 { 572 /* Only valid if pmcw.dnv == 1*/ 573 return 1; 574 } 575 576 /** 577 * scsw_cmd_is_valid_actl - check actl field validity 578 * @scsw: pointer to scsw 579 * 580 * Return non-zero if the actl field of the specified command mode scsw is 581 * valid, zero otherwise. 582 */ scsw_cmd_is_valid_actl(union scsw * scsw)583 static inline int scsw_cmd_is_valid_actl(union scsw *scsw) 584 { 585 /* Only valid if pmcw.dnv == 1*/ 586 return 1; 587 } 588 589 /** 590 * scsw_cmd_is_valid_stctl - check stctl field validity 591 * @scsw: pointer to scsw 592 * 593 * Return non-zero if the stctl field of the specified command mode scsw is 594 * valid, zero otherwise. 595 */ scsw_cmd_is_valid_stctl(union scsw * scsw)596 static inline int scsw_cmd_is_valid_stctl(union scsw *scsw) 597 { 598 /* Only valid if pmcw.dnv == 1*/ 599 return 1; 600 } 601 602 /** 603 * scsw_cmd_is_valid_dstat - check dstat field validity 604 * @scsw: pointer to scsw 605 * 606 * Return non-zero if the dstat field of the specified command mode scsw is 607 * valid, zero otherwise. 608 */ scsw_cmd_is_valid_dstat(union scsw * scsw)609 static inline int scsw_cmd_is_valid_dstat(union scsw *scsw) 610 { 611 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) && 612 (scsw->cmd.cc != 3); 613 } 614 615 /** 616 * scsw_cmd_is_valid_cstat - check cstat field validity 617 * @scsw: pointer to scsw 618 * 619 * Return non-zero if the cstat field of the specified command mode scsw is 620 * valid, zero otherwise. 621 */ scsw_cmd_is_valid_cstat(union scsw * scsw)622 static inline int scsw_cmd_is_valid_cstat(union scsw *scsw) 623 { 624 return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) && 625 (scsw->cmd.cc != 3); 626 } 627 628 /** 629 * scsw_tm_is_valid_key - check key field validity 630 * @scsw: pointer to scsw 631 * 632 * Return non-zero if the key field of the specified transport mode scsw is 633 * valid, zero otherwise. 634 */ scsw_tm_is_valid_key(union scsw * scsw)635 static inline int scsw_tm_is_valid_key(union scsw *scsw) 636 { 637 return (scsw->tm.fctl & SCSW_FCTL_START_FUNC); 638 } 639 640 /** 641 * scsw_tm_is_valid_eswf - check eswf field validity 642 * @scsw: pointer to scsw 643 * 644 * Return non-zero if the eswf field of the specified transport mode scsw is 645 * valid, zero otherwise. 646 */ scsw_tm_is_valid_eswf(union scsw * scsw)647 static inline int scsw_tm_is_valid_eswf(union scsw *scsw) 648 { 649 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND); 650 } 651 652 /** 653 * scsw_tm_is_valid_cc - check cc field validity 654 * @scsw: pointer to scsw 655 * 656 * Return non-zero if the cc field of the specified transport mode scsw is 657 * valid, zero otherwise. 658 */ scsw_tm_is_valid_cc(union scsw * scsw)659 static inline int scsw_tm_is_valid_cc(union scsw *scsw) 660 { 661 return (scsw->tm.fctl & SCSW_FCTL_START_FUNC) && 662 (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND); 663 } 664 665 /** 666 * scsw_tm_is_valid_fmt - check fmt field validity 667 * @scsw: pointer to scsw 668 * 669 * Return non-zero if the fmt field of the specified transport mode scsw is 670 * valid, zero otherwise. 671 */ scsw_tm_is_valid_fmt(union scsw * scsw)672 static inline int scsw_tm_is_valid_fmt(union scsw *scsw) 673 { 674 return 1; 675 } 676 677 /** 678 * scsw_tm_is_valid_x - check x field validity 679 * @scsw: pointer to scsw 680 * 681 * Return non-zero if the x field of the specified transport mode scsw is 682 * valid, zero otherwise. 683 */ scsw_tm_is_valid_x(union scsw * scsw)684 static inline int scsw_tm_is_valid_x(union scsw *scsw) 685 { 686 return 1; 687 } 688 689 /** 690 * scsw_tm_is_valid_q - check q field validity 691 * @scsw: pointer to scsw 692 * 693 * Return non-zero if the q field of the specified transport mode scsw is 694 * valid, zero otherwise. 695 */ scsw_tm_is_valid_q(union scsw * scsw)696 static inline int scsw_tm_is_valid_q(union scsw *scsw) 697 { 698 return 1; 699 } 700 701 /** 702 * scsw_tm_is_valid_ectl - check ectl field validity 703 * @scsw: pointer to scsw 704 * 705 * Return non-zero if the ectl field of the specified transport mode scsw is 706 * valid, zero otherwise. 707 */ scsw_tm_is_valid_ectl(union scsw * scsw)708 static inline int scsw_tm_is_valid_ectl(union scsw *scsw) 709 { 710 /* Must be status pending. */ 711 if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND)) 712 return 0; 713 714 /* Must have alert status. */ 715 if (!(scsw->tm.stctl & SCSW_STCTL_ALERT_STATUS)) 716 return 0; 717 718 /* Must be alone or together with primary, secondary or both, 719 * => no intermediate status. 720 */ 721 if (scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) 722 return 0; 723 724 return 1; 725 } 726 727 /** 728 * scsw_tm_is_valid_pno - check pno field validity 729 * @scsw: pointer to scsw 730 * 731 * Return non-zero if the pno field of the specified transport mode scsw is 732 * valid, zero otherwise. 733 */ scsw_tm_is_valid_pno(union scsw * scsw)734 static inline int scsw_tm_is_valid_pno(union scsw *scsw) 735 { 736 /* Must indicate at least one I/O function. */ 737 if (!scsw->tm.fctl) 738 return 0; 739 740 /* Must be status pending. */ 741 if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND)) 742 return 0; 743 744 /* Can be status pending alone, or with any combination of primary, 745 * secondary and alert => no intermediate status. 746 */ 747 if (!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS)) 748 return 1; 749 750 /* If intermediate, must be suspended. */ 751 if (scsw->tm.actl & SCSW_ACTL_SUSPENDED) 752 return 1; 753 754 return 0; 755 } 756 757 /** 758 * scsw_tm_is_valid_fctl - check fctl field validity 759 * @scsw: pointer to scsw 760 * 761 * Return non-zero if the fctl field of the specified transport mode scsw is 762 * valid, zero otherwise. 763 */ scsw_tm_is_valid_fctl(union scsw * scsw)764 static inline int scsw_tm_is_valid_fctl(union scsw *scsw) 765 { 766 /* Only valid if pmcw.dnv == 1*/ 767 return 1; 768 } 769 770 /** 771 * scsw_tm_is_valid_actl - check actl field validity 772 * @scsw: pointer to scsw 773 * 774 * Return non-zero if the actl field of the specified transport mode scsw is 775 * valid, zero otherwise. 776 */ scsw_tm_is_valid_actl(union scsw * scsw)777 static inline int scsw_tm_is_valid_actl(union scsw *scsw) 778 { 779 /* Only valid if pmcw.dnv == 1*/ 780 return 1; 781 } 782 783 /** 784 * scsw_tm_is_valid_stctl - check stctl field validity 785 * @scsw: pointer to scsw 786 * 787 * Return non-zero if the stctl field of the specified transport mode scsw is 788 * valid, zero otherwise. 789 */ scsw_tm_is_valid_stctl(union scsw * scsw)790 static inline int scsw_tm_is_valid_stctl(union scsw *scsw) 791 { 792 /* Only valid if pmcw.dnv == 1*/ 793 return 1; 794 } 795 796 /** 797 * scsw_tm_is_valid_dstat - check dstat field validity 798 * @scsw: pointer to scsw 799 * 800 * Return non-zero if the dstat field of the specified transport mode scsw is 801 * valid, zero otherwise. 802 */ scsw_tm_is_valid_dstat(union scsw * scsw)803 static inline int scsw_tm_is_valid_dstat(union scsw *scsw) 804 { 805 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) && 806 (scsw->tm.cc != 3); 807 } 808 809 /** 810 * scsw_tm_is_valid_cstat - check cstat field validity 811 * @scsw: pointer to scsw 812 * 813 * Return non-zero if the cstat field of the specified transport mode scsw is 814 * valid, zero otherwise. 815 */ scsw_tm_is_valid_cstat(union scsw * scsw)816 static inline int scsw_tm_is_valid_cstat(union scsw *scsw) 817 { 818 return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) && 819 (scsw->tm.cc != 3); 820 } 821 822 /** 823 * scsw_tm_is_valid_fcxs - check fcxs field validity 824 * @scsw: pointer to scsw 825 * 826 * Return non-zero if the fcxs field of the specified transport mode scsw is 827 * valid, zero otherwise. 828 */ scsw_tm_is_valid_fcxs(union scsw * scsw)829 static inline int scsw_tm_is_valid_fcxs(union scsw *scsw) 830 { 831 return 1; 832 } 833 834 /** 835 * scsw_tm_is_valid_schxs - check schxs field validity 836 * @scsw: pointer to scsw 837 * 838 * Return non-zero if the schxs field of the specified transport mode scsw is 839 * valid, zero otherwise. 840 */ scsw_tm_is_valid_schxs(union scsw * scsw)841 static inline int scsw_tm_is_valid_schxs(union scsw *scsw) 842 { 843 return (scsw->tm.cstat & (SCHN_STAT_PROG_CHECK | 844 SCHN_STAT_INTF_CTRL_CHK | 845 SCHN_STAT_PROT_CHECK | 846 SCHN_STAT_CHN_DATA_CHK)); 847 } 848 849 /** 850 * scsw_is_valid_actl - check actl field validity 851 * @scsw: pointer to scsw 852 * 853 * Return non-zero if the actl field of the specified scsw is valid, 854 * regardless of whether it is a transport mode or command mode scsw. 855 * Return zero if the field does not contain a valid value. 856 */ scsw_is_valid_actl(union scsw * scsw)857 static inline int scsw_is_valid_actl(union scsw *scsw) 858 { 859 if (scsw_is_tm(scsw)) 860 return scsw_tm_is_valid_actl(scsw); 861 else 862 return scsw_cmd_is_valid_actl(scsw); 863 } 864 865 /** 866 * scsw_is_valid_cc - check cc field validity 867 * @scsw: pointer to scsw 868 * 869 * Return non-zero if the cc field of the specified scsw is valid, 870 * regardless of whether it is a transport mode or command mode scsw. 871 * Return zero if the field does not contain a valid value. 872 */ scsw_is_valid_cc(union scsw * scsw)873 static inline int scsw_is_valid_cc(union scsw *scsw) 874 { 875 if (scsw_is_tm(scsw)) 876 return scsw_tm_is_valid_cc(scsw); 877 else 878 return scsw_cmd_is_valid_cc(scsw); 879 } 880 881 /** 882 * scsw_is_valid_cstat - check cstat field validity 883 * @scsw: pointer to scsw 884 * 885 * Return non-zero if the cstat field of the specified scsw is valid, 886 * regardless of whether it is a transport mode or command mode scsw. 887 * Return zero if the field does not contain a valid value. 888 */ scsw_is_valid_cstat(union scsw * scsw)889 static inline int scsw_is_valid_cstat(union scsw *scsw) 890 { 891 if (scsw_is_tm(scsw)) 892 return scsw_tm_is_valid_cstat(scsw); 893 else 894 return scsw_cmd_is_valid_cstat(scsw); 895 } 896 897 /** 898 * scsw_is_valid_dstat - check dstat field validity 899 * @scsw: pointer to scsw 900 * 901 * Return non-zero if the dstat field of the specified scsw is valid, 902 * regardless of whether it is a transport mode or command mode scsw. 903 * Return zero if the field does not contain a valid value. 904 */ scsw_is_valid_dstat(union scsw * scsw)905 static inline int scsw_is_valid_dstat(union scsw *scsw) 906 { 907 if (scsw_is_tm(scsw)) 908 return scsw_tm_is_valid_dstat(scsw); 909 else 910 return scsw_cmd_is_valid_dstat(scsw); 911 } 912 913 /** 914 * scsw_is_valid_ectl - check ectl field validity 915 * @scsw: pointer to scsw 916 * 917 * Return non-zero if the ectl field of the specified scsw is valid, 918 * regardless of whether it is a transport mode or command mode scsw. 919 * Return zero if the field does not contain a valid value. 920 */ scsw_is_valid_ectl(union scsw * scsw)921 static inline int scsw_is_valid_ectl(union scsw *scsw) 922 { 923 if (scsw_is_tm(scsw)) 924 return scsw_tm_is_valid_ectl(scsw); 925 else 926 return scsw_cmd_is_valid_ectl(scsw); 927 } 928 929 /** 930 * scsw_is_valid_eswf - check eswf field validity 931 * @scsw: pointer to scsw 932 * 933 * Return non-zero if the eswf field of the specified scsw is valid, 934 * regardless of whether it is a transport mode or command mode scsw. 935 * Return zero if the field does not contain a valid value. 936 */ scsw_is_valid_eswf(union scsw * scsw)937 static inline int scsw_is_valid_eswf(union scsw *scsw) 938 { 939 if (scsw_is_tm(scsw)) 940 return scsw_tm_is_valid_eswf(scsw); 941 else 942 return scsw_cmd_is_valid_eswf(scsw); 943 } 944 945 /** 946 * scsw_is_valid_fctl - check fctl field validity 947 * @scsw: pointer to scsw 948 * 949 * Return non-zero if the fctl field of the specified scsw is valid, 950 * regardless of whether it is a transport mode or command mode scsw. 951 * Return zero if the field does not contain a valid value. 952 */ scsw_is_valid_fctl(union scsw * scsw)953 static inline int scsw_is_valid_fctl(union scsw *scsw) 954 { 955 if (scsw_is_tm(scsw)) 956 return scsw_tm_is_valid_fctl(scsw); 957 else 958 return scsw_cmd_is_valid_fctl(scsw); 959 } 960 961 /** 962 * scsw_is_valid_key - check key field validity 963 * @scsw: pointer to scsw 964 * 965 * Return non-zero if the key field of the specified scsw is valid, 966 * regardless of whether it is a transport mode or command mode scsw. 967 * Return zero if the field does not contain a valid value. 968 */ scsw_is_valid_key(union scsw * scsw)969 static inline int scsw_is_valid_key(union scsw *scsw) 970 { 971 if (scsw_is_tm(scsw)) 972 return scsw_tm_is_valid_key(scsw); 973 else 974 return scsw_cmd_is_valid_key(scsw); 975 } 976 977 /** 978 * scsw_is_valid_pno - check pno field validity 979 * @scsw: pointer to scsw 980 * 981 * Return non-zero if the pno field of the specified scsw is valid, 982 * regardless of whether it is a transport mode or command mode scsw. 983 * Return zero if the field does not contain a valid value. 984 */ scsw_is_valid_pno(union scsw * scsw)985 static inline int scsw_is_valid_pno(union scsw *scsw) 986 { 987 if (scsw_is_tm(scsw)) 988 return scsw_tm_is_valid_pno(scsw); 989 else 990 return scsw_cmd_is_valid_pno(scsw); 991 } 992 993 /** 994 * scsw_is_valid_stctl - check stctl field validity 995 * @scsw: pointer to scsw 996 * 997 * Return non-zero if the stctl field of the specified scsw is valid, 998 * regardless of whether it is a transport mode or command mode scsw. 999 * Return zero if the field does not contain a valid value. 1000 */ scsw_is_valid_stctl(union scsw * scsw)1001 static inline int scsw_is_valid_stctl(union scsw *scsw) 1002 { 1003 if (scsw_is_tm(scsw)) 1004 return scsw_tm_is_valid_stctl(scsw); 1005 else 1006 return scsw_cmd_is_valid_stctl(scsw); 1007 } 1008 1009 /** 1010 * scsw_cmd_is_solicited - check for solicited scsw 1011 * @scsw: pointer to scsw 1012 * 1013 * Return non-zero if the command mode scsw indicates that the associated 1014 * status condition is solicited, zero if it is unsolicited. 1015 */ scsw_cmd_is_solicited(union scsw * scsw)1016 static inline int scsw_cmd_is_solicited(union scsw *scsw) 1017 { 1018 return (scsw->cmd.cc != 0) || (scsw->cmd.stctl != 1019 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)); 1020 } 1021 1022 /** 1023 * scsw_tm_is_solicited - check for solicited scsw 1024 * @scsw: pointer to scsw 1025 * 1026 * Return non-zero if the transport mode scsw indicates that the associated 1027 * status condition is solicited, zero if it is unsolicited. 1028 */ scsw_tm_is_solicited(union scsw * scsw)1029 static inline int scsw_tm_is_solicited(union scsw *scsw) 1030 { 1031 return (scsw->tm.cc != 0) || (scsw->tm.stctl != 1032 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)); 1033 } 1034 1035 /** 1036 * scsw_is_solicited - check for solicited scsw 1037 * @scsw: pointer to scsw 1038 * 1039 * Return non-zero if the transport or command mode scsw indicates that the 1040 * associated status condition is solicited, zero if it is unsolicited. 1041 */ scsw_is_solicited(union scsw * scsw)1042 static inline int scsw_is_solicited(union scsw *scsw) 1043 { 1044 if (scsw_is_tm(scsw)) 1045 return scsw_tm_is_solicited(scsw); 1046 else 1047 return scsw_cmd_is_solicited(scsw); 1048 } 1049 1050 #endif /* _ASM_S390_SCSW_H_ */ 1051