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  */
scsw_is_tm(union scsw * scsw)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  */
scsw_key(union scsw * scsw)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  */
scsw_eswf(union scsw * scsw)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  */
scsw_cc(union scsw * scsw)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  */
scsw_ectl(union scsw * scsw)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  */
scsw_pno(union scsw * scsw)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  */
scsw_fctl(union scsw * scsw)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  */
scsw_actl(union scsw * scsw)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  */
scsw_stctl(union scsw * scsw)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  */
scsw_dstat(union scsw * scsw)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  */
scsw_cstat(union scsw * scsw)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  */
scsw_cmd_is_valid_key(union scsw * scsw)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  */
scsw_cmd_is_valid_sctl(union scsw * scsw)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  */
scsw_cmd_is_valid_eswf(union scsw * scsw)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  */
scsw_cmd_is_valid_cc(union scsw * scsw)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  */
scsw_cmd_is_valid_fmt(union scsw * scsw)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  */
scsw_cmd_is_valid_pfch(union scsw * scsw)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  */
scsw_cmd_is_valid_isic(union scsw * scsw)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  */
scsw_cmd_is_valid_alcc(union scsw * scsw)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  */
scsw_cmd_is_valid_ssi(union scsw * scsw)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  */
scsw_cmd_is_valid_zcc(union scsw * scsw)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  */
scsw_cmd_is_valid_ectl(union scsw * scsw)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  */
scsw_cmd_is_valid_pno(union scsw * scsw)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  */
scsw_cmd_is_valid_fctl(union scsw * scsw)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  */
scsw_cmd_is_valid_actl(union scsw * scsw)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  */
scsw_cmd_is_valid_stctl(union scsw * scsw)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  */
scsw_cmd_is_valid_dstat(union scsw * scsw)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  */
scsw_cmd_is_valid_cstat(union scsw * scsw)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  */
scsw_tm_is_valid_key(union scsw * scsw)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  */
scsw_tm_is_valid_eswf(union scsw * scsw)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  */
scsw_tm_is_valid_cc(union scsw * scsw)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  */
scsw_tm_is_valid_fmt(union scsw * scsw)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  */
scsw_tm_is_valid_x(union scsw * scsw)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  */
scsw_tm_is_valid_q(union scsw * scsw)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  */
scsw_tm_is_valid_ectl(union scsw * scsw)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  */
scsw_tm_is_valid_pno(union scsw * scsw)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  */
scsw_tm_is_valid_fctl(union scsw * scsw)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  */
scsw_tm_is_valid_actl(union scsw * scsw)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  */
scsw_tm_is_valid_stctl(union scsw * scsw)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  */
scsw_tm_is_valid_dstat(union scsw * scsw)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  */
scsw_tm_is_valid_cstat(union scsw * scsw)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  */
scsw_tm_is_valid_fcxs(union scsw * scsw)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  */
scsw_tm_is_valid_schxs(union scsw * scsw)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  */
scsw_is_valid_actl(union scsw * scsw)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  */
scsw_is_valid_cc(union scsw * scsw)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  */
scsw_is_valid_cstat(union scsw * scsw)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  */
scsw_is_valid_dstat(union scsw * scsw)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  */
scsw_is_valid_ectl(union scsw * scsw)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  */
scsw_is_valid_eswf(union scsw * scsw)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  */
scsw_is_valid_fctl(union scsw * scsw)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  */
scsw_is_valid_key(union scsw * scsw)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  */
scsw_is_valid_pno(union scsw * scsw)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  */
scsw_is_valid_stctl(union scsw * scsw)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  */
scsw_cmd_is_solicited(union scsw * scsw)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  */
scsw_tm_is_solicited(union scsw * scsw)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  */
scsw_is_solicited(union scsw * scsw)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