Merge tag 'rpmsg-v4.10' of git://github.com/andersson/remoteproc (96128810) · Commits · 戴 / test

drivers/rpmsg/qcom_smd.c

+5 −12

Original line number	Original line	Diff line number	Diff line
	@@ -740,7 +740,7 @@ static int __qcom_smd_send(struct qcom_smd_channel channel, const void data,

	while (qcom_smd_get_tx_avail(channel) < tlen) {		while (qcom_smd_get_tx_avail(channel) < tlen) {
	if (!wait) {		if (!wait) {
	ret = -ENOMEM;		ret = -EAGAIN;
	goto out;		goto out;
	}		}

	@@ -821,21 +821,14 @@ qcom_smd_find_channel(struct qcom_smd_edge edge, const char name)
	struct qcom_smd_channel *channel;		struct qcom_smd_channel *channel;
	struct qcom_smd_channel *ret = NULL;		struct qcom_smd_channel *ret = NULL;
	unsigned long flags;		unsigned long flags;
	unsigned state;

	spin_lock_irqsave(&edge->channels_lock, flags);		spin_lock_irqsave(&edge->channels_lock, flags);
	list_for_each_entry(channel, &edge->channels, list) {		list_for_each_entry(channel, &edge->channels, list) {
	if (strcmp(channel->name, name))		if (!strcmp(channel->name, name)) {
	continue;

	state = GET_RX_CHANNEL_INFO(channel, state);
	if (state != SMD_CHANNEL_OPENING &&
	state != SMD_CHANNEL_OPENED)
	continue;

	ret = channel;		ret = channel;
	break;		break;
	}		}
			}
	spin_unlock_irqrestore(&edge->channels_lock, flags);		spin_unlock_irqrestore(&edge->channels_lock, flags);

	return ret;		return ret;

drivers/rpmsg/rpmsg_core.c

+58 −16

Original line number	Original line	Diff line number	Diff line
	@@ -71,6 +71,9 @@ struct rpmsg_endpoint rpmsg_create_ept(struct rpmsg_device rpdev,
	rpmsg_rx_cb_t cb, void *priv,		rpmsg_rx_cb_t cb, void *priv,
	struct rpmsg_channel_info chinfo)		struct rpmsg_channel_info chinfo)
	{		{
			if (WARN_ON(!rpdev))
			return ERR_PTR(-EINVAL);

	return rpdev->ops->create_ept(rpdev, cb, priv, chinfo);		return rpdev->ops->create_ept(rpdev, cb, priv, chinfo);
	}		}
	EXPORT_SYMBOL(rpmsg_create_ept);		EXPORT_SYMBOL(rpmsg_create_ept);
	@@ -80,10 +83,12 @@ EXPORT_SYMBOL(rpmsg_create_ept);
	* @ept: endpoing to destroy		* @ept: endpoing to destroy
	*		*
	* Should be used by drivers to destroy an rpmsg endpoint previously		* Should be used by drivers to destroy an rpmsg endpoint previously
	* created with rpmsg_create_ept().		* created with rpmsg_create_ept(). As with other types of "free" NULL
			* is a valid parameter.
	*/		*/
	void rpmsg_destroy_ept(struct rpmsg_endpoint *ept)		void rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
	{		{
			if (ept)
	ept->ops->destroy_ept(ept);		ept->ops->destroy_ept(ept);
	}		}
	EXPORT_SYMBOL(rpmsg_destroy_ept);		EXPORT_SYMBOL(rpmsg_destroy_ept);
	@@ -108,6 +113,11 @@ EXPORT_SYMBOL(rpmsg_destroy_ept);
	*/		*/
	int rpmsg_send(struct rpmsg_endpoint ept, void data, int len)		int rpmsg_send(struct rpmsg_endpoint ept, void data, int len)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->send)
			return -ENXIO;

	return ept->ops->send(ept, data, len);		return ept->ops->send(ept, data, len);
	}		}
	EXPORT_SYMBOL(rpmsg_send);		EXPORT_SYMBOL(rpmsg_send);
	@@ -132,6 +142,11 @@ EXPORT_SYMBOL(rpmsg_send);
	*/		*/
	int rpmsg_sendto(struct rpmsg_endpoint ept, void data, int len, u32 dst)		int rpmsg_sendto(struct rpmsg_endpoint ept, void data, int len, u32 dst)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->sendto)
			return -ENXIO;

	return ept->ops->sendto(ept, data, len, dst);		return ept->ops->sendto(ept, data, len, dst);
	}		}
	EXPORT_SYMBOL(rpmsg_sendto);		EXPORT_SYMBOL(rpmsg_sendto);
	@@ -159,6 +174,11 @@ EXPORT_SYMBOL(rpmsg_sendto);
	int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,		int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
	void *data, int len)		void *data, int len)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->send_offchannel)
			return -ENXIO;

	return ept->ops->send_offchannel(ept, src, dst, data, len);		return ept->ops->send_offchannel(ept, src, dst, data, len);
	}		}
	EXPORT_SYMBOL(rpmsg_send_offchannel);		EXPORT_SYMBOL(rpmsg_send_offchannel);
	@@ -182,6 +202,11 @@ EXPORT_SYMBOL(rpmsg_send_offchannel);
	*/		*/
	int rpmsg_trysend(struct rpmsg_endpoint ept, void data, int len)		int rpmsg_trysend(struct rpmsg_endpoint ept, void data, int len)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->trysend)
			return -ENXIO;

	return ept->ops->trysend(ept, data, len);		return ept->ops->trysend(ept, data, len);
	}		}
	EXPORT_SYMBOL(rpmsg_trysend);		EXPORT_SYMBOL(rpmsg_trysend);
	@@ -205,6 +230,11 @@ EXPORT_SYMBOL(rpmsg_trysend);
	*/		*/
	int rpmsg_trysendto(struct rpmsg_endpoint ept, void data, int len, u32 dst)		int rpmsg_trysendto(struct rpmsg_endpoint ept, void data, int len, u32 dst)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->trysendto)
			return -ENXIO;

	return ept->ops->trysendto(ept, data, len, dst);		return ept->ops->trysendto(ept, data, len, dst);
	}		}
	EXPORT_SYMBOL(rpmsg_trysendto);		EXPORT_SYMBOL(rpmsg_trysendto);
	@@ -231,6 +261,11 @@ EXPORT_SYMBOL(rpmsg_trysendto);
	int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,		int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
	void *data, int len)		void *data, int len)
	{		{
			if (WARN_ON(!ept))
			return -EINVAL;
			if (!ept->ops->trysend_offchannel)
			return -ENXIO;

	return ept->ops->trysend_offchannel(ept, src, dst, data, len);		return ept->ops->trysend_offchannel(ept, src, dst, data, len);
	}		}
	EXPORT_SYMBOL(rpmsg_trysend_offchannel);		EXPORT_SYMBOL(rpmsg_trysend_offchannel);
	@@ -315,6 +350,9 @@ static int rpmsg_dev_match(struct device dev, struct device_driver drv)
	const struct rpmsg_device_id *ids = rpdrv->id_table;		const struct rpmsg_device_id *ids = rpdrv->id_table;
	unsigned int i;		unsigned int i;

			if (rpdev->driver_override)
			return !strcmp(rpdev->driver_override, drv->name);

	if (ids)		if (ids)
	for (i = 0; ids[i].name[0]; i++)		for (i = 0; ids[i].name[0]; i++)
	if (rpmsg_id_match(rpdev, &ids[i]))		if (rpmsg_id_match(rpdev, &ids[i]))
	@@ -344,9 +382,10 @@ static int rpmsg_dev_probe(struct device *dev)
	struct rpmsg_device *rpdev = to_rpmsg_device(dev);		struct rpmsg_device *rpdev = to_rpmsg_device(dev);
	struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver);		struct rpmsg_driver *rpdrv = to_rpmsg_driver(rpdev->dev.driver);
	struct rpmsg_channel_info chinfo = {};		struct rpmsg_channel_info chinfo = {};
	struct rpmsg_endpoint *ept;		struct rpmsg_endpoint *ept = NULL;
	int err;		int err;

			if (rpdrv->callback) {
	strncpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE);		strncpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE);
	chinfo.src = rpdev->src;		chinfo.src = rpdev->src;
	chinfo.dst = RPMSG_ADDR_ANY;		chinfo.dst = RPMSG_ADDR_ANY;
	@@ -360,10 +399,12 @@ static int rpmsg_dev_probe(struct device *dev)

	rpdev->ept = ept;		rpdev->ept = ept;
	rpdev->src = ept->addr;		rpdev->src = ept->addr;
			}

	err = rpdrv->probe(rpdev);		err = rpdrv->probe(rpdev);
	if (err) {		if (err) {
	dev_err(dev, "%s: failed: %d\n", __func__, err);		dev_err(dev, "%s: failed: %d\n", __func__, err);
			if (ept)
	rpmsg_destroy_ept(ept);		rpmsg_destroy_ept(ept);
	goto out;		goto out;
	}		}
	@@ -385,6 +426,7 @@ static int rpmsg_dev_remove(struct device *dev)

	rpdrv->remove(rpdev);		rpdrv->remove(rpdev);

			if (rpdev->ept)
	rpmsg_destroy_ept(rpdev->ept);		rpmsg_destroy_ept(rpdev->ept);

	return err;		return err;

include/linux/rpmsg.h

+115 −10

Original line number	Original line	Diff line number	Diff line
	@@ -37,6 +37,7 @@

	#include <linux/types.h>		#include <linux/types.h>
	#include <linux/device.h>		#include <linux/device.h>
			#include <linux/err.h>
	#include <linux/mod_devicetable.h>		#include <linux/mod_devicetable.h>
	#include <linux/kref.h>		#include <linux/kref.h>
	#include <linux/mutex.h>		#include <linux/mutex.h>
	@@ -64,6 +65,7 @@ struct rpmsg_channel_info {
	* rpmsg_device - device that belong to the rpmsg bus		* rpmsg_device - device that belong to the rpmsg bus
	* @dev: the device struct		* @dev: the device struct
	* @id: device id (used to match between rpmsg drivers and devices)		* @id: device id (used to match between rpmsg drivers and devices)
			* @driver_override: driver name to force a match
	* @src: local address		* @src: local address
	* @dst: destination address		* @dst: destination address
	* @ept: the rpmsg endpoint of this channel		* @ept: the rpmsg endpoint of this channel
	@@ -72,6 +74,7 @@ struct rpmsg_channel_info {
	struct rpmsg_device {		struct rpmsg_device {
	struct device dev;		struct device dev;
	struct rpmsg_device_id id;		struct rpmsg_device_id id;
			char *driver_override;
	u32 src;		u32 src;
	u32 dst;		u32 dst;
	struct rpmsg_endpoint *ept;		struct rpmsg_endpoint *ept;
	@@ -132,6 +135,8 @@ struct rpmsg_driver {
	int (callback)(struct rpmsg_device , void , int, void , u32);		int (callback)(struct rpmsg_device , void , int, void , u32);
	};		};

			#if IS_ENABLED(CONFIG_RPMSG)

	int register_rpmsg_device(struct rpmsg_device *dev);		int register_rpmsg_device(struct rpmsg_device *dev);
	void unregister_rpmsg_device(struct rpmsg_device *dev);		void unregister_rpmsg_device(struct rpmsg_device *dev);
	int __register_rpmsg_driver(struct rpmsg_driver drv, struct module owner);		int __register_rpmsg_driver(struct rpmsg_driver drv, struct module owner);
	@@ -141,6 +146,116 @@ struct rpmsg_endpoint rpmsg_create_ept(struct rpmsg_device ,
	rpmsg_rx_cb_t cb, void *priv,		rpmsg_rx_cb_t cb, void *priv,
	struct rpmsg_channel_info chinfo);		struct rpmsg_channel_info chinfo);

			int rpmsg_send(struct rpmsg_endpoint ept, void data, int len);
			int rpmsg_sendto(struct rpmsg_endpoint ept, void data, int len, u32 dst);
			int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
			void *data, int len);

			int rpmsg_trysend(struct rpmsg_endpoint ept, void data, int len);
			int rpmsg_trysendto(struct rpmsg_endpoint ept, void data, int len, u32 dst);
			int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
			void *data, int len);

			#else

			static inline int register_rpmsg_device(struct rpmsg_device *dev)
			{
			return -ENXIO;
			}

			static inline void unregister_rpmsg_device(struct rpmsg_device *dev)
			{
			/* This shouldn't be possible */
			WARN_ON(1);
			}

			static inline int __register_rpmsg_driver(struct rpmsg_driver *drv,
			struct module *owner)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			static inline void unregister_rpmsg_driver(struct rpmsg_driver *drv)
			{
			/* This shouldn't be possible */
			WARN_ON(1);
			}

			static inline void rpmsg_destroy_ept(struct rpmsg_endpoint *ept)
			{
			/* This shouldn't be possible */
			WARN_ON(1);
			}

			static inline struct rpmsg_endpoint rpmsg_create_ept(struct rpmsg_device rpdev,
			rpmsg_rx_cb_t cb,
			void *priv,
			struct rpmsg_channel_info chinfo)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return ERR_PTR(-ENXIO);
			}

			static inline int rpmsg_send(struct rpmsg_endpoint ept, void data, int len)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			static inline int rpmsg_sendto(struct rpmsg_endpoint ept, void data, int len,
			u32 dst)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;

			}

			static inline int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src,
			u32 dst, void *data, int len)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			static inline int rpmsg_trysend(struct rpmsg_endpoint ept, void data, int len)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			static inline int rpmsg_trysendto(struct rpmsg_endpoint ept, void data,
			int len, u32 dst)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			static inline int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src,
			u32 dst, void *data, int len)
			{
			/* This shouldn't be possible */
			WARN_ON(1);

			return -ENXIO;
			}

			#endif /* IS_ENABLED(CONFIG_RPMSG) */

	/* use a macro to avoid include chaining to get THIS_MODULE */		/* use a macro to avoid include chaining to get THIS_MODULE */
	#define register_rpmsg_driver(drv) \		#define register_rpmsg_driver(drv) \
	__register_rpmsg_driver(drv, THIS_MODULE)		__register_rpmsg_driver(drv, THIS_MODULE)
	@@ -157,14 +272,4 @@ struct rpmsg_endpoint rpmsg_create_ept(struct rpmsg_device ,
	module_driver(__rpmsg_driver, register_rpmsg_driver, \		module_driver(__rpmsg_driver, register_rpmsg_driver, \
	unregister_rpmsg_driver)		unregister_rpmsg_driver)

	int rpmsg_send(struct rpmsg_endpoint ept, void data, int len);
	int rpmsg_sendto(struct rpmsg_endpoint ept, void data, int len, u32 dst);
	int rpmsg_send_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
	void *data, int len);

	int rpmsg_trysend(struct rpmsg_endpoint ept, void data, int len);
	int rpmsg_trysendto(struct rpmsg_endpoint ept, void data, int len, u32 dst);
	int rpmsg_trysend_offchannel(struct rpmsg_endpoint *ept, u32 src, u32 dst,
	void *data, int len);

	#endif /* _LINUX_RPMSG_H */		#endif /* _LINUX_RPMSG_H */

Admin message