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