[linux-2.6-block.git] / drivers / remoteproc / remoteproc_internal.h

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Remote processor framework
 *
 * Copyright (C) 2011 Texas Instruments, Inc.
 * Copyright (C) 2011 Google, Inc.
 *
 * Ohad Ben-Cohen <ohad@wizery.com>
 * Brian Swetland <swetland@google.com>
 */

#ifndef REMOTEPROC_INTERNAL_H
#define REMOTEPROC_INTERNAL_H

#include <linux/irqreturn.h>
#include <linux/firmware.h>

struct rproc;

struct rproc_debug_trace {
	struct rproc *rproc;
	struct dentry *tfile;
	struct list_head node;
	struct rproc_mem_entry trace_mem;
};

/**
 * struct rproc_vdev_data - remoteproc virtio device data
 * @rsc_offset: offset of the vdev's resource entry
 * @id: virtio device id (as in virtio_ids.h)
 * @index: vdev position versus other vdev declared in resource table
 * @rsc: pointer to the vdev resource entry. Valid only during vdev init as
 *       the resource can be cached by rproc.
 */
struct rproc_vdev_data {
	u32 rsc_offset;
	unsigned int id;
	u32 index;
	struct fw_rsc_vdev *rsc;
};

static inline bool rproc_has_feature(struct rproc *rproc, unsigned int feature)
{
	return test_bit(feature, rproc->features);
}

static inline int rproc_set_feature(struct rproc *rproc, unsigned int feature)
{
	if (feature >= RPROC_MAX_FEATURES)
		return -EINVAL;

	set_bit(feature, rproc->features);

	return 0;
}

/* from remoteproc_core.c */
void rproc_release(struct kref *kref);
int rproc_of_parse_firmware(struct device *dev, int index,
			    const char **fw_name);

/* from remoteproc_virtio.c */
irqreturn_t rproc_vq_interrupt(struct rproc *rproc, int vq_id);

/* from remoteproc_debugfs.c */
void rproc_remove_trace_file(struct dentry *tfile);
struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,
				       struct rproc_debug_trace *trace);
void rproc_delete_debug_dir(struct rproc *rproc);
void rproc_create_debug_dir(struct rproc *rproc);
void rproc_init_debugfs(void);
void rproc_exit_debugfs(void);

/* from remoteproc_sysfs.c */
extern struct class rproc_class;
int rproc_init_sysfs(void);
void rproc_exit_sysfs(void);

#ifdef CONFIG_REMOTEPROC_CDEV
void rproc_init_cdev(void);
void rproc_exit_cdev(void);
int rproc_char_device_add(struct rproc *rproc);
void rproc_char_device_remove(struct rproc *rproc);
#else
static inline void rproc_init_cdev(void)
{
}

static inline void rproc_exit_cdev(void)
{
}

/*
 * The character device interface is an optional feature, if it is not enabled
 * the function should not return an error.
 */
static inline int rproc_char_device_add(struct rproc *rproc)
{
	return 0;
}

static inline void  rproc_char_device_remove(struct rproc *rproc)
{
}
#endif

void rproc_free_vring(struct rproc_vring *rvring);
int rproc_alloc_vring(struct rproc_vdev *rvdev, int i);
int rproc_parse_vring(struct rproc_vdev *rvdev, struct fw_rsc_vdev *rsc, int i);

phys_addr_t rproc_va_to_pa(void *cpu_addr);
int rproc_trigger_recovery(struct rproc *rproc);

int rproc_elf_sanity_check(struct rproc *rproc, const struct firmware *fw);
u64 rproc_elf_get_boot_addr(struct rproc *rproc, const struct firmware *fw);
int rproc_elf_load_segments(struct rproc *rproc, const struct firmware *fw);
int rproc_elf_load_rsc_table(struct rproc *rproc, const struct firmware *fw);
struct resource_table *rproc_elf_find_loaded_rsc_table(struct rproc *rproc,
						       const struct firmware *fw);
struct rproc_mem_entry *
rproc_find_carveout_by_name(struct rproc *rproc, const char *name, ...);
void rproc_add_rvdev(struct rproc *rproc, struct rproc_vdev *rvdev);
void rproc_remove_rvdev(struct rproc_vdev *rvdev);

static inline int rproc_prepare_device(struct rproc *rproc)
{
	if (rproc->ops->prepare)
		return rproc->ops->prepare(rproc);

	return 0;
}

static inline int rproc_unprepare_device(struct rproc *rproc)
{
	if (rproc->ops->unprepare)
		return rproc->ops->unprepare(rproc);

	return 0;
}

static inline int rproc_attach_device(struct rproc *rproc)
{
	if (rproc->ops->attach)
		return rproc->ops->attach(rproc);

	return 0;
}

static inline
int rproc_fw_sanity_check(struct rproc *rproc, const struct firmware *fw)
{
	if (rproc->ops->sanity_check)
		return rproc->ops->sanity_check(rproc, fw);

	return 0;
}

static inline
u64 rproc_get_boot_addr(struct rproc *rproc, const struct firmware *fw)
{
	if (rproc->ops->get_boot_addr)
		return rproc->ops->get_boot_addr(rproc, fw);

	return 0;
}

static inline
int rproc_load_segments(struct rproc *rproc, const struct firmware *fw)
{
	if (rproc->ops->load)
		return rproc->ops->load(rproc, fw);

	return -EINVAL;
}

static inline int rproc_parse_fw(struct rproc *rproc, const struct firmware *fw)
{
	if (rproc->ops->parse_fw)
		return rproc->ops->parse_fw(rproc, fw);

	return 0;
}

static inline
int rproc_handle_rsc(struct rproc *rproc, u32 rsc_type, void *rsc, int offset,
		     int avail)
{
	if (rproc->ops->handle_rsc)
		return rproc->ops->handle_rsc(rproc, rsc_type, rsc, offset,
					      avail);

	return RSC_IGNORED;
}

static inline
struct resource_table *rproc_find_loaded_rsc_table(struct rproc *rproc,
						   const struct firmware *fw)
{
	if (rproc->ops->find_loaded_rsc_table)
		return rproc->ops->find_loaded_rsc_table(rproc, fw);

	return NULL;
}

static inline
struct resource_table *rproc_get_loaded_rsc_table(struct rproc *rproc,
						  size_t *size)
{
	if (rproc->ops->get_loaded_rsc_table)
		return rproc->ops->get_loaded_rsc_table(rproc, size);

	return NULL;
}

static inline
bool rproc_u64_fit_in_size_t(u64 val)
{
	if (sizeof(size_t) == sizeof(u64))
		return true;

	return (val <= (size_t) -1);
}

#endif /* REMOTEPROC_INTERNAL_H */
Commit	Line	Data
9c92ab61	1	/* SPDX-License-Identifier: GPL-2.0-only */
400e64df OBC	2	/*
	3	* Remote processor framework
	4	*
	5	* Copyright (C) 2011 Texas Instruments, Inc.
	6	* Copyright (C) 2011 Google, Inc.
	7	*
	8	* Ohad Ben-Cohen <ohad@wizery.com>
	9	* Brian Swetland <swetland@google.com>
400e64df OBC	10	*/
	11
	12	#ifndef REMOTEPROC_INTERNAL_H
	13	#define REMOTEPROC_INTERNAL_H
	14
	15	#include <linux/irqreturn.h>
72854fb0	16	#include <linux/firmware.h>
400e64df OBC	17
	18	struct rproc;
	19
a987e6b9 LP	20	struct rproc_debug_trace {
	21	struct rproc *rproc;
	22	struct dentry *tfile;
	23	struct list_head node;
	24	struct rproc_mem_entry trace_mem;
	25	};
	26
fd28f879 AP	27	/**
	28	* struct rproc_vdev_data - remoteproc virtio device data
	29	* @rsc_offset: offset of the vdev's resource entry
	30	* @id: virtio device id (as in virtio_ids.h)
	31	* @index: vdev position versus other vdev declared in resource table
	32	* @rsc: pointer to the vdev resource entry. Valid only during vdev init as
	33	* the resource can be cached by rproc.
	34	*/
	35	struct rproc_vdev_data {
	36	u32 rsc_offset;
	37	unsigned int id;
	38	u32 index;
	39	struct fw_rsc_vdev *rsc;
	40	};
	41
49f27f2b PF	42	static inline bool rproc_has_feature(struct rproc *rproc, unsigned int feature)
	43	{
	44	return test_bit(feature, rproc->features);
	45	}
	46
	47	static inline int rproc_set_feature(struct rproc *rproc, unsigned int feature)
	48	{
	49	if (feature >= RPROC_MAX_FEATURES)
	50	return -EINVAL;
	51
	52	set_bit(feature, rproc->features);
	53
	54	return 0;
	55	}
	56
400e64df OBC	57	/* from remoteproc_core.c */
400e64df OBC	58	void rproc_release(struct kref *kref);
a8aa5ee1 SA	59	int rproc_of_parse_firmware(struct device *dev, int index,
a8aa5ee1 SA	60	const char **fw_name);
400e64df	61
7a186941	62	/* from remoteproc_virtio.c */
9c31255c	63	irqreturn_t rproc_vq_interrupt(struct rproc *rproc, int vq_id);
400e64df OBC	64
	65	/* from remoteproc_debugfs.c */
	66	void rproc_remove_trace_file(struct dentry *tfile);
	67	struct dentry rproc_create_trace_file(const char name, struct rproc *rproc,
a987e6b9	68	struct rproc_debug_trace *trace);
400e64df OBC	69	void rproc_delete_debug_dir(struct rproc *rproc);
	70	void rproc_create_debug_dir(struct rproc *rproc);
	71	void rproc_init_debugfs(void);
	72	void rproc_exit_debugfs(void);
	73
2aefbef0 MR	74	/* from remoteproc_sysfs.c */
	75	extern struct class rproc_class;
	76	int rproc_init_sysfs(void);
	77	void rproc_exit_sysfs(void);
	78
44767708 SG	79	#ifdef CONFIG_REMOTEPROC_CDEV
	80	void rproc_init_cdev(void);
	81	void rproc_exit_cdev(void);
	82	int rproc_char_device_add(struct rproc *rproc);
	83	void rproc_char_device_remove(struct rproc *rproc);
	84	#else
	85	static inline void rproc_init_cdev(void)
	86	{
	87	}
	88
	89	static inline void rproc_exit_cdev(void)
	90	{
	91	}
	92
	93	/*
	94	* The character device interface is an optional feature, if it is not enabled
	95	* the function should not return an error.
	96	*/
	97	static inline int rproc_char_device_add(struct rproc *rproc)
	98	{
	99	return 0;
	100	}
	101
	102	static inline void rproc_char_device_remove(struct rproc *rproc)
	103	{
	104	}
	105	#endif
	106
6db20ea8 OBC	107	void rproc_free_vring(struct rproc_vring *rvring);
6db20ea8 OBC	108	int rproc_alloc_vring(struct rproc_vdev *rvdev, int i);
9c31255c	109	int rproc_parse_vring(struct rproc_vdev rvdev, struct fw_rsc_vdev rsc, int i);
72854fb0	110
086d0872	111	phys_addr_t rproc_va_to_pa(void *cpu_addr);
70b85ef8	112	int rproc_trigger_recovery(struct rproc *rproc);
72854fb0	113
f31e339f	114	int rproc_elf_sanity_check(struct rproc rproc, const struct firmware fw);
e4ae4b7d	115	u64 rproc_elf_get_boot_addr(struct rproc rproc, const struct firmware fw);
0f21f9cc	116	int rproc_elf_load_segments(struct rproc rproc, const struct firmware fw);
58b64090	117	int rproc_elf_load_rsc_table(struct rproc rproc, const struct firmware fw);
0f21f9cc BA	118	struct resource_table rproc_elf_find_loaded_rsc_table(struct rproc rproc,
0f21f9cc BA	119	const struct firmware *fw);
c6aed238 LP	120	struct rproc_mem_entry *
c6aed238 LP	121	rproc_find_carveout_by_name(struct rproc rproc, const char name, ...);
9c31255c AP	122	void rproc_add_rvdev(struct rproc rproc, struct rproc_vdev rvdev);
9c31255c AP	123	void rproc_remove_rvdev(struct rproc_vdev *rvdev);
0f21f9cc	124
33467ac3 LP	125	static inline int rproc_prepare_device(struct rproc *rproc)
	126	{
	127	if (rproc->ops->prepare)
	128	return rproc->ops->prepare(rproc);
	129
	130	return 0;
	131	}
	132
	133	static inline int rproc_unprepare_device(struct rproc *rproc)
	134	{
	135	if (rproc->ops->unprepare)
	136	return rproc->ops->unprepare(rproc);
	137
	138	return 0;
	139	}
	140
a6a4f285 MP	141	static inline int rproc_attach_device(struct rproc *rproc)
	142	{
	143	if (rproc->ops->attach)
	144	return rproc->ops->attach(rproc);
	145
	146	return 0;
	147	}
	148
4afc89d6 SB	149	static inline
	150	int rproc_fw_sanity_check(struct rproc rproc, const struct firmware fw)
	151	{
0f21f9cc BA	152	if (rproc->ops->sanity_check)
0f21f9cc BA	153	return rproc->ops->sanity_check(rproc, fw);
4afc89d6 SB	154
	155	return 0;
	156	}
	157
	158	static inline
e4ae4b7d	159	u64 rproc_get_boot_addr(struct rproc rproc, const struct firmware fw)
4afc89d6	160	{
0f21f9cc BA	161	if (rproc->ops->get_boot_addr)
0f21f9cc BA	162	return rproc->ops->get_boot_addr(rproc, fw);
4afc89d6 SB	163
	164	return 0;
	165	}
	166
	167	static inline
	168	int rproc_load_segments(struct rproc rproc, const struct firmware fw)
	169	{
0f21f9cc BA	170	if (rproc->ops->load)
0f21f9cc BA	171	return rproc->ops->load(rproc, fw);
4afc89d6 SB	172
	173	return -EINVAL;
	174	}
	175
c1d35c1a	176	static inline int rproc_parse_fw(struct rproc rproc, const struct firmware fw)
4afc89d6	177	{
c1d35c1a BA	178	if (rproc->ops->parse_fw)
c1d35c1a BA	179	return rproc->ops->parse_fw(rproc, fw);
4afc89d6	180
58b64090	181	return 0;
4afc89d6 SB	182	}
4afc89d6 SB	183
b1a17513 CL	184	static inline
	185	int rproc_handle_rsc(struct rproc rproc, u32 rsc_type, void rsc, int offset,
	186	int avail)
	187	{
	188	if (rproc->ops->handle_rsc)
	189	return rproc->ops->handle_rsc(rproc, rsc_type, rsc, offset,
	190	avail);
	191
	192	return RSC_IGNORED;
	193	}
	194
95f95781 SB	195	static inline
95f95781 SB	196	struct resource_table rproc_find_loaded_rsc_table(struct rproc rproc,
730f84ce	197	const struct firmware *fw)
95f95781	198	{
0f21f9cc BA	199	if (rproc->ops->find_loaded_rsc_table)
0f21f9cc BA	200	return rproc->ops->find_loaded_rsc_table(rproc, fw);
95f95781	201
57971159	202	return NULL;
95f95781 SB	203	}
95f95781 SB	204
1a631382 MP	205	static inline
	206	struct resource_table rproc_get_loaded_rsc_table(struct rproc rproc,
	207	size_t *size)
	208	{
	209	if (rproc->ops->get_loaded_rsc_table)
	210	return rproc->ops->get_loaded_rsc_table(rproc, size);
	211
	212	return NULL;
	213	}
	214
f31e339f CL	215	static inline
	216	bool rproc_u64_fit_in_size_t(u64 val)
	217	{
	218	if (sizeof(size_t) == sizeof(u64))
	219	return true;
	220
	221	return (val <= (size_t) -1);
	222	}
	223
400e64df	224	#endif /* REMOTEPROC_INTERNAL_H */