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