xref: /linux/drivers/s390/block/dasd_int.h (revision 576d7fed09c7edbae7600f29a8a3ed6c1ead904f)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
4  *		    Horst Hummel <Horst.Hummel@de.ibm.com>
5  *		    Martin Schwidefsky <schwidefsky@de.ibm.com>
6  * Bugreports.to..: <Linux390@de.ibm.com>
7  * Copyright IBM Corp. 1999, 2009
8  */
9 
10 #ifndef DASD_INT_H
11 #define DASD_INT_H
12 
13 /* we keep old device allocation scheme; IOW, minors are still in 0..255 */
14 #define DASD_PER_MAJOR (1U << (MINORBITS - DASD_PARTN_BITS))
15 #define DASD_PARTN_MASK ((1 << DASD_PARTN_BITS) - 1)
16 
17 /*
18  * States a dasd device can have:
19  *   new: the dasd_device structure is allocated.
20  *   known: the discipline for the device is identified.
21  *   basic: the device can do basic i/o.
22  *   unfmt: the device could not be analyzed (format is unknown).
23  *   ready: partition detection is done and the device is can do block io.
24  *   online: the device accepts requests from the block device queue.
25  *
26  * Things to do for startup state transitions:
27  *   new -> known: find discipline for the device and create devfs entries.
28  *   known -> basic: request irq line for the device.
29  *   basic -> ready: do the initial analysis, e.g. format detection,
30  *                   do block device setup and detect partitions.
31  *   ready -> online: schedule the device tasklet.
32  * Things to do for shutdown state transitions:
33  *   online -> ready: just set the new device state.
34  *   ready -> basic: flush requests from the block device layer, clear
35  *                   partition information and reset format information.
36  *   basic -> known: terminate all requests and free irq.
37  *   known -> new: remove devfs entries and forget discipline.
38  */
39 
40 #define DASD_STATE_NEW	  0
41 #define DASD_STATE_KNOWN  1
42 #define DASD_STATE_BASIC  2
43 #define DASD_STATE_UNFMT  3
44 #define DASD_STATE_READY  4
45 #define DASD_STATE_ONLINE 5
46 
47 #include <linux/module.h>
48 #include <linux/wait.h>
49 #include <linux/blkdev.h>
50 #include <linux/hdreg.h>
51 #include <linux/interrupt.h>
52 #include <linux/log2.h>
53 #include <asm/ccwdev.h>
54 #include <linux/workqueue.h>
55 #include <asm/debug.h>
56 #include <asm/dasd.h>
57 #include <asm/idals.h>
58 #include <linux/bitops.h>
59 #include <linux/blk-mq.h>
60 
61 /* DASD discipline magic */
62 #define DASD_ECKD_MAGIC 0xC5C3D2C4
63 #define DASD_DIAG_MAGIC 0xC4C9C1C7
64 #define DASD_FBA_MAGIC 0xC6C2C140
65 
66 /*
67  * SECTION: Type definitions
68  */
69 struct dasd_device;
70 struct dasd_block;
71 
72 /* BIT DEFINITIONS FOR SENSE DATA */
73 #define DASD_SENSE_BIT_0 0x80
74 #define DASD_SENSE_BIT_1 0x40
75 #define DASD_SENSE_BIT_2 0x20
76 #define DASD_SENSE_BIT_3 0x10
77 
78 /* BIT DEFINITIONS FOR SIM SENSE */
79 #define DASD_SIM_SENSE 0x0F
80 #define DASD_SIM_MSG_TO_OP 0x03
81 #define DASD_SIM_LOG 0x0C
82 
83 /* lock class for nested cdev lock */
84 #define CDEV_NESTED_FIRST 1
85 #define CDEV_NESTED_SECOND 2
86 
87 /*
88  * SECTION: MACROs for klogd and s390 debug feature (dbf)
89  */
90 #define DBF_DEV_EVENT(d_level, d_device, d_str, d_data...) \
91 do { \
92 	debug_sprintf_event(d_device->debug_area, \
93 			    d_level, \
94 			    d_str "\n", \
95 			    d_data); \
96 } while(0)
97 
98 #define DBF_EVENT(d_level, d_str, d_data...)\
99 do { \
100 	debug_sprintf_event(dasd_debug_area, \
101 			    d_level,\
102 			    d_str "\n", \
103 			    d_data); \
104 } while(0)
105 
106 #define DBF_EVENT_DEVID(d_level, d_cdev, d_str, d_data...)	\
107 do { \
108 	struct ccw_dev_id __dev_id;			\
109 	ccw_device_get_id(d_cdev, &__dev_id);		\
110 	debug_sprintf_event(dasd_debug_area,		\
111 			    d_level,					\
112 			    "0.%x.%04x " d_str "\n",			\
113 			    __dev_id.ssid, __dev_id.devno, d_data);	\
114 } while (0)
115 
116 /* limit size for an errorstring */
117 #define ERRORLENGTH 30
118 
119 /* definition of dbf debug levels */
120 #define	DBF_EMERG	0	/* system is unusable			*/
121 #define	DBF_ALERT	1	/* action must be taken immediately	*/
122 #define	DBF_CRIT	2	/* critical conditions			*/
123 #define	DBF_ERR		3	/* error conditions			*/
124 #define	DBF_WARNING	4	/* warning conditions			*/
125 #define	DBF_NOTICE	5	/* normal but significant condition	*/
126 #define	DBF_INFO	6	/* informational			*/
127 #define	DBF_DEBUG	6	/* debug-level messages			*/
128 
129 /* messages to be written via klogd and dbf */
130 #define DEV_MESSAGE(d_loglevel,d_device,d_string,d_args...)\
131 do { \
132 	printk(d_loglevel PRINTK_HEADER " %s: " d_string "\n", \
133 	       dev_name(&d_device->cdev->dev), d_args); \
134 	DBF_DEV_EVENT(DBF_ALERT, d_device, d_string, d_args); \
135 } while(0)
136 
137 #define MESSAGE(d_loglevel,d_string,d_args...)\
138 do { \
139 	printk(d_loglevel PRINTK_HEADER " " d_string "\n", d_args); \
140 	DBF_EVENT(DBF_ALERT, d_string, d_args); \
141 } while(0)
142 
143 /* messages to be written via klogd only */
144 #define DEV_MESSAGE_LOG(d_loglevel,d_device,d_string,d_args...)\
145 do { \
146 	printk(d_loglevel PRINTK_HEADER " %s: " d_string "\n", \
147 	       dev_name(&d_device->cdev->dev), d_args); \
148 } while(0)
149 
150 #define MESSAGE_LOG(d_loglevel,d_string,d_args...)\
151 do { \
152 	printk(d_loglevel PRINTK_HEADER " " d_string "\n", d_args); \
153 } while(0)
154 
155 /* Macro to calculate number of blocks per page */
156 #define BLOCKS_PER_PAGE(blksize) (PAGE_SIZE / blksize)
157 
158 struct dasd_ccw_req {
159 	unsigned int magic;		/* Eye catcher */
160 	int intrc;			/* internal error, e.g. from start_IO */
161 	struct list_head devlist;	/* for dasd_device request queue */
162 	struct list_head blocklist;	/* for dasd_block request queue */
163 	struct dasd_block *block;	/* the originating block device */
164 	struct dasd_device *memdev;	/* the device used to allocate this */
165 	struct dasd_device *startdev;	/* device the request is started on */
166 	struct dasd_device *basedev;	/* base device if no block->base */
167 	void *cpaddr;			/* address of ccw or tcw */
168 	short retries;			/* A retry counter */
169 	unsigned char cpmode;		/* 0 = cmd mode, 1 = itcw */
170 	char status;			/* status of this request */
171 	char lpm;			/* logical path mask */
172 	unsigned long flags;        	/* flags of this request */
173 	struct dasd_queue *dq;
174 	unsigned long starttime;	/* jiffies time of request start */
175 	unsigned long expires;		/* expiration period in jiffies */
176 	void *data;			/* pointer to data area */
177 	struct irb irb;			/* device status in case of an error */
178 	struct dasd_ccw_req *refers;	/* ERP-chain queueing. */
179 	void *function; 		/* originating ERP action */
180 	void *mem_chunk;
181 
182 	unsigned long buildclk;		/* TOD-clock of request generation */
183 	unsigned long startclk;		/* TOD-clock of request start */
184 	unsigned long stopclk;		/* TOD-clock of request interrupt */
185 	unsigned long endclk;		/* TOD-clock of request termination */
186 
187 	void (*callback)(struct dasd_ccw_req *, void *data);
188 	void *callback_data;
189 	unsigned int proc_bytes;	/* bytes for partial completion */
190 	unsigned int trkcount;		/* count formatted tracks */
191 };
192 
193 /*
194  * dasd_ccw_req -> status can be:
195  */
196 #define DASD_CQR_FILLED 	0x00	/* request is ready to be processed */
197 #define DASD_CQR_DONE		0x01	/* request is completed successfully */
198 #define DASD_CQR_NEED_ERP	0x02	/* request needs recovery action */
199 #define DASD_CQR_IN_ERP 	0x03	/* request is in recovery */
200 #define DASD_CQR_FAILED 	0x04	/* request is finally failed */
201 #define DASD_CQR_TERMINATED	0x05	/* request was stopped by driver */
202 
203 #define DASD_CQR_QUEUED 	0x80	/* request is queued to be processed */
204 #define DASD_CQR_IN_IO		0x81	/* request is currently in IO */
205 #define DASD_CQR_ERROR		0x82	/* request is completed with error */
206 #define DASD_CQR_CLEAR_PENDING	0x83	/* request is clear pending */
207 #define DASD_CQR_CLEARED	0x84	/* request was cleared */
208 #define DASD_CQR_SUCCESS	0x85	/* request was successful */
209 
210 /* default expiration time*/
211 #define DASD_EXPIRES	  300
212 #define DASD_EXPIRES_MAX  40000000
213 #define DASD_RETRIES	  256
214 #define DASD_RETRIES_MAX  32768
215 
216 /* per dasd_ccw_req flags */
217 #define DASD_CQR_FLAGS_USE_ERP   0	/* use ERP for this request */
218 #define DASD_CQR_FLAGS_FAILFAST  1	/* FAILFAST */
219 #define DASD_CQR_VERIFY_PATH	 2	/* path verification request */
220 #define DASD_CQR_ALLOW_SLOCK	 3	/* Try this request even when lock was
221 					 * stolen. Should not be combined with
222 					 * DASD_CQR_FLAGS_USE_ERP
223 					 */
224 /*
225  * The following flags are used to suppress output of certain errors.
226  */
227 #define DASD_CQR_SUPPRESS_NRF	4	/* Suppress 'No Record Found' error */
228 #define DASD_CQR_SUPPRESS_FP	5	/* Suppress 'File Protected' error*/
229 #define DASD_CQR_SUPPRESS_IL	6	/* Suppress 'Incorrect Length' error */
230 #define DASD_CQR_SUPPRESS_CR	7	/* Suppress 'Command Reject' error */
231 
232 #define DASD_REQ_PER_DEV 4
233 
234 /* Signature for error recovery functions. */
235 typedef struct dasd_ccw_req *(*dasd_erp_fn_t) (struct dasd_ccw_req *);
236 
237 /*
238  * A single CQR can only contain a maximum of 255 CCWs. It is limited by
239  * the locate record and locate record extended count value which can only hold
240  * 1 Byte max.
241  */
242 #define DASD_CQR_MAX_CCW 255
243 
244 /*
245  * Unique identifier for dasd device.
246  */
247 #define UA_NOT_CONFIGURED  0x00
248 #define UA_BASE_DEVICE	   0x01
249 #define UA_BASE_PAV_ALIAS  0x02
250 #define UA_HYPER_PAV_ALIAS 0x03
251 
252 struct dasd_uid {
253 	__u8 type;
254 	char vendor[4];
255 	char serial[15];
256 	__u16 ssid;
257 	__u8 real_unit_addr;
258 	__u8 base_unit_addr;
259 	char vduit[33];
260 };
261 
262 #define DASD_UID_STRLEN ( /* vendor */ 3 + 1 + /* serial    */ 14 + 1 +	\
263 			  /* SSID   */ 4 + 1 + /* unit addr */ 2 + 1 +	\
264 			  /* vduit */ 32 + 1)
265 
266 /*
267  * PPRC Status data
268  */
269 struct dasd_pprc_header {
270 	__u8 entries;		/* 0     Number of device entries */
271 	__u8 unused;		/* 1     unused */
272 	__u16 entry_length;	/* 2-3   Length of device entry */
273 	__u32 unused2;		/* 4-7   unused */
274 } __packed;
275 
276 struct dasd_pprc_dev_info {
277 	__u8 state;		/* 0       Copy State */
278 	__u8 flags;		/* 1       Flags */
279 	__u8 reserved1[2];	/* 2-3     reserved */
280 	__u8 prim_lss;		/* 4       Primary device LSS */
281 	__u8 primary;		/* 5       Primary device address */
282 	__u8 sec_lss;		/* 6       Secondary device LSS */
283 	__u8 secondary;		/* 7       Secondary device address */
284 	__u16 pprc_id;		/* 8-9     Peer-to-Peer Remote Copy ID */
285 	__u8 reserved2[12];	/* 10-21   reserved */
286 	__u16 prim_cu_ssid;	/* 22-23   Primary Control Unit SSID */
287 	__u8 reserved3[12];	/* 24-35   reserved */
288 	__u16 sec_cu_ssid;	/* 36-37   Secondary Control Unit SSID */
289 	__u8 reserved4[90];	/* 38-127  reserved */
290 } __packed;
291 
292 struct dasd_pprc_data_sc4 {
293 	struct dasd_pprc_header header;
294 	struct dasd_pprc_dev_info dev_info[5];
295 } __packed;
296 
297 #define DASD_BUS_ID_SIZE 20
298 #define DASD_CP_ENTRIES 5
299 
300 struct dasd_copy_entry {
301 	char busid[DASD_BUS_ID_SIZE];
302 	struct dasd_device *device;
303 	bool primary;
304 	bool configured;
305 };
306 
307 struct dasd_copy_relation {
308 	struct dasd_copy_entry entry[DASD_CP_ENTRIES];
309 	struct dasd_copy_entry *active;
310 };
311 
312 int dasd_devmap_set_device_copy_relation(struct ccw_device *,
313 					 bool pprc_enabled);
314 
315 /*
316  * the struct dasd_discipline is
317  * sth like a table of virtual functions, if you think of dasd_eckd
318  * inheriting dasd...
319  * no, currently we are not planning to reimplement the driver in C++
320  */
321 struct dasd_discipline {
322 	struct module *owner;
323 	char ebcname[8];	/* a name used for tagging and printks */
324 	char name[8];		/* a name used for tagging and printks */
325 
326 	struct list_head list;	/* used for list of disciplines */
327 
328 	/*
329 	 * Device recognition functions. check_device is used to verify
330 	 * the sense data and the information returned by read device
331 	 * characteristics. It returns 0 if the discipline can be used
332 	 * for the device in question. uncheck_device is called during
333 	 * device shutdown to deregister a device from its discipline.
334 	 */
335 	int (*check_device) (struct dasd_device *);
336 	void (*uncheck_device) (struct dasd_device *);
337 
338 	/*
339 	 * do_analysis is used in the step from device state "basic" to
340 	 * state "accept". It returns 0 if the device can be made ready,
341 	 * it returns -EMEDIUMTYPE if the device can't be made ready or
342 	 * -EAGAIN if do_analysis started a ccw that needs to complete
343 	 * before the analysis may be repeated.
344 	 */
345 	int (*do_analysis) (struct dasd_block *);
346 
347 	/*
348 	 * This function is called, when new paths become available.
349 	 * Disciplins may use this callback to do necessary setup work,
350 	 * e.g. verify that new path is compatible with the current
351 	 * configuration.
352 	 */
353 	int (*pe_handler)(struct dasd_device *, __u8, __u8);
354 
355 	/*
356 	 * Last things to do when a device is set online, and first things
357 	 * when it is set offline.
358 	 */
359 	int (*basic_to_ready) (struct dasd_device *);
360 	int (*online_to_ready) (struct dasd_device *);
361 	int (*basic_to_known)(struct dasd_device *);
362 
363 	/*
364 	 * Initialize block layer request queue.
365 	 */
366 	void (*setup_blk_queue)(struct dasd_block *);
367 	/* (struct dasd_device *);
368 	 * Device operation functions. build_cp creates a ccw chain for
369 	 * a block device request, start_io starts the request and
370 	 * term_IO cancels it (e.g. in case of a timeout). format_device
371 	 * formats the device and check_device_format compares the format of
372 	 * a device with the expected format_data.
373 	 * handle_terminated_request allows to examine a cqr and prepare
374 	 * it for retry.
375 	 */
376 	struct dasd_ccw_req *(*build_cp) (struct dasd_device *,
377 					  struct dasd_block *,
378 					  struct request *);
379 	int (*start_IO) (struct dasd_ccw_req *);
380 	int (*term_IO) (struct dasd_ccw_req *);
381 	void (*handle_terminated_request) (struct dasd_ccw_req *);
382 	int (*format_device) (struct dasd_device *,
383 			      struct format_data_t *, int);
384 	int (*check_device_format)(struct dasd_device *,
385 				   struct format_check_t *, int);
386 	int (*free_cp) (struct dasd_ccw_req *, struct request *);
387 
388 	/*
389 	 * Error recovery functions. examine_error() returns a value that
390 	 * indicates what to do for an error condition. If examine_error()
391 	 * returns 'dasd_era_recover' erp_action() is called to create a
392 	 * special error recovery ccw. erp_postaction() is called after
393 	 * an error recovery ccw has finished its execution. dump_sense
394 	 * is called for every error condition to print the sense data
395 	 * to the console.
396 	 */
397 	dasd_erp_fn_t(*erp_action) (struct dasd_ccw_req *);
398 	dasd_erp_fn_t(*erp_postaction) (struct dasd_ccw_req *);
399 	void (*dump_sense) (struct dasd_device *, struct dasd_ccw_req *,
400 			    struct irb *);
401 	void (*dump_sense_dbf) (struct dasd_device *, struct irb *, char *);
402 	void (*check_for_device_change) (struct dasd_device *,
403 					 struct dasd_ccw_req *,
404 					 struct irb *);
405 
406         /* i/o control functions. */
407 	int (*fill_geometry) (struct dasd_block *, struct hd_geometry *);
408 	int (*fill_info) (struct dasd_device *, struct dasd_information2_t *);
409 	int (*ioctl) (struct dasd_block *, unsigned int, void __user *);
410 
411 	/* reload device after state change */
412 	int (*reload) (struct dasd_device *);
413 
414 	int (*get_uid) (struct dasd_device *, struct dasd_uid *);
415 	void (*kick_validate) (struct dasd_device *);
416 	int (*check_attention)(struct dasd_device *, __u8);
417 	int (*host_access_count)(struct dasd_device *);
418 	int (*hosts_print)(struct dasd_device *, struct seq_file *);
419 	void (*handle_hpf_error)(struct dasd_device *, struct irb *);
420 	void (*disable_hpf)(struct dasd_device *);
421 	int (*hpf_enabled)(struct dasd_device *);
422 	void (*reset_path)(struct dasd_device *, __u8);
423 
424 	/*
425 	 * Extent Space Efficient (ESE) relevant functions
426 	 */
427 	int (*is_ese)(struct dasd_device *);
428 	/* Capacity */
429 	int (*space_allocated)(struct dasd_device *);
430 	int (*space_configured)(struct dasd_device *);
431 	int (*logical_capacity)(struct dasd_device *);
432 	int (*release_space)(struct dasd_device *, struct format_data_t *);
433 	/* Extent Pool */
434 	int (*ext_pool_id)(struct dasd_device *);
435 	int (*ext_size)(struct dasd_device *);
436 	int (*ext_pool_cap_at_warnlevel)(struct dasd_device *);
437 	int (*ext_pool_warn_thrshld)(struct dasd_device *);
438 	int (*ext_pool_oos)(struct dasd_device *);
439 	int (*ext_pool_exhaust)(struct dasd_device *, struct dasd_ccw_req *);
440 	struct dasd_ccw_req *(*ese_format)(struct dasd_device *,
441 					   struct dasd_ccw_req *, struct irb *);
442 	int (*ese_read)(struct dasd_ccw_req *, struct irb *);
443 	int (*pprc_status)(struct dasd_device *, struct	dasd_pprc_data_sc4 *);
444 	bool (*pprc_enabled)(struct dasd_device *);
445 	int (*copy_pair_swap)(struct dasd_device *, char *, char *);
446 	int (*device_ping)(struct dasd_device *);
447 };
448 
449 extern struct dasd_discipline *dasd_diag_discipline_pointer;
450 
451 /* Trigger IDs for extended error reporting DASD EER and autoquiesce */
452 enum eer_trigger {
453 	DASD_EER_FATALERROR = 1,
454 	DASD_EER_NOPATH,
455 	DASD_EER_STATECHANGE,
456 	DASD_EER_PPRCSUSPEND,
457 	DASD_EER_NOSPC,
458 	DASD_EER_TIMEOUTS,
459 	DASD_EER_STARTIO,
460 
461 	/* enum end marker, only add new trigger above */
462 	DASD_EER_MAX,
463 	DASD_EER_AUTOQUIESCE = 31, /* internal only */
464 };
465 
466 #define DASD_EER_VALID ((1U << DASD_EER_MAX) - 1)
467 
468 /* DASD path handling */
469 
470 #define DASD_PATH_OPERATIONAL  1
471 #define DASD_PATH_TBV	       2
472 #define DASD_PATH_PP	       3
473 #define DASD_PATH_NPP	       4
474 #define DASD_PATH_MISCABLED    5
475 #define DASD_PATH_NOHPF        6
476 #define DASD_PATH_CUIR	       7
477 #define DASD_PATH_IFCC	       8
478 #define DASD_PATH_FCSEC	       9
479 
480 #define DASD_THRHLD_MAX		4294967295U
481 #define DASD_INTERVAL_MAX	4294967295U
482 
483 /* FC Endpoint Security Capabilities */
484 #define DASD_FC_SECURITY_UNSUP		0
485 #define DASD_FC_SECURITY_AUTH		1
486 #define DASD_FC_SECURITY_ENC_FCSP2	2
487 #define DASD_FC_SECURITY_ENC_ERAS	3
488 
489 #define DASD_FC_SECURITY_ENC_STR	"Encryption"
490 static const struct {
491 	u8 value;
492 	char *name;
493 } dasd_path_fcs_mnemonics[] = {
494 	{ DASD_FC_SECURITY_UNSUP,	"Unsupported" },
495 	{ DASD_FC_SECURITY_AUTH,	"Authentication" },
496 	{ DASD_FC_SECURITY_ENC_FCSP2,	DASD_FC_SECURITY_ENC_STR },
497 	{ DASD_FC_SECURITY_ENC_ERAS,	DASD_FC_SECURITY_ENC_STR },
498 };
499 
500 static inline char *dasd_path_get_fcs_str(int val)
501 {
502 	int i;
503 
504 	for (i = 0; i < ARRAY_SIZE(dasd_path_fcs_mnemonics); i++) {
505 		if (dasd_path_fcs_mnemonics[i].value == val)
506 			return dasd_path_fcs_mnemonics[i].name;
507 	}
508 
509 	return dasd_path_fcs_mnemonics[0].name;
510 }
511 
512 struct dasd_path {
513 	unsigned long flags;
514 	u8 cssid;
515 	u8 ssid;
516 	u8 chpid;
517 	struct dasd_conf_data *conf_data;
518 	atomic_t error_count;
519 	unsigned long errorclk;
520 	u8 fc_security;
521 	struct kobject kobj;
522 	bool in_sysfs;
523 };
524 
525 #define to_dasd_path(path) container_of(path, struct dasd_path, kobj)
526 
527 static inline void dasd_path_release(struct kobject *kobj)
528 {
529 /* Memory for the dasd_path kobject is freed when dasd_free_device() is called */
530 }
531 
532 
533 struct dasd_profile_info {
534 	/* legacy part of profile data, as in dasd_profile_info_t */
535 	unsigned int dasd_io_reqs;	 /* number of requests processed */
536 	unsigned int dasd_io_sects;	 /* number of sectors processed */
537 	unsigned int dasd_io_secs[32];	 /* histogram of request's sizes */
538 	unsigned int dasd_io_times[32];	 /* histogram of requests's times */
539 	unsigned int dasd_io_timps[32];	 /* h. of requests's times per sector */
540 	unsigned int dasd_io_time1[32];	 /* hist. of time from build to start */
541 	unsigned int dasd_io_time2[32];	 /* hist. of time from start to irq */
542 	unsigned int dasd_io_time2ps[32]; /* hist. of time from start to irq */
543 	unsigned int dasd_io_time3[32];	 /* hist. of time from irq to end */
544 	unsigned int dasd_io_nr_req[32]; /* hist. of # of requests in chanq */
545 
546 	/* new data */
547 	struct timespec64 starttod;	   /* time of start or last reset */
548 	unsigned int dasd_io_alias;	   /* requests using an alias */
549 	unsigned int dasd_io_tpm;	   /* requests using transport mode */
550 	unsigned int dasd_read_reqs;	   /* total number of read  requests */
551 	unsigned int dasd_read_sects;	   /* total number read sectors */
552 	unsigned int dasd_read_alias;	   /* read request using an alias */
553 	unsigned int dasd_read_tpm;	   /* read requests in transport mode */
554 	unsigned int dasd_read_secs[32];   /* histogram of request's sizes */
555 	unsigned int dasd_read_times[32];  /* histogram of requests's times */
556 	unsigned int dasd_read_time1[32];  /* hist. time from build to start */
557 	unsigned int dasd_read_time2[32];  /* hist. of time from start to irq */
558 	unsigned int dasd_read_time3[32];  /* hist. of time from irq to end */
559 	unsigned int dasd_read_nr_req[32]; /* hist. of # of requests in chanq */
560 	unsigned long dasd_sum_times;	   /* sum of request times */
561 	unsigned long dasd_sum_time_str;   /* sum of time from build to start */
562 	unsigned long dasd_sum_time_irq;   /* sum of time from start to irq */
563 	unsigned long dasd_sum_time_end;   /* sum of time from irq to end */
564 };
565 
566 struct dasd_profile {
567 	struct dentry *dentry;
568 	struct dasd_profile_info *data;
569 	spinlock_t lock;
570 };
571 
572 struct dasd_format_entry {
573 	struct list_head list;
574 	sector_t track;
575 };
576 
577 struct dasd_device {
578 	/* Block device stuff. */
579 	struct dasd_block *block;
580 
581         unsigned int devindex;
582 	unsigned long flags;	   /* per device flags */
583 	unsigned short features;   /* copy of devmap-features (read-only!) */
584 
585 	/* extended error reporting stuff (eer) */
586 	struct dasd_ccw_req *eer_cqr;
587 
588 	/* Device discipline stuff. */
589 	struct dasd_discipline *discipline;
590 	struct dasd_discipline *base_discipline;
591 	void *private;
592 	struct dasd_path path[8];
593 	__u8 opm;
594 
595 	/* Device state and target state. */
596 	int state, target;
597 	struct mutex state_mutex;
598 	int stopped;		/* device (ccw_device_start) was stopped */
599 
600 	/* reference count. */
601         atomic_t ref_count;
602 
603 	/* ccw queue and memory for static ccw/erp buffers. */
604 	struct list_head ccw_queue;
605 	spinlock_t mem_lock;
606 	void *ccw_mem;
607 	void *erp_mem;
608 	void *ese_mem;
609 	struct list_head ccw_chunks;
610 	struct list_head erp_chunks;
611 	struct list_head ese_chunks;
612 
613 	atomic_t tasklet_scheduled;
614         struct tasklet_struct tasklet;
615 	struct work_struct kick_work;
616 	struct work_struct reload_device;
617 	struct work_struct kick_validate;
618 	struct work_struct suc_work;
619 	struct work_struct requeue_requests;
620 	struct timer_list timer;
621 
622 	debug_info_t *debug_area;
623 
624 	struct ccw_device *cdev;
625 
626 	/* hook for alias management */
627 	struct list_head alias_list;
628 
629 	/* default expiration time in s */
630 	unsigned long default_expires;
631 	unsigned long default_retries;
632 
633 	unsigned long blk_timeout;
634 
635 	unsigned long path_thrhld;
636 	unsigned long path_interval;
637 
638 	struct dentry *debugfs_dentry;
639 	struct dentry *hosts_dentry;
640 	struct dasd_profile profile;
641 	struct dasd_format_entry format_entry;
642 	struct kset *paths_info;
643 	struct dasd_copy_relation *copy;
644 	unsigned long aq_mask;
645 	unsigned int aq_timeouts;
646 };
647 
648 struct dasd_block {
649 	/* Block device stuff. */
650 	struct gendisk *gdp;
651 	spinlock_t request_queue_lock;
652 	struct blk_mq_tag_set tag_set;
653 	struct bdev_handle *bdev_handle;
654 	atomic_t open_count;
655 
656 	unsigned long blocks;	   /* size of volume in blocks */
657 	unsigned int bp_block;	   /* bytes per block */
658 	unsigned int s2b_shift;	   /* log2 (bp_block/512) */
659 
660 	struct dasd_device *base;
661 	struct list_head ccw_queue;
662 	spinlock_t queue_lock;
663 
664 	atomic_t tasklet_scheduled;
665 	struct tasklet_struct tasklet;
666 	struct timer_list timer;
667 
668 	struct dentry *debugfs_dentry;
669 	struct dasd_profile profile;
670 
671 	struct list_head format_list;
672 	spinlock_t format_lock;
673 	atomic_t trkcount;
674 };
675 
676 struct dasd_attention_data {
677 	struct dasd_device *device;
678 	__u8 lpum;
679 };
680 
681 struct dasd_queue {
682 	spinlock_t lock;
683 };
684 
685 /* reasons why device (ccw_device_start) was stopped */
686 #define DASD_STOPPED_NOT_ACC 1         /* not accessible */
687 #define DASD_STOPPED_QUIESCE 2         /* Quiesced */
688 #define DASD_STOPPED_PENDING 4         /* long busy */
689 #define DASD_STOPPED_DC_WAIT 8         /* disconnected, wait */
690 #define DASD_STOPPED_SU      16        /* summary unit check handling */
691 #define DASD_STOPPED_PPRC    32        /* PPRC swap */
692 #define DASD_STOPPED_NOSPC   128       /* no space left */
693 
694 /* per device flags */
695 #define DASD_FLAG_OFFLINE	3	/* device is in offline processing */
696 #define DASD_FLAG_EER_SNSS	4	/* A SNSS is required */
697 #define DASD_FLAG_EER_IN_USE	5	/* A SNSS request is running */
698 #define DASD_FLAG_DEVICE_RO	6	/* The device itself is read-only. Don't
699 					 * confuse this with the user specified
700 					 * read-only feature.
701 					 */
702 #define DASD_FLAG_IS_RESERVED	7	/* The device is reserved */
703 #define DASD_FLAG_LOCK_STOLEN	8	/* The device lock was stolen */
704 #define DASD_FLAG_SUSPENDED	9	/* The device was suspended */
705 #define DASD_FLAG_SAFE_OFFLINE	10	/* safe offline processing requested*/
706 #define DASD_FLAG_SAFE_OFFLINE_RUNNING	11	/* safe offline running */
707 #define DASD_FLAG_ABORTALL	12	/* Abort all noretry requests */
708 #define DASD_FLAG_PATH_VERIFY	13	/* Path verification worker running */
709 #define DASD_FLAG_SUC		14	/* unhandled summary unit check */
710 
711 #define DASD_SLEEPON_START_TAG	((void *) 1)
712 #define DASD_SLEEPON_END_TAG	((void *) 2)
713 
714 void dasd_put_device_wake(struct dasd_device *);
715 
716 /*
717  * return values to be returned from the copy pair swap function
718  * 0x00: swap successful
719  * 0x01: swap data invalid
720  * 0x02: no active device found
721  * 0x03: wrong primary specified
722  * 0x04: secondary device not found
723  * 0x05: swap already running
724  */
725 #define DASD_COPYPAIRSWAP_SUCCESS	0
726 #define DASD_COPYPAIRSWAP_INVALID	1
727 #define DASD_COPYPAIRSWAP_NOACTIVE	2
728 #define DASD_COPYPAIRSWAP_PRIMARY	3
729 #define DASD_COPYPAIRSWAP_SECONDARY	4
730 #define DASD_COPYPAIRSWAP_MULTIPLE	5
731 
732 /*
733  * Reference count inliners
734  */
735 static inline void
736 dasd_get_device(struct dasd_device *device)
737 {
738 	atomic_inc(&device->ref_count);
739 }
740 
741 static inline void
742 dasd_put_device(struct dasd_device *device)
743 {
744 	if (atomic_dec_return(&device->ref_count) == 0)
745 		dasd_put_device_wake(device);
746 }
747 
748 /*
749  * The static memory in ccw_mem and erp_mem is managed by a sorted
750  * list of free memory chunks.
751  */
752 struct dasd_mchunk
753 {
754 	struct list_head list;
755 	unsigned long size;
756 } __attribute__ ((aligned(8)));
757 
758 static inline void
759 dasd_init_chunklist(struct list_head *chunk_list, void *mem,
760 		    unsigned long size)
761 {
762 	struct dasd_mchunk *chunk;
763 
764 	INIT_LIST_HEAD(chunk_list);
765 	chunk = (struct dasd_mchunk *) mem;
766 	chunk->size = size - sizeof(struct dasd_mchunk);
767 	list_add(&chunk->list, chunk_list);
768 }
769 
770 static inline void *
771 dasd_alloc_chunk(struct list_head *chunk_list, unsigned long size)
772 {
773 	struct dasd_mchunk *chunk, *tmp;
774 
775 	size = (size + 7L) & -8L;
776 	list_for_each_entry(chunk, chunk_list, list) {
777 		if (chunk->size < size)
778 			continue;
779 		if (chunk->size > size + sizeof(struct dasd_mchunk)) {
780 			char *endaddr = (char *) (chunk + 1) + chunk->size;
781 			tmp = (struct dasd_mchunk *) (endaddr - size) - 1;
782 			tmp->size = size;
783 			chunk->size -= size + sizeof(struct dasd_mchunk);
784 			chunk = tmp;
785 		} else
786 			list_del(&chunk->list);
787 		return (void *) (chunk + 1);
788 	}
789 	return NULL;
790 }
791 
792 static inline void
793 dasd_free_chunk(struct list_head *chunk_list, void *mem)
794 {
795 	struct dasd_mchunk *chunk, *tmp;
796 	struct list_head *p, *left;
797 
798 	chunk = (struct dasd_mchunk *)
799 		((char *) mem - sizeof(struct dasd_mchunk));
800 	/* Find out the left neighbour in chunk_list. */
801 	left = chunk_list;
802 	list_for_each(p, chunk_list) {
803 		if (list_entry(p, struct dasd_mchunk, list) > chunk)
804 			break;
805 		left = p;
806 	}
807 	/* Try to merge with right neighbour = next element from left. */
808 	if (left->next != chunk_list) {
809 		tmp = list_entry(left->next, struct dasd_mchunk, list);
810 		if ((char *) (chunk + 1) + chunk->size == (char *) tmp) {
811 			list_del(&tmp->list);
812 			chunk->size += tmp->size + sizeof(struct dasd_mchunk);
813 		}
814 	}
815 	/* Try to merge with left neighbour. */
816 	if (left != chunk_list) {
817 		tmp = list_entry(left, struct dasd_mchunk, list);
818 		if ((char *) (tmp + 1) + tmp->size == (char *) chunk) {
819 			tmp->size += chunk->size + sizeof(struct dasd_mchunk);
820 			return;
821 		}
822 	}
823 	__list_add(&chunk->list, left, left->next);
824 }
825 
826 /*
827  * Check if bsize is in { 512, 1024, 2048, 4096 }
828  */
829 static inline int
830 dasd_check_blocksize(int bsize)
831 {
832 	if (bsize < 512 || bsize > 4096 || !is_power_of_2(bsize))
833 		return -EMEDIUMTYPE;
834 	return 0;
835 }
836 
837 /*
838  * return the callback data of the original request in case there are
839  * ERP requests build on top of it
840  */
841 static inline void *dasd_get_callback_data(struct dasd_ccw_req *cqr)
842 {
843 	while (cqr->refers)
844 		cqr = cqr->refers;
845 
846 	return cqr->callback_data;
847 }
848 
849 /* externals in dasd.c */
850 #define DASD_PROFILE_OFF	 0
851 #define DASD_PROFILE_ON 	 1
852 #define DASD_PROFILE_GLOBAL_ONLY 2
853 
854 extern debug_info_t *dasd_debug_area;
855 extern struct dasd_profile dasd_global_profile;
856 extern unsigned int dasd_global_profile_level;
857 extern const struct block_device_operations dasd_device_operations;
858 extern struct blk_mq_ops dasd_mq_ops;
859 
860 extern struct kmem_cache *dasd_page_cache;
861 
862 struct dasd_ccw_req *
863 dasd_smalloc_request(int, int, int, struct dasd_device *, struct dasd_ccw_req *);
864 struct dasd_ccw_req *dasd_fmalloc_request(int, int, int, struct dasd_device *);
865 void dasd_sfree_request(struct dasd_ccw_req *, struct dasd_device *);
866 void dasd_ffree_request(struct dasd_ccw_req *, struct dasd_device *);
867 void dasd_wakeup_cb(struct dasd_ccw_req *, void *);
868 
869 struct dasd_device *dasd_alloc_device(void);
870 void dasd_free_device(struct dasd_device *);
871 
872 struct dasd_block *dasd_alloc_block(void);
873 void dasd_free_block(struct dasd_block *);
874 
875 enum blk_eh_timer_return dasd_times_out(struct request *req);
876 
877 void dasd_enable_device(struct dasd_device *);
878 void dasd_set_target_state(struct dasd_device *, int);
879 void dasd_kick_device(struct dasd_device *);
880 void dasd_reload_device(struct dasd_device *);
881 void dasd_schedule_requeue(struct dasd_device *);
882 
883 void dasd_add_request_head(struct dasd_ccw_req *);
884 void dasd_add_request_tail(struct dasd_ccw_req *);
885 int  dasd_start_IO(struct dasd_ccw_req *);
886 int  dasd_term_IO(struct dasd_ccw_req *);
887 void dasd_schedule_device_bh(struct dasd_device *);
888 void dasd_schedule_block_bh(struct dasd_block *);
889 int  dasd_sleep_on(struct dasd_ccw_req *);
890 int  dasd_sleep_on_queue(struct list_head *);
891 int  dasd_sleep_on_immediatly(struct dasd_ccw_req *);
892 int  dasd_sleep_on_queue_interruptible(struct list_head *);
893 int  dasd_sleep_on_interruptible(struct dasd_ccw_req *);
894 void dasd_device_set_timer(struct dasd_device *, int);
895 void dasd_device_clear_timer(struct dasd_device *);
896 void dasd_block_set_timer(struct dasd_block *, int);
897 void dasd_block_clear_timer(struct dasd_block *);
898 int  dasd_cancel_req(struct dasd_ccw_req *);
899 int dasd_flush_device_queue(struct dasd_device *);
900 int dasd_generic_probe(struct ccw_device *);
901 void dasd_generic_free_discipline(struct dasd_device *);
902 void dasd_generic_remove (struct ccw_device *cdev);
903 int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
904 int dasd_generic_set_offline (struct ccw_device *cdev);
905 int dasd_generic_notify(struct ccw_device *, int);
906 int dasd_generic_last_path_gone(struct dasd_device *);
907 int dasd_generic_path_operational(struct dasd_device *);
908 void dasd_generic_shutdown(struct ccw_device *);
909 
910 void dasd_generic_handle_state_change(struct dasd_device *);
911 enum uc_todo dasd_generic_uc_handler(struct ccw_device *, struct irb *);
912 void dasd_generic_path_event(struct ccw_device *, int *);
913 int dasd_generic_verify_path(struct dasd_device *, __u8);
914 void dasd_generic_space_exhaust(struct dasd_device *, struct dasd_ccw_req *);
915 void dasd_generic_space_avail(struct dasd_device *);
916 
917 int dasd_generic_requeue_all_requests(struct dasd_device *);
918 
919 int dasd_generic_read_dev_chars(struct dasd_device *, int, void *, int);
920 char *dasd_get_sense(struct irb *);
921 
922 void dasd_device_set_stop_bits(struct dasd_device *, int);
923 void dasd_device_remove_stop_bits(struct dasd_device *, int);
924 
925 int dasd_device_is_ro(struct dasd_device *);
926 
927 void dasd_profile_reset(struct dasd_profile *);
928 int dasd_profile_on(struct dasd_profile *);
929 void dasd_profile_off(struct dasd_profile *);
930 char *dasd_get_user_string(const char __user *, size_t);
931 
932 /* externals in dasd_devmap.c */
933 extern int dasd_max_devindex;
934 extern int dasd_probeonly;
935 extern int dasd_autodetect;
936 extern int dasd_nopav;
937 extern int dasd_nofcx;
938 
939 int dasd_devmap_init(void);
940 void dasd_devmap_exit(void);
941 
942 struct dasd_device *dasd_create_device(struct ccw_device *);
943 void dasd_delete_device(struct dasd_device *);
944 
945 int dasd_get_feature(struct ccw_device *, int);
946 int dasd_set_feature(struct ccw_device *, int, int);
947 
948 extern const struct attribute_group *dasd_dev_groups[];
949 void dasd_path_create_kobj(struct dasd_device *, int);
950 void dasd_path_create_kobjects(struct dasd_device *);
951 void dasd_path_remove_kobjects(struct dasd_device *);
952 
953 struct dasd_device *dasd_device_from_cdev(struct ccw_device *);
954 struct dasd_device *dasd_device_from_cdev_locked(struct ccw_device *);
955 struct dasd_device *dasd_device_from_devindex(int);
956 
957 void dasd_add_link_to_gendisk(struct gendisk *, struct dasd_device *);
958 struct dasd_device *dasd_device_from_gendisk(struct gendisk *);
959 
960 int dasd_parse(void) __init;
961 int dasd_busid_known(const char *);
962 
963 /* externals in dasd_gendisk.c */
964 int  dasd_gendisk_init(void);
965 void dasd_gendisk_exit(void);
966 int dasd_gendisk_alloc(struct dasd_block *);
967 void dasd_gendisk_free(struct dasd_block *);
968 int dasd_scan_partitions(struct dasd_block *);
969 void dasd_destroy_partitions(struct dasd_block *);
970 
971 /* externals in dasd_ioctl.c */
972 int dasd_ioctl(struct block_device *bdev, blk_mode_t mode, unsigned int cmd,
973 		unsigned long arg);
974 int dasd_set_read_only(struct block_device *bdev, bool ro);
975 
976 /* externals in dasd_proc.c */
977 int dasd_proc_init(void);
978 void dasd_proc_exit(void);
979 
980 /* externals in dasd_erp.c */
981 struct dasd_ccw_req *dasd_default_erp_action(struct dasd_ccw_req *);
982 struct dasd_ccw_req *dasd_default_erp_postaction(struct dasd_ccw_req *);
983 struct dasd_ccw_req *dasd_alloc_erp_request(unsigned int, int, int,
984 					    struct dasd_device *);
985 void dasd_free_erp_request(struct dasd_ccw_req *, struct dasd_device *);
986 void dasd_log_sense(struct dasd_ccw_req *, struct irb *);
987 void dasd_log_sense_dbf(struct dasd_ccw_req *cqr, struct irb *irb);
988 
989 /* externals in dasd_3990_erp.c */
990 struct dasd_ccw_req *dasd_3990_erp_action(struct dasd_ccw_req *);
991 void dasd_3990_erp_handle_sim(struct dasd_device *, char *);
992 
993 /* externals in dasd_eer.c */
994 #ifdef CONFIG_DASD_EER
995 int dasd_eer_init(void);
996 void dasd_eer_exit(void);
997 int dasd_eer_enable(struct dasd_device *);
998 void dasd_eer_disable(struct dasd_device *);
999 void dasd_eer_write(struct dasd_device *, struct dasd_ccw_req *cqr,
1000 		    unsigned int id);
1001 void dasd_eer_snss(struct dasd_device *);
1002 
1003 static inline int dasd_eer_enabled(struct dasd_device *device)
1004 {
1005 	return device->eer_cqr != NULL;
1006 }
1007 #else
1008 #define dasd_eer_init()		(0)
1009 #define dasd_eer_exit()		do { } while (0)
1010 #define dasd_eer_enable(d)	(0)
1011 #define dasd_eer_disable(d)	do { } while (0)
1012 #define dasd_eer_write(d,c,i)	do { } while (0)
1013 #define dasd_eer_snss(d)	do { } while (0)
1014 #define dasd_eer_enabled(d)	(0)
1015 #endif	/* CONFIG_DASD_ERR */
1016 
1017 
1018 /* DASD path handling functions */
1019 
1020 /*
1021  * helper functions to modify bit masks for a given channel path for a device
1022  */
1023 static inline int dasd_path_is_operational(struct dasd_device *device, int chp)
1024 {
1025 	return test_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
1026 }
1027 
1028 static inline int dasd_path_need_verify(struct dasd_device *device, int chp)
1029 {
1030 	return test_bit(DASD_PATH_TBV, &device->path[chp].flags);
1031 }
1032 
1033 static inline void dasd_path_verify(struct dasd_device *device, int chp)
1034 {
1035 	__set_bit(DASD_PATH_TBV, &device->path[chp].flags);
1036 }
1037 
1038 static inline void dasd_path_clear_verify(struct dasd_device *device, int chp)
1039 {
1040 	__clear_bit(DASD_PATH_TBV, &device->path[chp].flags);
1041 }
1042 
1043 static inline void dasd_path_clear_all_verify(struct dasd_device *device)
1044 {
1045 	int chp;
1046 
1047 	for (chp = 0; chp < 8; chp++)
1048 		dasd_path_clear_verify(device, chp);
1049 }
1050 
1051 static inline void dasd_path_fcsec(struct dasd_device *device, int chp)
1052 {
1053 	__set_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
1054 }
1055 
1056 static inline void dasd_path_clear_fcsec(struct dasd_device *device, int chp)
1057 {
1058 	__clear_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
1059 }
1060 
1061 static inline int dasd_path_need_fcsec(struct dasd_device *device, int chp)
1062 {
1063 	return test_bit(DASD_PATH_FCSEC, &device->path[chp].flags);
1064 }
1065 
1066 static inline void dasd_path_clear_all_fcsec(struct dasd_device *device)
1067 {
1068 	int chp;
1069 
1070 	for (chp = 0; chp < 8; chp++)
1071 		dasd_path_clear_fcsec(device, chp);
1072 }
1073 
1074 static inline void dasd_path_operational(struct dasd_device *device, int chp)
1075 {
1076 	__set_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
1077 	device->opm |= (0x80 >> chp);
1078 }
1079 
1080 static inline void dasd_path_nonpreferred(struct dasd_device *device, int chp)
1081 {
1082 	__set_bit(DASD_PATH_NPP, &device->path[chp].flags);
1083 }
1084 
1085 static inline int dasd_path_is_nonpreferred(struct dasd_device *device, int chp)
1086 {
1087 	return test_bit(DASD_PATH_NPP, &device->path[chp].flags);
1088 }
1089 
1090 static inline void dasd_path_clear_nonpreferred(struct dasd_device *device,
1091 						int chp)
1092 {
1093 	__clear_bit(DASD_PATH_NPP, &device->path[chp].flags);
1094 }
1095 
1096 static inline void dasd_path_preferred(struct dasd_device *device, int chp)
1097 {
1098 	__set_bit(DASD_PATH_PP, &device->path[chp].flags);
1099 }
1100 
1101 static inline int dasd_path_is_preferred(struct dasd_device *device, int chp)
1102 {
1103 	return test_bit(DASD_PATH_PP, &device->path[chp].flags);
1104 }
1105 
1106 static inline void dasd_path_clear_preferred(struct dasd_device *device,
1107 					     int chp)
1108 {
1109 	__clear_bit(DASD_PATH_PP, &device->path[chp].flags);
1110 }
1111 
1112 static inline void dasd_path_clear_oper(struct dasd_device *device, int chp)
1113 {
1114 	__clear_bit(DASD_PATH_OPERATIONAL, &device->path[chp].flags);
1115 	device->opm &= ~(0x80 >> chp);
1116 }
1117 
1118 static inline void dasd_path_clear_cable(struct dasd_device *device, int chp)
1119 {
1120 	__clear_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1121 }
1122 
1123 static inline void dasd_path_cuir(struct dasd_device *device, int chp)
1124 {
1125 	__set_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1126 }
1127 
1128 static inline int dasd_path_is_cuir(struct dasd_device *device, int chp)
1129 {
1130 	return test_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1131 }
1132 
1133 static inline void dasd_path_clear_cuir(struct dasd_device *device, int chp)
1134 {
1135 	__clear_bit(DASD_PATH_CUIR, &device->path[chp].flags);
1136 }
1137 
1138 static inline void dasd_path_ifcc(struct dasd_device *device, int chp)
1139 {
1140 	set_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1141 }
1142 
1143 static inline int dasd_path_is_ifcc(struct dasd_device *device, int chp)
1144 {
1145 	return test_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1146 }
1147 
1148 static inline void dasd_path_clear_ifcc(struct dasd_device *device, int chp)
1149 {
1150 	clear_bit(DASD_PATH_IFCC, &device->path[chp].flags);
1151 }
1152 
1153 static inline void dasd_path_clear_nohpf(struct dasd_device *device, int chp)
1154 {
1155 	__clear_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1156 }
1157 
1158 static inline void dasd_path_miscabled(struct dasd_device *device, int chp)
1159 {
1160 	__set_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1161 }
1162 
1163 static inline int dasd_path_is_miscabled(struct dasd_device *device, int chp)
1164 {
1165 	return test_bit(DASD_PATH_MISCABLED, &device->path[chp].flags);
1166 }
1167 
1168 static inline void dasd_path_nohpf(struct dasd_device *device, int chp)
1169 {
1170 	__set_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1171 }
1172 
1173 static inline int dasd_path_is_nohpf(struct dasd_device *device, int chp)
1174 {
1175 	return test_bit(DASD_PATH_NOHPF, &device->path[chp].flags);
1176 }
1177 
1178 /*
1179  * get functions for path masks
1180  * will return a path masks for the given device
1181  */
1182 
1183 static inline __u8 dasd_path_get_opm(struct dasd_device *device)
1184 {
1185 	return device->opm;
1186 }
1187 
1188 static inline __u8 dasd_path_get_tbvpm(struct dasd_device *device)
1189 {
1190 	int chp;
1191 	__u8 tbvpm = 0x00;
1192 
1193 	for (chp = 0; chp < 8; chp++)
1194 		if (dasd_path_need_verify(device, chp))
1195 			tbvpm |= 0x80 >> chp;
1196 	return tbvpm;
1197 }
1198 
1199 static inline int dasd_path_get_fcsecpm(struct dasd_device *device)
1200 {
1201 	int chp;
1202 
1203 	for (chp = 0; chp < 8; chp++)
1204 		if (dasd_path_need_fcsec(device, chp))
1205 			return 1;
1206 
1207 	return 0;
1208 }
1209 
1210 static inline __u8 dasd_path_get_nppm(struct dasd_device *device)
1211 {
1212 	int chp;
1213 	__u8 npm = 0x00;
1214 
1215 	for (chp = 0; chp < 8; chp++) {
1216 		if (dasd_path_is_nonpreferred(device, chp))
1217 			npm |= 0x80 >> chp;
1218 	}
1219 	return npm;
1220 }
1221 
1222 static inline __u8 dasd_path_get_ppm(struct dasd_device *device)
1223 {
1224 	int chp;
1225 	__u8 ppm = 0x00;
1226 
1227 	for (chp = 0; chp < 8; chp++)
1228 		if (dasd_path_is_preferred(device, chp))
1229 			ppm |= 0x80 >> chp;
1230 	return ppm;
1231 }
1232 
1233 static inline __u8 dasd_path_get_cablepm(struct dasd_device *device)
1234 {
1235 	int chp;
1236 	__u8 cablepm = 0x00;
1237 
1238 	for (chp = 0; chp < 8; chp++)
1239 		if (dasd_path_is_miscabled(device, chp))
1240 			cablepm |= 0x80 >> chp;
1241 	return cablepm;
1242 }
1243 
1244 static inline __u8 dasd_path_get_cuirpm(struct dasd_device *device)
1245 {
1246 	int chp;
1247 	__u8 cuirpm = 0x00;
1248 
1249 	for (chp = 0; chp < 8; chp++)
1250 		if (dasd_path_is_cuir(device, chp))
1251 			cuirpm |= 0x80 >> chp;
1252 	return cuirpm;
1253 }
1254 
1255 static inline __u8 dasd_path_get_ifccpm(struct dasd_device *device)
1256 {
1257 	int chp;
1258 	__u8 ifccpm = 0x00;
1259 
1260 	for (chp = 0; chp < 8; chp++)
1261 		if (dasd_path_is_ifcc(device, chp))
1262 			ifccpm |= 0x80 >> chp;
1263 	return ifccpm;
1264 }
1265 
1266 static inline __u8 dasd_path_get_hpfpm(struct dasd_device *device)
1267 {
1268 	int chp;
1269 	__u8 hpfpm = 0x00;
1270 
1271 	for (chp = 0; chp < 8; chp++)
1272 		if (dasd_path_is_nohpf(device, chp))
1273 			hpfpm |= 0x80 >> chp;
1274 	return hpfpm;
1275 }
1276 
1277 static inline u8 dasd_path_get_fcs_path(struct dasd_device *device, int chp)
1278 {
1279 	return device->path[chp].fc_security;
1280 }
1281 
1282 static inline int dasd_path_get_fcs_device(struct dasd_device *device)
1283 {
1284 	u8 fc_sec = 0;
1285 	int chp;
1286 
1287 	for (chp = 0; chp < 8; chp++) {
1288 		if (device->opm & (0x80 >> chp)) {
1289 			fc_sec = device->path[chp].fc_security;
1290 			break;
1291 		}
1292 	}
1293 	for (; chp < 8; chp++) {
1294 		if (device->opm & (0x80 >> chp))
1295 			if (device->path[chp].fc_security != fc_sec)
1296 				return -EINVAL;
1297 	}
1298 
1299 	return fc_sec;
1300 }
1301 
1302 /*
1303  * add functions for path masks
1304  * the existing path mask will be extended by the given path mask
1305  */
1306 static inline void dasd_path_add_tbvpm(struct dasd_device *device, __u8 pm)
1307 {
1308 	int chp;
1309 
1310 	for (chp = 0; chp < 8; chp++)
1311 		if (pm & (0x80 >> chp))
1312 			dasd_path_verify(device, chp);
1313 }
1314 
1315 static inline __u8 dasd_path_get_notoperpm(struct dasd_device *device)
1316 {
1317 	int chp;
1318 	__u8 nopm = 0x00;
1319 
1320 	for (chp = 0; chp < 8; chp++)
1321 		if (dasd_path_is_nohpf(device, chp) ||
1322 		    dasd_path_is_ifcc(device, chp) ||
1323 		    dasd_path_is_cuir(device, chp) ||
1324 		    dasd_path_is_miscabled(device, chp))
1325 			nopm |= 0x80 >> chp;
1326 	return nopm;
1327 }
1328 
1329 static inline void dasd_path_add_opm(struct dasd_device *device, __u8 pm)
1330 {
1331 	int chp;
1332 
1333 	for (chp = 0; chp < 8; chp++)
1334 		if (pm & (0x80 >> chp)) {
1335 			dasd_path_operational(device, chp);
1336 			/*
1337 			 * if the path is used
1338 			 * it should not be in one of the negative lists
1339 			 */
1340 			dasd_path_clear_nohpf(device, chp);
1341 			dasd_path_clear_cuir(device, chp);
1342 			dasd_path_clear_cable(device, chp);
1343 			dasd_path_clear_ifcc(device, chp);
1344 		}
1345 }
1346 
1347 static inline void dasd_path_add_cablepm(struct dasd_device *device, __u8 pm)
1348 {
1349 	int chp;
1350 
1351 	for (chp = 0; chp < 8; chp++)
1352 		if (pm & (0x80 >> chp))
1353 			dasd_path_miscabled(device, chp);
1354 }
1355 
1356 static inline void dasd_path_add_cuirpm(struct dasd_device *device, __u8 pm)
1357 {
1358 	int chp;
1359 
1360 	for (chp = 0; chp < 8; chp++)
1361 		if (pm & (0x80 >> chp))
1362 			dasd_path_cuir(device, chp);
1363 }
1364 
1365 static inline void dasd_path_add_ifccpm(struct dasd_device *device, __u8 pm)
1366 {
1367 	int chp;
1368 
1369 	for (chp = 0; chp < 8; chp++)
1370 		if (pm & (0x80 >> chp))
1371 			dasd_path_ifcc(device, chp);
1372 }
1373 
1374 static inline void dasd_path_add_nppm(struct dasd_device *device, __u8 pm)
1375 {
1376 	int chp;
1377 
1378 	for (chp = 0; chp < 8; chp++)
1379 		if (pm & (0x80 >> chp))
1380 			dasd_path_nonpreferred(device, chp);
1381 }
1382 
1383 static inline void dasd_path_add_nohpfpm(struct dasd_device *device, __u8 pm)
1384 {
1385 	int chp;
1386 
1387 	for (chp = 0; chp < 8; chp++)
1388 		if (pm & (0x80 >> chp))
1389 			dasd_path_nohpf(device, chp);
1390 }
1391 
1392 static inline void dasd_path_add_ppm(struct dasd_device *device, __u8 pm)
1393 {
1394 	int chp;
1395 
1396 	for (chp = 0; chp < 8; chp++)
1397 		if (pm & (0x80 >> chp))
1398 			dasd_path_preferred(device, chp);
1399 }
1400 
1401 static inline void dasd_path_add_fcsecpm(struct dasd_device *device, __u8 pm)
1402 {
1403 	int chp;
1404 
1405 	for (chp = 0; chp < 8; chp++)
1406 		if (pm & (0x80 >> chp))
1407 			dasd_path_fcsec(device, chp);
1408 }
1409 
1410 /*
1411  * set functions for path masks
1412  * the existing path mask will be replaced by the given path mask
1413  */
1414 static inline void dasd_path_set_tbvpm(struct dasd_device *device, __u8 pm)
1415 {
1416 	int chp;
1417 
1418 	for (chp = 0; chp < 8; chp++)
1419 		if (pm & (0x80 >> chp))
1420 			dasd_path_verify(device, chp);
1421 		else
1422 			dasd_path_clear_verify(device, chp);
1423 }
1424 
1425 static inline void dasd_path_set_opm(struct dasd_device *device, __u8 pm)
1426 {
1427 	int chp;
1428 
1429 	for (chp = 0; chp < 8; chp++) {
1430 		dasd_path_clear_oper(device, chp);
1431 		if (pm & (0x80 >> chp)) {
1432 			dasd_path_operational(device, chp);
1433 			/*
1434 			 * if the path is used
1435 			 * it should not be in one of the negative lists
1436 			 */
1437 			dasd_path_clear_nohpf(device, chp);
1438 			dasd_path_clear_cuir(device, chp);
1439 			dasd_path_clear_cable(device, chp);
1440 			dasd_path_clear_ifcc(device, chp);
1441 		}
1442 	}
1443 }
1444 
1445 /*
1446  * remove functions for path masks
1447  * the existing path mask will be cleared with the given path mask
1448  */
1449 static inline void dasd_path_remove_opm(struct dasd_device *device, __u8 pm)
1450 {
1451 	int chp;
1452 
1453 	for (chp = 0; chp < 8; chp++) {
1454 		if (pm & (0x80 >> chp))
1455 			dasd_path_clear_oper(device, chp);
1456 	}
1457 }
1458 
1459 /*
1460  * add the newly available path to the to be verified pm and remove it from
1461  * normal operation until it is verified
1462  */
1463 static inline void dasd_path_available(struct dasd_device *device, int chp)
1464 {
1465 	dasd_path_clear_oper(device, chp);
1466 	dasd_path_verify(device, chp);
1467 }
1468 
1469 static inline void dasd_path_notoper(struct dasd_device *device, int chp)
1470 {
1471 	dasd_path_clear_oper(device, chp);
1472 	dasd_path_clear_preferred(device, chp);
1473 	dasd_path_clear_nonpreferred(device, chp);
1474 }
1475 
1476 static inline void dasd_path_fcsec_update(struct dasd_device *device, int chp)
1477 {
1478 	dasd_path_fcsec(device, chp);
1479 }
1480 
1481 /*
1482  * remove all paths from normal operation
1483  */
1484 static inline void dasd_path_no_path(struct dasd_device *device)
1485 {
1486 	int chp;
1487 
1488 	for (chp = 0; chp < 8; chp++)
1489 		dasd_path_notoper(device, chp);
1490 
1491 	dasd_path_clear_all_verify(device);
1492 }
1493 
1494 /* end - path handling */
1495 
1496 #endif				/* DASD_H */
1497