xref: /openbmc/linux/drivers/s390/block/dasd_int.h (revision 26d0dfbb16fcb17d128a79dc70f3020ea6992af0)
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_IT	5	/* Suppress 'Invalid Track' 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   Pimary 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  
dasd_path_get_fcs_str(int val)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  
dasd_path_release(struct kobject * kobj)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 block_device *bdev;
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
dasd_get_device(struct dasd_device * device)736  dasd_get_device(struct dasd_device *device)
737  {
738  	atomic_inc(&device->ref_count);
739  }
740  
741  static inline void
dasd_put_device(struct dasd_device * device)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
dasd_init_chunklist(struct list_head * chunk_list,void * mem,unsigned long size)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 *
dasd_alloc_chunk(struct list_head * chunk_list,unsigned long size)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
dasd_free_chunk(struct list_head * chunk_list,void * mem)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
dasd_check_blocksize(int bsize)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   */
dasd_get_callback_data(struct dasd_ccw_req * cqr)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  
dasd_eer_enabled(struct dasd_device * device)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   */
dasd_path_is_operational(struct dasd_device * device,int chp)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  
dasd_path_need_verify(struct dasd_device * device,int chp)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  
dasd_path_verify(struct dasd_device * device,int chp)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  
dasd_path_clear_verify(struct dasd_device * device,int chp)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  
dasd_path_clear_all_verify(struct dasd_device * device)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  
dasd_path_fcsec(struct dasd_device * device,int chp)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  
dasd_path_clear_fcsec(struct dasd_device * device,int chp)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  
dasd_path_need_fcsec(struct dasd_device * device,int chp)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  
dasd_path_clear_all_fcsec(struct dasd_device * device)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  
dasd_path_operational(struct dasd_device * device,int chp)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  
dasd_path_nonpreferred(struct dasd_device * device,int chp)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  
dasd_path_is_nonpreferred(struct dasd_device * device,int chp)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  
dasd_path_clear_nonpreferred(struct dasd_device * device,int chp)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  
dasd_path_preferred(struct dasd_device * device,int chp)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  
dasd_path_is_preferred(struct dasd_device * device,int chp)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  
dasd_path_clear_preferred(struct dasd_device * device,int chp)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  
dasd_path_clear_oper(struct dasd_device * device,int chp)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  
dasd_path_clear_cable(struct dasd_device * device,int chp)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  
dasd_path_cuir(struct dasd_device * device,int chp)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  
dasd_path_is_cuir(struct dasd_device * device,int chp)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  
dasd_path_clear_cuir(struct dasd_device * device,int chp)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  
dasd_path_ifcc(struct dasd_device * device,int chp)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  
dasd_path_is_ifcc(struct dasd_device * device,int chp)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  
dasd_path_clear_ifcc(struct dasd_device * device,int chp)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  
dasd_path_clear_nohpf(struct dasd_device * device,int chp)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  
dasd_path_miscabled(struct dasd_device * device,int chp)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  
dasd_path_is_miscabled(struct dasd_device * device,int chp)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  
dasd_path_nohpf(struct dasd_device * device,int chp)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  
dasd_path_is_nohpf(struct dasd_device * device,int chp)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  
dasd_path_get_opm(struct dasd_device * device)1183  static inline __u8 dasd_path_get_opm(struct dasd_device *device)
1184  {
1185  	return device->opm;
1186  }
1187  
dasd_path_get_tbvpm(struct dasd_device * device)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  
dasd_path_get_fcsecpm(struct dasd_device * device)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  
dasd_path_get_nppm(struct dasd_device * device)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  
dasd_path_get_ppm(struct dasd_device * device)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  
dasd_path_get_cablepm(struct dasd_device * device)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  
dasd_path_get_cuirpm(struct dasd_device * device)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  
dasd_path_get_ifccpm(struct dasd_device * device)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  
dasd_path_get_hpfpm(struct dasd_device * device)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  
dasd_path_get_fcs_path(struct dasd_device * device,int chp)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  
dasd_path_get_fcs_device(struct dasd_device * device)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   */
dasd_path_add_tbvpm(struct dasd_device * device,__u8 pm)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  
dasd_path_get_notoperpm(struct dasd_device * device)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  
dasd_path_add_opm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_cablepm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_cuirpm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_ifccpm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_nppm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_nohpfpm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_ppm(struct dasd_device * device,__u8 pm)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  
dasd_path_add_fcsecpm(struct dasd_device * device,__u8 pm)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   */
dasd_path_set_tbvpm(struct dasd_device * device,__u8 pm)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  
dasd_path_set_opm(struct dasd_device * device,__u8 pm)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   */
dasd_path_remove_opm(struct dasd_device * device,__u8 pm)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   */
dasd_path_available(struct dasd_device * device,int chp)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  
dasd_path_notoper(struct dasd_device * device,int chp)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  
dasd_path_fcsec_update(struct dasd_device * device,int chp)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   */
dasd_path_no_path(struct dasd_device * device)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