[mirror_ubuntu-bionic-kernel.git] / drivers / s390 / block / scm_blk.h

#ifndef SCM_BLK_H
#define SCM_BLK_H

#include <linux/interrupt.h>
#include <linux/spinlock.h>
#include <linux/blkdev.h>
#include <linux/genhd.h>
#include <linux/list.h>

#include <asm/debug.h>
#include <asm/eadm.h>

#define SCM_NR_PARTS 8
#define SCM_QUEUE_DELAY 5

struct scm_blk_dev {
	struct tasklet_struct tasklet;
	struct request_queue *rq;
	struct gendisk *gendisk;
	struct scm_device *scmdev;
	spinlock_t rq_lock;	/* guard the request queue */
	spinlock_t lock;	/* guard the rest of the blockdev */
	atomic_t queued_reqs;
	enum {SCM_OPER, SCM_WR_PROHIBIT} state;
	struct list_head finished_requests;
#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
	struct list_head cluster_list;
#endif
};

struct scm_request {
	struct scm_blk_dev *bdev;
	struct aidaw *next_aidaw;
	struct request **request;
	struct aob *aob;
	struct list_head list;
	u8 retries;
	blk_status_t error;
#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
	struct {
		enum {CLUSTER_NONE, CLUSTER_READ, CLUSTER_WRITE} state;
		struct list_head list;
		void **buf;
	} cluster;
#endif
};

#define to_aobrq(rq) container_of((void *) rq, struct aob_rq_header, data)

int scm_blk_dev_setup(struct scm_blk_dev *, struct scm_device *);
void scm_blk_dev_cleanup(struct scm_blk_dev *);
void scm_blk_set_available(struct scm_blk_dev *);
void scm_blk_irq(struct scm_device *, void *, blk_status_t);

void scm_request_finish(struct scm_request *);
void scm_request_requeue(struct scm_request *);

struct aidaw *scm_aidaw_fetch(struct scm_request *scmrq, unsigned int bytes);

int scm_drv_init(void);
void scm_drv_cleanup(void);

#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
void __scm_free_rq_cluster(struct scm_request *);
int __scm_alloc_rq_cluster(struct scm_request *);
void scm_request_cluster_init(struct scm_request *);
bool scm_reserve_cluster(struct scm_request *);
void scm_release_cluster(struct scm_request *);
void scm_blk_dev_cluster_setup(struct scm_blk_dev *);
bool scm_need_cluster_request(struct scm_request *);
void scm_initiate_cluster_request(struct scm_request *);
void scm_cluster_request_irq(struct scm_request *);
bool scm_test_cluster_request(struct scm_request *);
bool scm_cluster_size_valid(void);
#else /* CONFIG_SCM_BLOCK_CLUSTER_WRITE */
static inline void __scm_free_rq_cluster(struct scm_request *scmrq) {}
static inline int __scm_alloc_rq_cluster(struct scm_request *scmrq)
{
	return 0;
}
static inline void scm_request_cluster_init(struct scm_request *scmrq) {}
static inline bool scm_reserve_cluster(struct scm_request *scmrq)
{
	return true;
}
static inline void scm_release_cluster(struct scm_request *scmrq) {}
static inline void scm_blk_dev_cluster_setup(struct scm_blk_dev *bdev) {}
static inline bool scm_need_cluster_request(struct scm_request *scmrq)
{
	return false;
}
static inline void scm_initiate_cluster_request(struct scm_request *scmrq) {}
static inline void scm_cluster_request_irq(struct scm_request *scmrq) {}
static inline bool scm_test_cluster_request(struct scm_request *scmrq)
{
	return false;
}
static inline bool scm_cluster_size_valid(void)
{
	return true;
}
#endif /* CONFIG_SCM_BLOCK_CLUSTER_WRITE */

extern debug_info_t *scm_debug;

#define SCM_LOG(imp, txt) do {					\
		debug_text_event(scm_debug, imp, txt);		\
	} while (0)

static inline void SCM_LOG_HEX(int level, void *data, int length)
{
	if (!debug_level_enabled(scm_debug, level))
		return;
	while (length > 0) {
		debug_event(scm_debug, level, data, length);
		length -= scm_debug->buf_size;
		data += scm_debug->buf_size;
	}
}

static inline void SCM_LOG_STATE(int level, struct scm_device *scmdev)
{
	struct {
		u64 address;
		u8 oper_state;
		u8 rank;
	} __packed data = {
		.address = scmdev->address,
		.oper_state = scmdev->attrs.oper_state,
		.rank = scmdev->attrs.rank,
	};

	SCM_LOG_HEX(level, &data, sizeof(data));
}

#endif /* SCM_BLK_H */
Commit	Line	Data
f30664e2 SO	1	#ifndef SCM_BLK_H
	2	#define SCM_BLK_H
	3
	4	#include <linux/interrupt.h>
	5	#include <linux/spinlock.h>
	6	#include <linux/blkdev.h>
	7	#include <linux/genhd.h>
	8	#include <linux/list.h>
	9
	10	#include <asm/debug.h>
	11	#include <asm/eadm.h>
	12
	13	#define SCM_NR_PARTS 8
	14	#define SCM_QUEUE_DELAY 5
	15
	16	struct scm_blk_dev {
	17	struct tasklet_struct tasklet;
	18	struct request_queue *rq;
	19	struct gendisk *gendisk;
	20	struct scm_device *scmdev;
	21	spinlock_t rq_lock; /* guard the request queue */
	22	spinlock_t lock; /* guard the rest of the blockdev */
	23	atomic_t queued_reqs;
4fa3c019	24	enum {SCM_OPER, SCM_WR_PROHIBIT} state;
f30664e2	25	struct list_head finished_requests;
0d804b20 SO	26	#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
	27	struct list_head cluster_list;
	28	#endif
f30664e2 SO	29	};
	30
	31	struct scm_request {
	32	struct scm_blk_dev *bdev;
de88d0d2	33	struct aidaw *next_aidaw;
8622384f	34	struct request **request;
f30664e2 SO	35	struct aob *aob;
	36	struct list_head list;
	37	u8 retries;
2a842aca	38	blk_status_t error;
0d804b20 SO	39	#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
	40	struct {
	41	enum {CLUSTER_NONE, CLUSTER_READ, CLUSTER_WRITE} state;
	42	struct list_head list;
	43	void **buf;
	44	} cluster;
	45	#endif
f30664e2 SO	46	};
	47
	48	#define to_aobrq(rq) container_of((void *) rq, struct aob_rq_header, data)
	49
	50	int scm_blk_dev_setup(struct scm_blk_dev , struct scm_device );
	51	void scm_blk_dev_cleanup(struct scm_blk_dev *);
4fa3c019	52	void scm_blk_set_available(struct scm_blk_dev *);
2a842aca	53	void scm_blk_irq(struct scm_device , void , blk_status_t);
f30664e2	54
0d804b20 SO	55	void scm_request_finish(struct scm_request *);
	56	void scm_request_requeue(struct scm_request *);
	57
de88d0d2	58	struct aidaw scm_aidaw_fetch(struct scm_request scmrq, unsigned int bytes);
9d4df77f	59
f30664e2 SO	60	int scm_drv_init(void);
	61	void scm_drv_cleanup(void);
	62
0d804b20 SO	63	#ifdef CONFIG_SCM_BLOCK_CLUSTER_WRITE
	64	void __scm_free_rq_cluster(struct scm_request *);
	65	int __scm_alloc_rq_cluster(struct scm_request *);
	66	void scm_request_cluster_init(struct scm_request *);
	67	bool scm_reserve_cluster(struct scm_request *);
	68	void scm_release_cluster(struct scm_request *);
	69	void scm_blk_dev_cluster_setup(struct scm_blk_dev *);
	70	bool scm_need_cluster_request(struct scm_request *);
	71	void scm_initiate_cluster_request(struct scm_request *);
	72	void scm_cluster_request_irq(struct scm_request *);
	73	bool scm_test_cluster_request(struct scm_request *);
	74	bool scm_cluster_size_valid(void);
58fece78 SO	75	#else /* CONFIG_SCM_BLOCK_CLUSTER_WRITE */
	76	static inline void __scm_free_rq_cluster(struct scm_request *scmrq) {}
	77	static inline int __scm_alloc_rq_cluster(struct scm_request *scmrq)
	78	{
	79	return 0;
	80	}
	81	static inline void scm_request_cluster_init(struct scm_request *scmrq) {}
	82	static inline bool scm_reserve_cluster(struct scm_request *scmrq)
	83	{
	84	return true;
	85	}
	86	static inline void scm_release_cluster(struct scm_request *scmrq) {}
	87	static inline void scm_blk_dev_cluster_setup(struct scm_blk_dev *bdev) {}
	88	static inline bool scm_need_cluster_request(struct scm_request *scmrq)
	89	{
	90	return false;
	91	}
	92	static inline void scm_initiate_cluster_request(struct scm_request *scmrq) {}
	93	static inline void scm_cluster_request_irq(struct scm_request *scmrq) {}
	94	static inline bool scm_test_cluster_request(struct scm_request *scmrq)
	95	{
	96	return false;
	97	}
	98	static inline bool scm_cluster_size_valid(void)
	99	{
	100	return true;
	101	}
	102	#endif /* CONFIG_SCM_BLOCK_CLUSTER_WRITE */
f30664e2 SO	103
	104	extern debug_info_t *scm_debug;
	105
	106	#define SCM_LOG(imp, txt) do { \
	107	debug_text_event(scm_debug, imp, txt); \
	108	} while (0)
	109
	110	static inline void SCM_LOG_HEX(int level, void *data, int length)
	111	{
8e6a8285	112	if (!debug_level_enabled(scm_debug, level))
f30664e2 SO	113	return;
	114	while (length > 0) {
	115	debug_event(scm_debug, level, data, length);
	116	length -= scm_debug->buf_size;
	117	data += scm_debug->buf_size;
	118	}
	119	}
	120
	121	static inline void SCM_LOG_STATE(int level, struct scm_device *scmdev)
	122	{
	123	struct {
	124	u64 address;
	125	u8 oper_state;
	126	u8 rank;
	127	} __packed data = {
	128	.address = scmdev->address,
	129	.oper_state = scmdev->attrs.oper_state,
	130	.rank = scmdev->attrs.rank,
	131	};
	132
	133	SCM_LOG_HEX(level, &data, sizeof(data));
	134	}
	135
	136	#endif /* SCM_BLK_H */