[linux-block.git] / include / linux / transport_class.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * transport_class.h - a generic container for all transport classes
 *
 * Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
 */

#ifndef _TRANSPORT_CLASS_H_
#define _TRANSPORT_CLASS_H_

#include <linux/device.h>
#include <linux/bug.h>
#include <linux/attribute_container.h>

struct transport_container;

struct transport_class {
	struct class class;
	int (*setup)(struct transport_container *, struct device *,
		     struct device *);
	int (*configure)(struct transport_container *, struct device *,
			 struct device *);
	int (*remove)(struct transport_container *, struct device *,
		      struct device *);
};

#define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg)			\
struct transport_class cls = {						\
	.class = {							\
		.name = nm,						\
	},								\
	.setup = su,							\
	.remove = rm,							\
	.configure = cfg,						\
}


struct anon_transport_class {
	struct transport_class tclass;
	struct attribute_container container;
};

#define DECLARE_ANON_TRANSPORT_CLASS(cls, mtch, cfg)		\
struct anon_transport_class cls = {				\
	.tclass = {						\
		.configure = cfg,				\
	},							\
	. container = {						\
		.match = mtch,					\
	},							\
}

#define class_to_transport_class(x) \
	container_of(x, struct transport_class, class)

struct transport_container {
	struct attribute_container ac;
	const struct attribute_group *statistics;
};

#define attribute_container_to_transport_container(x) \
	container_of(x, struct transport_container, ac)

void transport_remove_device(struct device *);
int transport_add_device(struct device *);
void transport_setup_device(struct device *);
void transport_configure_device(struct device *);
void transport_destroy_device(struct device *);

static inline int
transport_register_device(struct device *dev)
{
	int ret;

	transport_setup_device(dev);
	ret = transport_add_device(dev);
	if (ret)
		transport_destroy_device(dev);

	return ret;
}

static inline void
transport_unregister_device(struct device *dev)
{
	transport_remove_device(dev);
	transport_destroy_device(dev);
}

static inline int transport_container_register(struct transport_container *tc)
{
	return attribute_container_register(&tc->ac);
}

static inline void transport_container_unregister(struct transport_container *tc)
{
	if (unlikely(attribute_container_unregister(&tc->ac)))
		BUG();
}

int transport_class_register(struct transport_class *);
int anon_transport_class_register(struct anon_transport_class *);
void transport_class_unregister(struct transport_class *);
void anon_transport_class_unregister(struct anon_transport_class *);


#endif
Commit	Line	Data
82664963	1	/* SPDX-License-Identifier: GPL-2.0-only */
1da177e4 LT	2	/*
	3	* transport_class.h - a generic container for all transport classes
	4	*
	5	* Copyright (c) 2005 - James Bottomley <James.Bottomley@steeleye.com>
1da177e4 LT	6	*/
	7
	8	#ifndef _TRANSPORT_CLASS_H_
	9	#define _TRANSPORT_CLASS_H_
	10
	11	#include <linux/device.h>
187f1882	12	#include <linux/bug.h>
1da177e4 LT	13	#include <linux/attribute_container.h>
1da177e4 LT	14
d0a7e574 JB	15	struct transport_container;
d0a7e574 JB	16
1da177e4 LT	17	struct transport_class {
1da177e4 LT	18	struct class class;
d0a7e574	19	int (setup)(struct transport_container , struct device *,
ee959b00	20	struct device *);
d0a7e574	21	int (configure)(struct transport_container , struct device *,
ee959b00	22	struct device *);
d0a7e574	23	int (remove)(struct transport_container , struct device *,
ee959b00	24	struct device *);
1da177e4 LT	25	};
	26
	27	#define DECLARE_TRANSPORT_CLASS(cls, nm, su, rm, cfg) \
	28	struct transport_class cls = { \
	29	.class = { \
	30	.name = nm, \
	31	}, \
	32	.setup = su, \
	33	.remove = rm, \
	34	.configure = cfg, \
	35	}
	36
	37
	38	struct anon_transport_class {
	39	struct transport_class tclass;
	40	struct attribute_container container;
	41	};
	42
	43	#define DECLARE_ANON_TRANSPORT_CLASS(cls, mtch, cfg) \
	44	struct anon_transport_class cls = { \
	45	.tclass = { \
	46	.configure = cfg, \
	47	}, \
	48	. container = { \
	49	.match = mtch, \
	50	}, \
	51	}
	52
	53	#define class_to_transport_class(x) \
	54	container_of(x, struct transport_class, class)
	55
	56	struct transport_container {
	57	struct attribute_container ac;
a4dbd674	58	const struct attribute_group *statistics;
1da177e4 LT	59	};
	60
	61	#define attribute_container_to_transport_container(x) \
	62	container_of(x, struct transport_container, ac)
	63
	64	void transport_remove_device(struct device *);
cd7ea70b	65	int transport_add_device(struct device *);
1da177e4 LT	66	void transport_setup_device(struct device *);
	67	void transport_configure_device(struct device *);
	68	void transport_destroy_device(struct device *);
	69
cd7ea70b	70	static inline int
1da177e4 LT	71	transport_register_device(struct device *dev)
1da177e4 LT	72	{
a8636780 YY	73	int ret;
a8636780 YY	74
1da177e4	75	transport_setup_device(dev);
a8636780 YY	76	ret = transport_add_device(dev);
	77	if (ret)
	78	transport_destroy_device(dev);
	79
	80	return ret;
1da177e4 LT	81	}
	82
	83	static inline void
	84	transport_unregister_device(struct device *dev)
	85	{
	86	transport_remove_device(dev);
	87	transport_destroy_device(dev);
	88	}
	89
	90	static inline int transport_container_register(struct transport_container *tc)
	91	{
	92	return attribute_container_register(&tc->ac);
	93	}
	94
2f3edc69	95	static inline void transport_container_unregister(struct transport_container *tc)
1da177e4	96	{
2f3edc69 JB	97	if (unlikely(attribute_container_unregister(&tc->ac)))
2f3edc69 JB	98	BUG();
1da177e4 LT	99	}
	100
	101	int transport_class_register(struct transport_class *);
	102	int anon_transport_class_register(struct anon_transport_class *);
	103	void transport_class_unregister(struct transport_class *);
	104	void anon_transport_class_unregister(struct anon_transport_class *);
	105
	106
	107	#endif