remoteproc: qcom: Add callbacks for remoteproc events
v2 cover remoteproc: qcom: Add callbacks for remoteproc events
This patch series adds the usecases for SSR and Sysmon subdevices which are used by remoteprocs and kernel client drivers relying on those remoteprocs.
Patch 1-3 adds callbacks for prepare, start and unprepare events, and also type
of sysmon notification.
Patch 4-6 adds a per subsystem notifier chain, callbacks for prepare, start
and stop events for ssr subdevice.
Changes since v1:
- Patch 3 updated to add comments and check for sysmon ssctl_version, and updated commit text based on Mathieu's comments [1].
[1]: https://lkml.org/lkml/2020/2/27/1802
Rishabh Bhatnagar (1):
remoteproc: qcom: Add name field for every subdevice
Siddharth Gupta (5):
remoteproc: sysmon: Add ability to send type of notification
remoteproc: sysmon: Add notifications for events
remoteproc: sysmon: Inform current rproc about all active rprocs
remoteproc: qcom: Add per subsystem SSR notification
remoteproc: qcom: Add notification types to SSR
drivers/remoteproc/qcom_common.c | 86 +++++++++++++++++++++---- drivers/remoteproc/qcom_common.h | 1 + drivers/remoteproc/qcom_sysmon.c | 116 +++++++++++++++++++++++++++++----- drivers/soc/qcom/glink_ssr.c | 20 +++++- include/linux/remoteproc.h | 17 +++++ include/linux/remoteproc/qcom_rproc.h | 17 +++-- 6 files changed, 222 insertions(+), 35 deletions(-)
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 2/6 remoteproc: sysmon: Add notifications for events
Add notification for other stages of remoteproc boot and shutdown. This includes adding callback functions for the prepare and unprepare events, and fleshing out the callback function for start.
--- drivers/remoteproc/qcom_sysmon.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)
drivers/remoteproc/qcom_sysmon.c +37 -0
@@ -439,8 +439,31 @@ static const struct qmi_ops ssctl_ops = { .del_server = ssctl_del_server, }; +static int sysmon_prepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); + +return 0 ; +} +static int sysmon_start (struct rproc_subdev *subdev) { + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +return 0 ; }
@@ -464,6 +487,18 @@ static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)sysmon_request_shutdown (sysmon); } +static void sysmon_unprepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_SHUTDOWN + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +} +/** * sysmon_notify() - notify sysmon target of another's SSR * @nb: notifier_block associated with sysmon instance
@@ -563,8 +598,10 @@ struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,qmi_add_lookup (&sysmon->qmi,43 ,0 ,0 ); + sysmon->subdev.prepare = sysmon_prepare; sysmon->subdev.start = sysmon_start; sysmon->subdev.stop = sysmon_stop; + sysmon->subdev.unprepare = sysmon_unprepare;rproc_add_subdev (rproc, &sysmon->subdev);
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 3/6 remoteproc: sysmon: Inform current rproc about all active rprocs
In reply to Siddharth GuptaClients/services running on a remoteproc that booted up might need to be aware of the state of already running remoteprocs. When a remoteproc boots up (fresh or after recovery) it is not aware of the remoteprocs that booted before it, i.e., the system state is incomplete. So to keep track of it we send sysmon on behalf of all 'ONLINE' remoteprocs.
--- drivers/remoteproc/qcom_sysmon.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)
drivers/remoteproc/qcom_sysmon.c +25 -0
@@ -453,10 +453,20 @@ static int sysmon_prepare(struct rproc_subdev *subdev)return 0 ; } +/** +* sysmon_start() - start callback for the sysmon remoteproc subdevice +* @subdev: instance of the sysmon subdevice +* +* Inform all the listners of sysmon notifications that the rproc associated +* to @subdev has booted up. The rproc that booted up also needs to know +* which rprocs are already up and running, so send start notifications +* on behalf of all the online rprocs. +*/ static int sysmon_start (struct rproc_subdev *subdev) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct qcom_sysmon *target;struct sysmon_event event = { .subsys_name = sysmon->name, .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP
@@ -464,6 +474,21 @@ static int sysmon_start(struct rproc_subdev *subdev)blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +mutex_lock (&sysmon_lock); +list_for_each_entry (target, &sysmon_list, node) { +if (target == sysmon || + target->rproc->state !=RPROC_RUNNING ) +continue ; + + event.subsys_name = target->name; + +if (sysmon->ssctl_version ==2 ) +ssctl_send_event (sysmon, &event); +else if (sysmon->ept) +sysmon_send_event (sysmon, &event); + } +mutex_unlock (&sysmon_lock); +return 0 ; }
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 4/6 remoteproc: qcom: Add name field for every subdevice
In reply to Siddharth GuptaFrom: Rishabh Bhatnagar <[email protected]>
When a client driver wishes to utilize functionality from a particular subdevice of a remoteproc, it cannot differentiate between the subdevices that have been added. This patch allows the client driver to distinguish between subdevices and thus utilize their functionality.
--- drivers/remoteproc/qcom_common.c | 6 ++++++ include/linux/remoteproc.h | 2 ++ 2 files changed, 8 insertions(+)
drivers/remoteproc/qcom_common.c +6 -0
@@ -56,6 +56,7 @@ void qcom_add_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glink)return ; glink->dev = dev; + glink->subdev.name =kstrdup ("glink" ,GFP_KERNEL ); glink->subdev.start = glink_subdev_start; glink->subdev.stop = glink_subdev_stop;
@@ -73,6 +74,7 @@ void qcom_remove_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glinif (!glink->node)return ; +kfree (glink->subdev.name);rproc_remove_subdev (rproc, &glink->subdev);of_node_put (glink->node); }
@@ -152,6 +154,7 @@ void qcom_add_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)return ; smd->dev = dev; + smd->subdev.name =kstrdup ("smd" ,GFP_KERNEL ); smd->subdev.start = smd_subdev_start; smd->subdev.stop = smd_subdev_stop;
@@ -169,6 +172,7 @@ void qcom_remove_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)if (!smd->node)return ; +kfree (smd->subdev.name);rproc_remove_subdev (rproc, &smd->subdev);of_node_put (smd->node); }
@@ -220,6 +224,7 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, const char *ssr_name) { ssr->name = ssr_name; + ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare;rproc_add_subdev (rproc, &ssr->subdev);
@@ -233,6 +238,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);*/ void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) { +kfree (ssr->subdev.name);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);
include/linux/remoteproc.h +2 -0
@@ -523,6 +523,7 @@ struct rproc {/** * struct rproc_subdev - subdevice tied to a remoteproc * @node: list node related to the rproc subdevs list +* @name: name of the subdevice * @prepare: prepare function, called before the rproc is started * @start: start function, called after the rproc has been started * @stop: stop function, called before the rproc is stopped; the @crashed
@@ -531,6 +532,7 @@ struct rproc {*/ struct rproc_subdev {struct list_head node; +char *name;int (*prepare)(struct rproc_subdev *subdev);int (*start)(struct rproc_subdev *subdev);
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 5/6 remoteproc: qcom: Add per subsystem SSR notification
In reply to Siddharth GuptaCurrently there is a global notification chain which is called whenever any remoteproc shuts down. This leads to all the listeners being notified, and is not an optimal design as kernel drivers might only be interested in listening to notifications from a particular remoteproc. Create an individual notifier chain for every SSR subdevice, and modify the notification registration API to include the remoteproc struct as an argument. Update the existing user of the registration API to get the phandle of the remoteproc dt node to register for SSR notifications.
--- drivers/remoteproc/qcom_common.c | 49 +++++++++++++++++++++++++++-------- drivers/remoteproc/qcom_common.h | 1 + drivers/soc/qcom/glink_ssr.c | 20 ++++++++++++-- include/linux/remoteproc/qcom_rproc.h | 17 ++++++++---- 4 files changed, 69 insertions(+), 18 deletions(-)
drivers/remoteproc/qcom_common.c +38 -11
@@ -23,8 +23,6 @@#define to_smd_subdev (d) container_of(d, struct qcom_rproc_subdev, subdev)#define to_ssr_subdev (d) container_of(d, struct qcom_rproc_ssr, subdev) -static BLOCKING_NOTIFIER_HEAD (ssr_notifiers); -static int glink_subdev_start (struct rproc_subdev *subdev) {struct qcom_rproc_glink *glink =to_glink_subdev (subdev);
@@ -180,27 +178,52 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);/** * qcom_register_ssr_notifier() - register SSR notification handler +* @rproc: pointer to the remoteproc structure * @nb: notifier_block to notify for restart notifications * -* Returns 0 on success, negative errno on failure. +* Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This register the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the SSR -* name passed as a parameter. +* This registers the @notify function as handler for restart notifications. As +* remote processors are stopped this function will be called, with the rproc +* pointer passed as a parameter. */ -int qcom_register_ssr_notifier (struct notifier_block *nb) +void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) { -return blocking_notifier_chain_register (&ssr_notifiers, nb); +struct rproc_subdev *subdev; +struct qcom_rproc_ssr *ssr; +int ret; + +if (!rproc) +return ERR_PTR (-EINVAL ); + +mutex_lock (&rproc->lock); +list_for_each_entry (subdev, &rproc->subdevs, node) { + ret =strcmp (subdev->name,"ssr_notifs" ); +if (!ret) +break ; + } +mutex_unlock (&rproc->lock); +if (ret) +return ERR_PTR (-ENOENT ); + + ssr =to_ssr_subdev (subdev); +srcu_notifier_chain_register (ssr->rproc_notif_list, nb); + +return ssr->rproc_notif_list; }EXPORT_SYMBOL_GPL (qcom_register_ssr_notifier);/** * qcom_unregister_ssr_notifier() - unregister SSR notification handler +* @notify: pointer to srcu notifier head * @nb: notifier_block to unregister */ -void qcom_unregister_ssr_notifier (struct notifier_block *nb) +int qcom_unregister_ssr_notifier (void *notify,struct notifier_block *nb) { -blocking_notifier_chain_unregister (&ssr_notifiers, nb); +if (!notify) +return -EINVAL ; + +return srcu_notifier_chain_unregister (notify, nb); }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier);
@@ -208,7 +231,7 @@ static void ssr_notify_unprepare(struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -blocking_notifier_call_chain (&ssr_notifiers,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); }/**
@@ -226,6 +249,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare; + ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ), +GFP_KERNEL ); +srcu_init_notifier_head (ssr->rproc_notif_list);rproc_add_subdev (rproc, &ssr->subdev); }
@@ -239,6 +265,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) {kfree (ssr->subdev.name); +kfree (ssr->rproc_notif_list);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);
drivers/remoteproc/qcom_common.h +1 -0
@@ -27,6 +27,7 @@ struct qcom_rproc_subdev {struct qcom_rproc_ssr {struct rproc_subdev subdev; +struct srcu_notifier_head *rproc_notif_list;const char *name; };
drivers/soc/qcom/glink_ssr.c +18 -2
@@ -7,6 +7,7 @@#include <linux/completion.h> #include <linux/module.h> #include <linux/notifier.h> +#include <linux/remoteproc.h> #include <linux/rpmsg.h> #include <linux/remoteproc/qcom_rproc.h>
@@ -49,6 +50,7 @@ struct glink_ssr {struct rpmsg_endpoint *ept;struct notifier_block nb; +void *notifier_head;u32 seq_num;struct completion completion;
@@ -112,6 +114,7 @@ static int qcom_glink_ssr_notify(struct notifier_block *nb, unsigned long event,static int qcom_glink_ssr_probe (struct rpmsg_device *rpdev) {struct glink_ssr *ssr; +struct rproc *rproc; ssr =devm_kzalloc (&rpdev->dev,sizeof (*ssr),GFP_KERNEL );if (!ssr)
@@ -125,14 +128,27 @@ static int qcom_glink_ssr_probe(struct rpmsg_device *rpdev)dev_set_drvdata (&rpdev->dev, ssr); -return qcom_register_ssr_notifier (&ssr->nb); + rproc =rproc_get_by_child (&rpdev->dev); +if (!rproc) { +dev_err (&rpdev->dev,"glink device not child of rproc\n" ); +return -EINVAL ; + } + + ssr->notifier_head =qcom_register_ssr_notifier (rproc, &ssr->nb); +if (IS_ERR (ssr->notifier_head)) { +dev_err (&rpdev->dev, +"failed to register for ssr notifications\n" ); +return PTR_ERR (ssr->notifier_head); + } + +return 0 ; }static void qcom_glink_ssr_remove (struct rpmsg_device *rpdev) {struct glink_ssr *ssr =dev_get_drvdata (&rpdev->dev); -qcom_unregister_ssr_notifier (&ssr->nb); +qcom_unregister_ssr_notifier (ssr->notifier_head, &ssr->nb); }static const struct rpmsg_device_id qcom_glink_ssr_match[] = {
include/linux/remoteproc/qcom_rproc.h +12 -5
@@ -2,20 +2,27 @@#define __QCOM_RPROC_H__struct notifier_block ; +struct rproc ;#if IS_ENABLED (CONFIG_QCOM_RPROC_COMMON ) -int qcom_register_ssr_notifier (struct notifier_block *nb); -void qcom_unregister_ssr_notifier (struct notifier_block *nb); +void *qcom_register_ssr_notifier (struct rproc *rproc, +struct notifier_block *nb); +int qcom_unregister_ssr_notifier (void *notify,struct notifier_block *nb);#else -static inline int qcom_register_ssr_notifier (struct notifier_block *nb) +static inline void *qcom_register_ssr_notifier (struct rproc *rproc, +struct notifier_block *nb) { -return 0 ; +return NULL ; } -static inline void qcom_unregister_ssr_notifier (struct notifier_block *nb) {} +static inline int qcom_unregister_ssr_notifier (void *notify, +struct notifier_block *nb) +{ +return 0 ; +}#endif
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 6/6 remoteproc: qcom: Add notification types to SSR
In reply to Siddharth GuptaThe SSR subdevice only adds callback for the unprepare event. Add callbacks for unprepare, start and prepare events. The client driver for a particular remoteproc might be interested in knowing the status of the remoteproc while undergoing SSR, not just when the remoteproc has finished shutting down.
--- drivers/remoteproc/qcom_common.c | 39 +++++++++++++++++++++++++++++++++++---- include/linux/remoteproc.h | 15 +++++++++++++++ 2 files changed, 50 insertions(+), 4 deletions(-)
drivers/remoteproc/qcom_common.c +35 -4
@@ -183,9 +183,9 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);* * Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This registers the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the rproc -* pointer passed as a parameter. +* This registers the @notify function as handler for powerup/shutdown +* notifications. This function will be invoked inside the callbacks registered +* for the ssr subdevice, with the rproc pointer passed as a parameter. */ void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) {
@@ -227,11 +227,39 @@ int qcom_unregister_ssr_notifier(void *notify, struct notifier_block *nb) }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier); +static int ssr_notify_prepare (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_POWERUP , (void *)ssr->name); +return 0 ; +} + +static int ssr_notify_start (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_POWERUP , (void *)ssr->name); +return 0 ; +} + +static void ssr_notify_stop (struct rproc_subdev *subdev,bool crashed) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_SHUTDOWN , (void *)ssr->name); +} + +static void ssr_notify_unprepare (struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_SHUTDOWN , (void *)ssr->name); }/**
@@ -248,6 +276,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, { ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); + ssr->subdev.prepare = ssr_notify_prepare; + ssr->subdev.start = ssr_notify_start; + ssr->subdev.stop = ssr_notify_stop; ssr->subdev.unprepare = ssr_notify_unprepare; ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ),GFP_KERNEL );
include/linux/remoteproc.h +15 -0
@@ -452,6 +452,21 @@ struct rproc_dump_segment { };/** +* enum rproc_notif_type - Different stages of remoteproc notifications +* @RPROC_BEFORE_SHUTDOWN: unprepare stage of remoteproc +* @RPROC_AFTER_SHUTDOWN: stop stage of remoteproc +* @RPROC_BEFORE_POWERUP: prepare stage of remoteproc +* @RPROC_AFTER_POWERUP: start stage of remoteproc +*/ +enum rproc_notif_type { +RPROC_BEFORE_SHUTDOWN , +RPROC_AFTER_SHUTDOWN , +RPROC_BEFORE_POWERUP , +RPROC_AFTER_POWERUP , +RPROC_MAX +}; + +/** * struct rproc - represents a physical remote processor device * @node: list node of this rproc object * @domain: iommu domain
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
PATCH v2 1/6 remoteproc: sysmon: Add ability to send type of notification
In reply to Siddharth GuptaCurrent implementation of the sysmon driver does not support adding notifications for other remoteproc events - prepare, start, unprepare. Clients on the remoteproc side might be interested in knowing when a remoteproc boots up. This change adds the ability to send the notification type along with the name. For example, audio DSP is interested in knowing when modem has crashed so that it can perform cleanup and wait for modem to boot up before it starts processing data again.
--- drivers/remoteproc/qcom_sysmon.c | 54 +++++++++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 17 deletions(-)
drivers/remoteproc/qcom_sysmon.c +37 -17
@@ -46,6 +46,25 @@ struct qcom_sysmon {struct sockaddr_qrtr ssctl; }; +enum { +SSCTL_SSR_EVENT_BEFORE_POWERUP , +SSCTL_SSR_EVENT_AFTER_POWERUP , +SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , +SSCTL_SSR_EVENT_AFTER_SHUTDOWN , +}; + +static const char *const sysmon_state_string[] = { + [SSCTL_SSR_EVENT_BEFORE_POWERUP ] ="before_powerup" , + [SSCTL_SSR_EVENT_AFTER_POWERUP ] ="after_powerup" , + [SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ] ="before_shutdown" , + [SSCTL_SSR_EVENT_AFTER_SHUTDOWN ] ="after_shutdown" , +}; + +struct sysmon_event { +const char *subsys_name; +u32 ssr_event; +}; +static DEFINE_MUTEX (sysmon_lock);static LIST_HEAD (sysmon_list);
@@ -54,13 +73,15 @@ static LIST_HEAD(sysmon_list);* @sysmon: sysmon context * @name: other remote's name */ -static void sysmon_send_event (struct qcom_sysmon *sysmon,const char *name) +static void sysmon_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {char req[50 ];int len;int ret; - len =snprintf (req,sizeof (req),"ssr:%s:before_shutdown" , name); + len =snprintf (req,sizeof (req),"ssr:%s:%s" , event->subsys_name, + sysmon_state_string[event->ssr_event]);if (len >=sizeof (req))return ;
@@ -149,13 +170,6 @@ static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,#define SSCTL_SUBSYS_NAME_LENGTH 15enum { -SSCTL_SSR_EVENT_BEFORE_POWERUP , -SSCTL_SSR_EVENT_AFTER_POWERUP , -SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , -SSCTL_SSR_EVENT_AFTER_SHUTDOWN , -}; - -enum {SSCTL_SSR_EVENT_FORCED ,SSCTL_SSR_EVENT_GRACEFUL , };
@@ -331,7 +345,8 @@ static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)* @sysmon: sysmon context * @name: other remote's name */ -static void ssctl_send_event (struct qcom_sysmon *sysmon,const char *name) +static void ssctl_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {struct ssctl_subsys_event_resp resp;struct ssctl_subsys_event_req req;
@@ -346,9 +361,9 @@ static void ssctl_send_event(struct qcom_sysmon *sysmon, const char *name) }memset (&req,0 ,sizeof (req)); -strlcpy (req.subsys_name, name,sizeof (req.subsys_name)); +strlcpy (req.subsys_name, event->subsys_name,sizeof (req.subsys_name)); req.subsys_name_len =strlen (req.subsys_name); - req.event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ; + req.event = event->ssr_event; req.evt_driven_valid = true; req.evt_driven =SSCTL_SSR_EVENT_FORCED ;
@@ -432,8 +447,12 @@ static int sysmon_start(struct rproc_subdev *subdev)static void sysmon_stop (struct rproc_subdev *subdev,bool crashed) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN + }; -blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)sysmon->name); +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event);/* Don't request graceful shutdown if we've crashed */ if (crashed)
@@ -456,19 +475,20 @@ static int sysmon_notify(struct notifier_block *nb, unsigned long event, { struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);struct rproc *rproc = sysmon->rproc; -const char *ssr_name = data; +struct sysmon_event *sysmon_event = data;/* Skip non-running rprocs and the originating instance */ -if (rproc->state !=RPROC_RUNNING || !strcmp (data, sysmon->name)) { +if (rproc->state !=RPROC_RUNNING || + !strcmp (sysmon_event->subsys_name, sysmon->name)) {dev_dbg (sysmon->dev,"not notifying %s\n" , sysmon->name);return NOTIFY_DONE ; }/* Only SSCTL version 2 supports SSR events */ if (sysmon->ssctl_version ==2 ) -ssctl_send_event (sysmon, ssr_name); +ssctl_send_event (sysmon, sysmon_event);else if (sysmon->ept) -sysmon_send_event (sysmon, ssr_name); +sysmon_send_event (sysmon, sysmon_event);return NOTIFY_DONE ; }
Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 1/6] remoteproc: sysmon: Add ability to send type of notification
Quoted 9 lines · Siddharth Gupta
Current implementation of the sysmon driver does not support adding notifications for other remoteproc events - prepare, start, unprepare. Clients on the remoteproc side might be interested in knowing when a remoteproc boots up. This change adds the ability to send the notification type along with the name. For example, audio DSP is interested in knowing when modem has crashed so that it can perform cleanup and wait for modem to boot up before it starts processing data again.
Signed-off-by Siddharth Gupta <[email protected]>
Quoted 130 lines
--- drivers/remoteproc/qcom_sysmon.c | 54 +++++++++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 17 deletions(-)drivers/remoteproc/qcom_sysmon.c +37
-17@@ -46,6 +46,25 @@ struct qcom_sysmon {struct sockaddr_qrtr ssctl; }; +enum { +SSCTL_SSR_EVENT_BEFORE_POWERUP , +SSCTL_SSR_EVENT_AFTER_POWERUP , +SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , +SSCTL_SSR_EVENT_AFTER_SHUTDOWN , +}; + +static const char *const sysmon_state_string[] = { + [SSCTL_SSR_EVENT_BEFORE_POWERUP ] ="before_powerup" , + [SSCTL_SSR_EVENT_AFTER_POWERUP ] ="after_powerup" , + [SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ] ="before_shutdown" , + [SSCTL_SSR_EVENT_AFTER_SHUTDOWN ] ="after_shutdown" , +}; + +struct sysmon_event { +const char *subsys_name; +u32 ssr_event; +}; +static DEFINE_MUTEX (sysmon_lock);static LIST_HEAD (sysmon_list);@@ -54,13 +73,15 @@ static LIST_HEAD(sysmon_list);* @sysmon: sysmon context * @name: other remote's name */ -static void sysmon_send_event (struct qcom_sysmon *sysmon,const char *name) +static void sysmon_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {char req[50 ];int len;int ret; - len =snprintf (req,sizeof (req),"ssr:%s:before_shutdown" , name); + len =snprintf (req,sizeof (req),"ssr:%s:%s" , event->subsys_name, + sysmon_state_string[event->ssr_event]);if (len >=sizeof (req))return ;@@ -149,13 +170,6 @@ static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,#define SSCTL_SUBSYS_NAME_LENGTH 15enum { -SSCTL_SSR_EVENT_BEFORE_POWERUP , -SSCTL_SSR_EVENT_AFTER_POWERUP , -SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , -SSCTL_SSR_EVENT_AFTER_SHUTDOWN , -}; - -enum {SSCTL_SSR_EVENT_FORCED ,SSCTL_SSR_EVENT_GRACEFUL , };@@ -331,7 +345,8 @@ static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)* @sysmon: sysmon context * @name: other remote's name */ -static void ssctl_send_event (struct qcom_sysmon *sysmon,const char *name) +static void ssctl_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {struct ssctl_subsys_event_resp resp;struct ssctl_subsys_event_req req;@@ -346,9 +361,9 @@ static void ssctl_send_event(struct qcom_sysmon *sysmon, const char *name) }memset (&req,0 ,sizeof (req)); -strlcpy (req.subsys_name, name,sizeof (req.subsys_name)); +strlcpy (req.subsys_name, event->subsys_name,sizeof (req.subsys_name)); req.subsys_name_len =strlen (req.subsys_name); - req.event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ; + req.event = event->ssr_event; req.evt_driven_valid = true; req.evt_driven =SSCTL_SSR_EVENT_FORCED ;@@ -432,8 +447,12 @@ static int sysmon_start(struct rproc_subdev *subdev)static void sysmon_stop (struct rproc_subdev *subdev,bool crashed) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN + }; -blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)sysmon->name); +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event);/* Don't request graceful shutdown if we've crashed */ if (crashed)@@ -456,19 +475,20 @@ static int sysmon_notify(struct notifier_block *nb, unsigned long event, { struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);struct rproc *rproc = sysmon->rproc; -const char *ssr_name = data; +struct sysmon_event *sysmon_event = data;/* Skip non-running rprocs and the originating instance */ -if (rproc->state !=RPROC_RUNNING || !strcmp (data, sysmon->name)) { +if (rproc->state !=RPROC_RUNNING || + !strcmp (sysmon_event->subsys_name, sysmon->name)) {dev_dbg (sysmon->dev,"not notifying %s\n" , sysmon->name);return NOTIFY_DONE ; }/* Only SSCTL version 2 supports SSR events */ if (sysmon->ssctl_version ==2 ) -ssctl_send_event (sysmon, ssr_name); +ssctl_send_event (sysmon, sysmon_event);else if (sysmon->ept) -sysmon_send_event (sysmon, ssr_name); +sysmon_send_event (sysmon, sysmon_event);return NOTIFY_DONE ; }Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 2/6] remoteproc: sysmon: Add notifications for events
In reply to Siddharth GuptaQuoted 5 lines · Siddharth Gupta
Add notification for other stages of remoteproc boot and shutdown. This includes adding callback functions for the prepare and unprepare events, and fleshing out the callback function for start.
Signed-off-by Siddharth Gupta <[email protected]>
Quoted 73 lines
--- drivers/remoteproc/qcom_sysmon.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)drivers/remoteproc/qcom_sysmon.c +37
-0@@ -439,8 +439,31 @@ static const struct qmi_ops ssctl_ops = { .del_server = ssctl_del_server, }; +static int sysmon_prepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); + +return 0 ; +} +static int sysmon_start (struct rproc_subdev *subdev) { + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +return 0 ; }@@ -464,6 +487,18 @@ static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)sysmon_request_shutdown (sysmon); } +static void sysmon_unprepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_SHUTDOWN + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +} +/** * sysmon_notify() - notify sysmon target of another's SSR * @nb: notifier_block associated with sysmon instance @@ -563,8 +598,10 @@ struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,qmi_add_lookup (&sysmon->qmi,43 ,0 ,0 ); + sysmon->subdev.prepare = sysmon_prepare; sysmon->subdev.start = sysmon_start; sysmon->subdev.stop = sysmon_stop; + sysmon->subdev.unprepare = sysmon_unprepare;rproc_add_subdev (rproc, &sysmon->subdev);Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 3/6] remoteproc: sysmon: Inform current rproc about all active rprocs
In reply to Siddharth GuptaQuoted 45 lines · Siddharth Gupta
Clients/services running on a remoteproc that booted up might need to be aware of the state of already running remoteprocs. When a remoteproc boots up (fresh or after recovery) it is not aware of the remoteprocs that booted before it, i.e., the system state is incomplete. So to keep track of it we send sysmon on behalf of all 'ONLINE' remoteprocs.
Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_sysmon.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/remoteproc/qcom_sysmon.c +15
-0@@ -453,10 +453,20 @@ static int sysmon_prepare(struct rproc_subdev *subdev)return 0 ; } +/** +* sysmon_start() - start callback for the sysmon remoteproc subdevice +* @subdev: instance of the sysmon subdevice +* +* Inform all the listners of sysmon notifications that the rproc associated +* to @subdev has booted up. The rproc that booted up also needs to know +* which rprocs are already up and running, so send start notifications +* on behalf of all the online rprocs. +*/ static int sysmon_start (struct rproc_subdev *subdev) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct qcom_sysmon *target;struct sysmon_event event = { .subsys_name = sysmon->name, .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP @@ -464,6 +474,21 @@ static int sysmon_start(struct rproc_subdev *subdev)blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +mutex_lock (&sysmon_lock); +list_for_each_entry (target, &sysmon_list, node) { +if (target == sysmon || + target->rproc->state !=RPROC_RUNNING ) +continue ;
drivers/remoteproc/qcom_sysmon.c static int sysmon_start(struct rproc_subdev *subdev) · line 491
Quoted 10 lines
drivers/remoteproc/qcom_sysmon.c +10
-0+ + event.subsys_name = target->name; + +if (sysmon->ssctl_version ==2 ) +ssctl_send_event (sysmon, &event); +else if (sysmon->ept) +sysmon_send_event (sysmon, &event); + } +mutex_unlock (&sysmon_lock); +
Quoted 6 lines
drivers/remoteproc/qcom_sysmon.c +0
-0return 0 ; }Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 5/6] remoteproc: qcom: Add per subsystem SSR notification
In reply to Siddharth GuptaQuoted 45 lines · Siddharth Gupta
Currently there is a global notification chain which is called whenever any remoteproc shuts down. This leads to all the listeners being notified, and is not an optimal design as kernel drivers might only be interested in listening to notifications from a particular remoteproc. Create an individual notifier chain for every SSR subdevice, and modify the notification registration API to include the remoteproc struct as an argument. Update the existing user of the registration API to get the phandle of the remoteproc dt node to register for SSR notifications.
Signed-off-by Rishabh Bhatnagar <[email protected]>Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_common.c | 49 +++++++++++++++++++++++++++-------- drivers/remoteproc/qcom_common.h | 1 + drivers/soc/qcom/glink_ssr.c | 20 ++++++++++++-- include/linux/remoteproc/qcom_rproc.h | 17 ++++++++---- 4 files changed, 69 insertions(+), 18 deletions(-)drivers/remoteproc/qcom_common.c +3
-6@@ -23,8 +23,6 @@#define to_smd_subdev (d) container_of(d, struct qcom_rproc_subdev, subdev)#define to_ssr_subdev (d) container_of(d, struct qcom_rproc_ssr, subdev) -static BLOCKING_NOTIFIER_HEAD (ssr_notifiers); -static int glink_subdev_start (struct rproc_subdev *subdev) {struct qcom_rproc_glink *glink =to_glink_subdev (subdev);@@ -180,27 +178,52 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);/** * qcom_register_ssr_notifier() - register SSR notification handler +* @rproc: pointer to the remoteproc structure * @nb: notifier_block to notify for restart notifications * -* Returns 0 on success, negative errno on failure. +* Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This register the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the SSR -* name passed as a parameter. +* This registers the @notify function as handler for restart notifications. As
drivers/remoteproc/qcom_common.c EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev); · line 194
Quoted 10 lines
drivers/remoteproc/qcom_common.c +6
-2+* remote processors are stopped this function will be called, with the rproc +* pointer passed as a parameter. */ -int qcom_register_ssr_notifier (struct notifier_block *nb) +void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) { -return blocking_notifier_chain_register (&ssr_notifiers, nb); +struct rproc_subdev *subdev; +struct qcom_rproc_ssr *ssr; +int ret;
Variable 'ret' needs to be initalised to -ENOENT.
drivers/remoteproc/qcom_common.c EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev); · line 207
Quoted 13 lines
drivers/remoteproc/qcom_common.c +13
-0+ +if (!rproc) +return ERR_PTR (-EINVAL ); + +mutex_lock (&rproc->lock); +list_for_each_entry (subdev, &rproc->subdevs, node) { + ret =strcmp (subdev->name,"ssr_notifs" ); +if (!ret) +break ; + } +mutex_unlock (&rproc->lock); +if (ret) +return ERR_PTR (-ENOENT );
If the rproc->subdevs list is empty to_ssr_subdev() will generate a coredump.
With the above:
Quoted 161 lines
drivers/remoteproc/qcom_common.c +16
-3+ + ssr =to_ssr_subdev (subdev); +srcu_notifier_chain_register (ssr->rproc_notif_list, nb); + +return ssr->rproc_notif_list; }EXPORT_SYMBOL_GPL (qcom_register_ssr_notifier);/** * qcom_unregister_ssr_notifier() - unregister SSR notification handler +* @notify: pointer to srcu notifier head * @nb: notifier_block to unregister */ -void qcom_unregister_ssr_notifier (struct notifier_block *nb) +int qcom_unregister_ssr_notifier (void *notify,struct notifier_block *nb) { -blocking_notifier_chain_unregister (&ssr_notifiers, nb); +if (!notify) +return -EINVAL ; + +return srcu_notifier_chain_unregister (notify, nb); }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier);@@ -208,7 +231,7 @@ static void ssr_notify_unprepare(struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -blocking_notifier_call_chain (&ssr_notifiers,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); }/** @@ -226,6 +249,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare; + ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ), +GFP_KERNEL ); +srcu_init_notifier_head (ssr->rproc_notif_list);rproc_add_subdev (rproc, &ssr->subdev); }@@ -239,6 +265,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) {kfree (ssr->subdev.name); +kfree (ssr->rproc_notif_list);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);drivers/remoteproc/qcom_common.h +1
-0@@ -27,6 +27,7 @@ struct qcom_rproc_subdev {struct qcom_rproc_ssr {struct rproc_subdev subdev; +struct srcu_notifier_head *rproc_notif_list;const char *name; };drivers/soc/qcom/glink_ssr.c +18
-2@@ -7,6 +7,7 @@#include <linux/completion.h> #include <linux/module.h> #include <linux/notifier.h> +#include <linux/remoteproc.h> #include <linux/rpmsg.h> #include <linux/remoteproc/qcom_rproc.h> @@ -49,6 +50,7 @@ struct glink_ssr {struct rpmsg_endpoint *ept;struct notifier_block nb; +void *notifier_head;u32 seq_num;struct completion completion;@@ -112,6 +114,7 @@ static int qcom_glink_ssr_notify(struct notifier_block *nb, unsigned long event,static int qcom_glink_ssr_probe (struct rpmsg_device *rpdev) {struct glink_ssr *ssr; +struct rproc *rproc; ssr =devm_kzalloc (&rpdev->dev,sizeof (*ssr),GFP_KERNEL );if (!ssr)@@ -125,14 +128,27 @@ static int qcom_glink_ssr_probe(struct rpmsg_device *rpdev)dev_set_drvdata (&rpdev->dev, ssr); -return qcom_register_ssr_notifier (&ssr->nb); + rproc =rproc_get_by_child (&rpdev->dev); +if (!rproc) { +dev_err (&rpdev->dev,"glink device not child of rproc\n" ); +return -EINVAL ; + } + + ssr->notifier_head =qcom_register_ssr_notifier (rproc, &ssr->nb); +if (IS_ERR (ssr->notifier_head)) { +dev_err (&rpdev->dev, +"failed to register for ssr notifications\n" ); +return PTR_ERR (ssr->notifier_head); + } + +return 0 ; }static void qcom_glink_ssr_remove (struct rpmsg_device *rpdev) {struct glink_ssr *ssr =dev_get_drvdata (&rpdev->dev); -qcom_unregister_ssr_notifier (&ssr->nb); +qcom_unregister_ssr_notifier (ssr->notifier_head, &ssr->nb); }static const struct rpmsg_device_id qcom_glink_ssr_match[] = {include/linux/remoteproc/qcom_rproc.h +12
-5@@ -2,20 +2,27 @@#define __QCOM_RPROC_H__struct notifier_block ; +struct rproc ;#if IS_ENABLED (CONFIG_QCOM_RPROC_COMMON ) -int qcom_register_ssr_notifier (struct notifier_block *nb); -void qcom_unregister_ssr_notifier (struct notifier_block *nb); +void *qcom_register_ssr_notifier (struct rproc *rproc, +struct notifier_block *nb); +int qcom_unregister_ssr_notifier (void *notify,struct notifier_block *nb);#else -static inline int qcom_register_ssr_notifier (struct notifier_block *nb) +static inline void *qcom_register_ssr_notifier (struct rproc *rproc, +struct notifier_block *nb) { -return 0 ; +return NULL ; } -static inline void qcom_unregister_ssr_notifier (struct notifier_block *nb) {} +static inline int qcom_unregister_ssr_notifier (void *notify, +struct notifier_block *nb) +{ +return 0 ; +}#endif Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 6/6] remoteproc: qcom: Add notification types to SSR
In reply to Siddharth GuptaQuoted 90 lines · Siddharth Gupta
The SSR subdevice only adds callback for the unprepare event. Add callbacks for unprepare, start and prepare events. The client driver for a particular remoteproc might be interested in knowing the status of the remoteproc while undergoing SSR, not just when the remoteproc has finished shutting down.
Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_common.c | 39 +++++++++++++++++++++++++++++++++++---- include/linux/remoteproc.h | 15 +++++++++++++++ 2 files changed, 50 insertions(+), 4 deletions(-)drivers/remoteproc/qcom_common.c +35
-4@@ -183,9 +183,9 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);* * Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This registers the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the rproc -* pointer passed as a parameter. +* This registers the @notify function as handler for powerup/shutdown +* notifications. This function will be invoked inside the callbacks registered +* for the ssr subdevice, with the rproc pointer passed as a parameter. */ void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) {@@ -227,11 +227,39 @@ int qcom_unregister_ssr_notifier(void *notify, struct notifier_block *nb) }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier); +static int ssr_notify_prepare (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_POWERUP , (void *)ssr->name); +return 0 ; +} + +static int ssr_notify_start (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_POWERUP , (void *)ssr->name); +return 0 ; +} + +static void ssr_notify_stop (struct rproc_subdev *subdev,bool crashed) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_SHUTDOWN , (void *)ssr->name); +} + +static void ssr_notify_unprepare (struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_SHUTDOWN , (void *)ssr->name); }/** @@ -248,6 +276,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, { ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); + ssr->subdev.prepare = ssr_notify_prepare; + ssr->subdev.start = ssr_notify_start; + ssr->subdev.stop = ssr_notify_stop; ssr->subdev.unprepare = ssr_notify_unprepare; ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ),GFP_KERNEL );include/linux/remoteproc.h +2
-0@@ -452,6 +452,21 @@ struct rproc_dump_segment { };/** +* enum rproc_notif_type - Different stages of remoteproc notifications +* @RPROC_BEFORE_SHUTDOWN: unprepare stage of remoteproc
include/linux/remoteproc.h struct rproc_dump_segment { · line 466
Quoted 10 lines
include/linux/remoteproc.h +10
-0+* @RPROC_AFTER_SHUTDOWN: stop stage of remoteproc +* @RPROC_BEFORE_POWERUP: prepare stage of remoteproc +* @RPROC_AFTER_POWERUP: start stage of remoteproc +*/ +enum rproc_notif_type { +RPROC_BEFORE_SHUTDOWN , +RPROC_AFTER_SHUTDOWN , +RPROC_BEFORE_POWERUP , +RPROC_AFTER_POWERUP , +RPROC_MAX
Not sure why you have a RPROC_MAX here... It is not needed in this set but it might be in some downstream or upcoming code.
Quoted 9 lines
include/linux/remoteproc.h +3
-0+}; + +/** * struct rproc - represents a physical remote processor device * @node: list node of this rproc object * @domain: iommu domain Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 4/6] remoteproc: qcom: Add name field for every subdevice
In reply to Siddharth GuptaQuoted 9 lines · Siddharth Gupta
From: Rishabh Bhatnagar <[email protected]>
When a client driver wishes to utilize functionality from a particular subdevice of a remoteproc, it cannot differentiate between the subdevices that have been added. This patch allows the client driver to distinguish between subdevices and thus utilize their functionality.
Signed-off-by Rishabh Bhatnagar <[email protected]>Signed-off-by Siddharth Gupta <[email protected]>
Quoted 80 lines
--- drivers/remoteproc/qcom_common.c | 6 ++++++ include/linux/remoteproc.h | 2 ++ 2 files changed, 8 insertions(+)drivers/remoteproc/qcom_common.c +6
-0@@ -56,6 +56,7 @@ void qcom_add_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glink)return ; glink->dev = dev; + glink->subdev.name =kstrdup ("glink" ,GFP_KERNEL ); glink->subdev.start = glink_subdev_start; glink->subdev.stop = glink_subdev_stop;@@ -73,6 +74,7 @@ void qcom_remove_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glinif (!glink->node)return ; +kfree (glink->subdev.name);rproc_remove_subdev (rproc, &glink->subdev);of_node_put (glink->node); }@@ -152,6 +154,7 @@ void qcom_add_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)return ; smd->dev = dev; + smd->subdev.name =kstrdup ("smd" ,GFP_KERNEL ); smd->subdev.start = smd_subdev_start; smd->subdev.stop = smd_subdev_stop;@@ -169,6 +172,7 @@ void qcom_remove_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)if (!smd->node)return ; +kfree (smd->subdev.name);rproc_remove_subdev (rproc, &smd->subdev);of_node_put (smd->node); }@@ -220,6 +224,7 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, const char *ssr_name) { ssr->name = ssr_name; + ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare;rproc_add_subdev (rproc, &ssr->subdev);@@ -233,6 +238,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);*/ void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) { +kfree (ssr->subdev.name);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);include/linux/remoteproc.h +2
-0@@ -523,6 +523,7 @@ struct rproc {/** * struct rproc_subdev - subdevice tied to a remoteproc * @node: list node related to the rproc subdevs list +* @name: name of the subdevice * @prepare: prepare function, called before the rproc is started * @start: start function, called after the rproc has been started * @stop: stop function, called before the rproc is stopped; the @crashed @@ -531,6 +532,7 @@ struct rproc {*/ struct rproc_subdev {struct list_head node; +char *name;int (*prepare)(struct rproc_subdev *subdev);int (*start)(struct rproc_subdev *subdev);Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 1/6] remoteproc: sysmon: Add ability to send type of notification
In reply to Siddharth GuptaQuoted 9 lines · Siddharth Gupta
Current implementation of the sysmon driver does not support adding notifications for other remoteproc events - prepare, start, unprepare. Clients on the remoteproc side might be interested in knowing when a remoteproc boots up. This change adds the ability to send the notification type along with the name. For example, audio DSP is interested in knowing when modem has crashed so that it can perform cleanup and wait for modem to boot up before it starts processing data again.
Signed-off-by Siddharth Gupta <[email protected]>
Regards,
Bjorn
Quoted 130 lines
--- drivers/remoteproc/qcom_sysmon.c | 54 +++++++++++++++++++++++++++------------- 1 file changed, 37 insertions(+), 17 deletions(-)drivers/remoteproc/qcom_sysmon.c +37
-17@@ -46,6 +46,25 @@ struct qcom_sysmon {struct sockaddr_qrtr ssctl; }; +enum { +SSCTL_SSR_EVENT_BEFORE_POWERUP , +SSCTL_SSR_EVENT_AFTER_POWERUP , +SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , +SSCTL_SSR_EVENT_AFTER_SHUTDOWN , +}; + +static const char *const sysmon_state_string[] = { + [SSCTL_SSR_EVENT_BEFORE_POWERUP ] ="before_powerup" , + [SSCTL_SSR_EVENT_AFTER_POWERUP ] ="after_powerup" , + [SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ] ="before_shutdown" , + [SSCTL_SSR_EVENT_AFTER_SHUTDOWN ] ="after_shutdown" , +}; + +struct sysmon_event { +const char *subsys_name; +u32 ssr_event; +}; +static DEFINE_MUTEX (sysmon_lock);static LIST_HEAD (sysmon_list);@@ -54,13 +73,15 @@ static LIST_HEAD(sysmon_list);* @sysmon: sysmon context * @name: other remote's name */ -static void sysmon_send_event (struct qcom_sysmon *sysmon,const char *name) +static void sysmon_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {char req[50 ];int len;int ret; - len =snprintf (req,sizeof (req),"ssr:%s:before_shutdown" , name); + len =snprintf (req,sizeof (req),"ssr:%s:%s" , event->subsys_name, + sysmon_state_string[event->ssr_event]);if (len >=sizeof (req))return ;@@ -149,13 +170,6 @@ static int sysmon_callback(struct rpmsg_device *rpdev, void *data, int count,#define SSCTL_SUBSYS_NAME_LENGTH 15enum { -SSCTL_SSR_EVENT_BEFORE_POWERUP , -SSCTL_SSR_EVENT_AFTER_POWERUP , -SSCTL_SSR_EVENT_BEFORE_SHUTDOWN , -SSCTL_SSR_EVENT_AFTER_SHUTDOWN , -}; - -enum {SSCTL_SSR_EVENT_FORCED ,SSCTL_SSR_EVENT_GRACEFUL , };@@ -331,7 +345,8 @@ static void ssctl_request_shutdown(struct qcom_sysmon *sysmon)* @sysmon: sysmon context * @name: other remote's name */ -static void ssctl_send_event (struct qcom_sysmon *sysmon,const char *name) +static void ssctl_send_event (struct qcom_sysmon *sysmon, +const struct sysmon_event *event) {struct ssctl_subsys_event_resp resp;struct ssctl_subsys_event_req req;@@ -346,9 +361,9 @@ static void ssctl_send_event(struct qcom_sysmon *sysmon, const char *name) }memset (&req,0 ,sizeof (req)); -strlcpy (req.subsys_name, name,sizeof (req.subsys_name)); +strlcpy (req.subsys_name, event->subsys_name,sizeof (req.subsys_name)); req.subsys_name_len =strlen (req.subsys_name); - req.event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN ; + req.event = event->ssr_event; req.evt_driven_valid = true; req.evt_driven =SSCTL_SSR_EVENT_FORCED ;@@ -432,8 +447,12 @@ static int sysmon_start(struct rproc_subdev *subdev)static void sysmon_stop (struct rproc_subdev *subdev,bool crashed) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_SHUTDOWN + }; -blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)sysmon->name); +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event);/* Don't request graceful shutdown if we've crashed */ if (crashed)@@ -456,19 +475,20 @@ static int sysmon_notify(struct notifier_block *nb, unsigned long event, { struct qcom_sysmon *sysmon = container_of(nb, struct qcom_sysmon, nb);struct rproc *rproc = sysmon->rproc; -const char *ssr_name = data; +struct sysmon_event *sysmon_event = data;/* Skip non-running rprocs and the originating instance */ -if (rproc->state !=RPROC_RUNNING || !strcmp (data, sysmon->name)) { +if (rproc->state !=RPROC_RUNNING || + !strcmp (sysmon_event->subsys_name, sysmon->name)) {dev_dbg (sysmon->dev,"not notifying %s\n" , sysmon->name);return NOTIFY_DONE ; }/* Only SSCTL version 2 supports SSR events */ if (sysmon->ssctl_version ==2 ) -ssctl_send_event (sysmon, ssr_name); +ssctl_send_event (sysmon, sysmon_event);else if (sysmon->ept) -sysmon_send_event (sysmon, ssr_name); +sysmon_send_event (sysmon, sysmon_event);return NOTIFY_DONE ; }Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 2/6] remoteproc: sysmon: Add notifications for events
In reply to Siddharth GuptaQuoted 5 lines · Siddharth Gupta
Add notification for other stages of remoteproc boot and shutdown. This includes adding callback functions for the prepare and unprepare events, and fleshing out the callback function for start.
Signed-off-by Siddharth Gupta <[email protected]>
Regards,
Bjorn
Quoted 73 lines
--- drivers/remoteproc/qcom_sysmon.c | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+)drivers/remoteproc/qcom_sysmon.c +37
-0@@ -439,8 +439,31 @@ static const struct qmi_ops ssctl_ops = { .del_server = ssctl_del_server, }; +static int sysmon_prepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_BEFORE_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); + +return 0 ; +} +static int sysmon_start (struct rproc_subdev *subdev) { + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +return 0 ; }@@ -464,6 +487,18 @@ static void sysmon_stop(struct rproc_subdev *subdev, bool crashed)sysmon_request_shutdown (sysmon); } +static void sysmon_unprepare (struct rproc_subdev *subdev) +{ + struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, + subdev); +struct sysmon_event event = { + .subsys_name = sysmon->name, + .ssr_event =SSCTL_SSR_EVENT_AFTER_SHUTDOWN + }; + +blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +} +/** * sysmon_notify() - notify sysmon target of another's SSR * @nb: notifier_block associated with sysmon instance @@ -563,8 +598,10 @@ struct qcom_sysmon *qcom_add_sysmon_subdev(struct rproc *rproc,qmi_add_lookup (&sysmon->qmi,43 ,0 ,0 ); + sysmon->subdev.prepare = sysmon_prepare; sysmon->subdev.start = sysmon_start; sysmon->subdev.stop = sysmon_stop; + sysmon->subdev.unprepare = sysmon_unprepare;rproc_add_subdev (rproc, &sysmon->subdev);Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 3/6] remoteproc: sysmon: Inform current rproc about all active rprocs
In reply to Siddharth GuptaQuoted 7 lines · Siddharth Gupta
Clients/services running on a remoteproc that booted up might need to be aware of the state of already running remoteprocs. When a remoteproc boots up (fresh or after recovery) it is not aware of the remoteprocs that booted before it, i.e., the system state is incomplete. So to keep track of it we send sysmon on behalf of all 'ONLINE' remoteprocs.
Signed-off-by Siddharth Gupta <[email protected]>
Regards,
Bjorn
Quoted 54 lines
--- drivers/remoteproc/qcom_sysmon.c | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+)drivers/remoteproc/qcom_sysmon.c +25
-0@@ -453,10 +453,20 @@ static int sysmon_prepare(struct rproc_subdev *subdev)return 0 ; } +/** +* sysmon_start() - start callback for the sysmon remoteproc subdevice +* @subdev: instance of the sysmon subdevice +* +* Inform all the listners of sysmon notifications that the rproc associated +* to @subdev has booted up. The rproc that booted up also needs to know +* which rprocs are already up and running, so send start notifications +* on behalf of all the online rprocs. +*/ static int sysmon_start (struct rproc_subdev *subdev) { struct qcom_sysmon *sysmon = container_of(subdev, struct qcom_sysmon, subdev); +struct qcom_sysmon *target;struct sysmon_event event = { .subsys_name = sysmon->name, .ssr_event =SSCTL_SSR_EVENT_AFTER_POWERUP @@ -464,6 +474,21 @@ static int sysmon_start(struct rproc_subdev *subdev)blocking_notifier_call_chain (&sysmon_notifiers,0 , (void *)&event); +mutex_lock (&sysmon_lock); +list_for_each_entry (target, &sysmon_list, node) { +if (target == sysmon || + target->rproc->state !=RPROC_RUNNING ) +continue ; + + event.subsys_name = target->name; + +if (sysmon->ssctl_version ==2 ) +ssctl_send_event (sysmon, &event); +else if (sysmon->ept) +sysmon_send_event (sysmon, &event); + } +mutex_unlock (&sysmon_lock); +return 0 ; }Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 5/6] remoteproc: qcom: Add per subsystem SSR notification
In reply to Siddharth GuptaQuoted 51 lines · Siddharth Gupta
Currently there is a global notification chain which is called whenever any remoteproc shuts down. This leads to all the listeners being notified, and is not an optimal design as kernel drivers might only be interested in listening to notifications from a particular remoteproc. Create an individual notifier chain for every SSR subdevice, and modify the notification registration API to include the remoteproc struct as an argument. Update the existing user of the registration API to get the phandle of the remoteproc dt node to register for SSR notifications.
Signed-off-by Rishabh Bhatnagar <[email protected]>Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_common.c | 49 +++++++++++++++++++++++++++-------- drivers/remoteproc/qcom_common.h | 1 + drivers/soc/qcom/glink_ssr.c | 20 ++++++++++++-- include/linux/remoteproc/qcom_rproc.h | 17 ++++++++---- 4 files changed, 69 insertions(+), 18 deletions(-)drivers/remoteproc/qcom_common.c +6
-7@@ -23,8 +23,6 @@#define to_smd_subdev (d) container_of(d, struct qcom_rproc_subdev, subdev)#define to_ssr_subdev (d) container_of(d, struct qcom_rproc_ssr, subdev) -static BLOCKING_NOTIFIER_HEAD (ssr_notifiers); -static int glink_subdev_start (struct rproc_subdev *subdev) {struct qcom_rproc_glink *glink =to_glink_subdev (subdev);@@ -180,27 +178,52 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);/** * qcom_register_ssr_notifier() - register SSR notification handler +* @rproc: pointer to the remoteproc structure * @nb: notifier_block to notify for restart notifications * -* Returns 0 on success, negative errno on failure. +* Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This register the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the SSR -* name passed as a parameter. +* This registers the @notify function as handler for restart notifications. As +* remote processors are stopped this function will be called, with the rproc +* pointer passed as a parameter. */ -int qcom_register_ssr_notifier (struct notifier_block *nb) +void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) {
drivers/remoteproc/qcom_common.c EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev); · line 200
Quoted 10 lines
drivers/remoteproc/qcom_common.c +9
-1-return blocking_notifier_chain_register (&ssr_notifiers, nb); +struct rproc_subdev *subdev; +struct qcom_rproc_ssr *ssr; +int ret; + +if (!rproc) +return ERR_PTR (-EINVAL ); + +mutex_lock (&rproc->lock); +list_for_each_entry (subdev, &rproc->subdevs, node) {
I would prefer that we don't touch the lock or subdevs list outside of the remoteproc core.
drivers/remoteproc/qcom_common.c EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev); · line 210
Quoted 10 lines
drivers/remoteproc/qcom_common.c +10
-0+ ret =strcmp (subdev->name,"ssr_notifs" ); +if (!ret) +break ; + } +mutex_unlock (&rproc->lock); +if (ret) +return ERR_PTR (-ENOENT ); + + ssr =to_ssr_subdev (subdev); +srcu_notifier_chain_register (ssr->rproc_notif_list, nb);
Adding the notifier to an existing ssr_subdev means that any client driver that is interested in notification about a remoteproc coming and going will need to be registered (typically probed) after the remoteproc driver.
I presume this would be handled by probe deferring on rproc_get_by_phandle(), but I'm concerned that this will cause unnecessary probe deferral. But more importantly, it wouldn't allow for the remoteproc driver to be unloaded and loaded again (as that would be a new notifier list).
So I think you should carry a global list of "watchers" and upon subdev events you can match entries in this list based on either struct of_node or perhaps by ssr_name?
Quoted 89 lines
drivers/remoteproc/qcom_common.c +13
-3+ +return ssr->rproc_notif_list; }EXPORT_SYMBOL_GPL (qcom_register_ssr_notifier);/** * qcom_unregister_ssr_notifier() - unregister SSR notification handler +* @notify: pointer to srcu notifier head * @nb: notifier_block to unregister */ -void qcom_unregister_ssr_notifier (struct notifier_block *nb) +int qcom_unregister_ssr_notifier (void *notify,struct notifier_block *nb) { -blocking_notifier_chain_unregister (&ssr_notifiers, nb); +if (!notify) +return -EINVAL ; + +return srcu_notifier_chain_unregister (notify, nb); }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier);@@ -208,7 +231,7 @@ static void ssr_notify_unprepare(struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -blocking_notifier_call_chain (&ssr_notifiers,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); }/** @@ -226,6 +249,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare; + ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ), +GFP_KERNEL ); +srcu_init_notifier_head (ssr->rproc_notif_list);rproc_add_subdev (rproc, &ssr->subdev); }@@ -239,6 +265,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) {kfree (ssr->subdev.name); +kfree (ssr->rproc_notif_list);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);drivers/remoteproc/qcom_common.h +1
-0@@ -27,6 +27,7 @@ struct qcom_rproc_subdev {struct qcom_rproc_ssr {struct rproc_subdev subdev; +struct srcu_notifier_head *rproc_notif_list;const char *name; };drivers/soc/qcom/glink_ssr.c +3
-0@@ -7,6 +7,7 @@#include <linux/completion.h> #include <linux/module.h> #include <linux/notifier.h> +#include <linux/remoteproc.h> #include <linux/rpmsg.h> #include <linux/remoteproc/qcom_rproc.h> @@ -49,6 +50,7 @@ struct glink_ssr {struct rpmsg_endpoint *ept;struct notifier_block nb; +void *notifier_head;u32 seq_num;struct completion completion;@@ -112,6 +114,7 @@ static int qcom_glink_ssr_notify(struct notifier_block *nb, unsigned long event,static int qcom_glink_ssr_probe (struct rpmsg_device *rpdev) {struct glink_ssr *ssr; +struct rproc *rproc; ssr =devm_kzalloc (&rpdev->dev,sizeof (*ssr),GFP_KERNEL );if (!ssr)
drivers/soc/qcom/glink_ssr.c static int qcom_glink_ssr_probe(struct rpmsg_device *rpdev) · line 131
Quoted 5 lines
drivers/soc/qcom/glink_ssr.c +1
-1@@ -125,14 +128,27 @@ static int qcom_glink_ssr_probe(struct rpmsg_device *rpdev)dev_set_drvdata (&rpdev->dev, ssr); -return qcom_register_ssr_notifier (&ssr->nb); + rproc =rproc_get_by_child (&rpdev->dev);
As we discussed in our meeting offline earlier today, not all glink_ssr instances has a remoteproc ancestor. After going back and forth on how to handle this I posted below series:
https://lore.kernel.org/linux-arm-msm/[email protected]/T/#t
With this we are flexible to tie the ssr_subdev API to remoteproc instances...
Regards,
Bjorn
Re: [PATCH v2 4/6] remoteproc: qcom: Add name field for every subdevice
In reply to Siddharth GuptaQuoted 7 lines · Siddharth Gupta
From: Rishabh Bhatnagar <[email protected]>
When a client driver wishes to utilize functionality from a particular subdevice of a remoteproc, it cannot differentiate between the subdevices that have been added. This patch allows the client driver to distinguish between subdevices and thus utilize their functionality.
As noted in patch 5, this invites driver authors to traverse the rproc subdev list outside the remoteproc core. So I would like to avoid this.
Regards,
Bjorn
Quoted 82 lines
Signed-off-by Rishabh Bhatnagar <[email protected]>Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_common.c | 6 ++++++ include/linux/remoteproc.h | 2 ++ 2 files changed, 8 insertions(+)drivers/remoteproc/qcom_common.c +6
-0@@ -56,6 +56,7 @@ void qcom_add_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glink)return ; glink->dev = dev; + glink->subdev.name =kstrdup ("glink" ,GFP_KERNEL ); glink->subdev.start = glink_subdev_start; glink->subdev.stop = glink_subdev_stop;@@ -73,6 +74,7 @@ void qcom_remove_glink_subdev(struct rproc *rproc, struct qcom_rproc_glink *glinif (!glink->node)return ; +kfree (glink->subdev.name);rproc_remove_subdev (rproc, &glink->subdev);of_node_put (glink->node); }@@ -152,6 +154,7 @@ void qcom_add_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)return ; smd->dev = dev; + smd->subdev.name =kstrdup ("smd" ,GFP_KERNEL ); smd->subdev.start = smd_subdev_start; smd->subdev.stop = smd_subdev_stop;@@ -169,6 +172,7 @@ void qcom_remove_smd_subdev(struct rproc *rproc, struct qcom_rproc_subdev *smd)if (!smd->node)return ; +kfree (smd->subdev.name);rproc_remove_subdev (rproc, &smd->subdev);of_node_put (smd->node); }@@ -220,6 +224,7 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, const char *ssr_name) { ssr->name = ssr_name; + ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); ssr->subdev.unprepare = ssr_notify_unprepare;rproc_add_subdev (rproc, &ssr->subdev);@@ -233,6 +238,7 @@ EXPORT_SYMBOL_GPL(qcom_add_ssr_subdev);*/ void qcom_remove_ssr_subdev (struct rproc *rproc,struct qcom_rproc_ssr *ssr) { +kfree (ssr->subdev.name);rproc_remove_subdev (rproc, &ssr->subdev); }EXPORT_SYMBOL_GPL (qcom_remove_ssr_subdev);include/linux/remoteproc.h +2
-0@@ -523,6 +523,7 @@ struct rproc {/** * struct rproc_subdev - subdevice tied to a remoteproc * @node: list node related to the rproc subdevs list +* @name: name of the subdevice * @prepare: prepare function, called before the rproc is started * @start: start function, called after the rproc has been started * @stop: stop function, called before the rproc is stopped; the @crashed @@ -531,6 +532,7 @@ struct rproc {*/ struct rproc_subdev {struct list_head node; +char *name;int (*prepare)(struct rproc_subdev *subdev);int (*start)(struct rproc_subdev *subdev);Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project
Re: [PATCH v2 6/6] remoteproc: qcom: Add notification types to SSR
In reply to Siddharth GuptaQuoted 85 lines · Siddharth Gupta
The SSR subdevice only adds callback for the unprepare event. Add callbacks for unprepare, start and prepare events. The client driver for a particular remoteproc might be interested in knowing the status of the remoteproc while undergoing SSR, not just when the remoteproc has finished shutting down.
Signed-off-by Siddharth Gupta <[email protected]>--- drivers/remoteproc/qcom_common.c | 39 +++++++++++++++++++++++++++++++++++---- include/linux/remoteproc.h | 15 +++++++++++++++ 2 files changed, 50 insertions(+), 4 deletions(-)drivers/remoteproc/qcom_common.c +35
-4@@ -183,9 +183,9 @@ EXPORT_SYMBOL_GPL(qcom_remove_smd_subdev);* * Returns pointer to srcu notifier head on success, ERR_PTR on failure. * -* This registers the @notify function as handler for restart notifications. As -* remote processors are stopped this function will be called, with the rproc -* pointer passed as a parameter. +* This registers the @notify function as handler for powerup/shutdown +* notifications. This function will be invoked inside the callbacks registered +* for the ssr subdevice, with the rproc pointer passed as a parameter. */ void *qcom_register_ssr_notifier (struct rproc *rproc,struct notifier_block *nb) {@@ -227,11 +227,39 @@ int qcom_unregister_ssr_notifier(void *notify, struct notifier_block *nb) }EXPORT_SYMBOL_GPL (qcom_unregister_ssr_notifier); +static int ssr_notify_prepare (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_POWERUP , (void *)ssr->name); +return 0 ; +} + +static int ssr_notify_start (struct rproc_subdev *subdev) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_POWERUP , (void *)ssr->name); +return 0 ; +} + +static void ssr_notify_stop (struct rproc_subdev *subdev,bool crashed) +{ +struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); + +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_BEFORE_SHUTDOWN , (void *)ssr->name); +} + +static void ssr_notify_unprepare (struct rproc_subdev *subdev) {struct qcom_rproc_ssr *ssr =to_ssr_subdev (subdev); -srcu_notifier_call_chain (ssr->rproc_notif_list,0 , (void *)ssr->name); +srcu_notifier_call_chain (ssr->rproc_notif_list, +RPROC_AFTER_SHUTDOWN , (void *)ssr->name); }/** @@ -248,6 +276,9 @@ void qcom_add_ssr_subdev(struct rproc *rproc, struct qcom_rproc_ssr *ssr, { ssr->name = ssr_name; ssr->subdev.name =kstrdup ("ssr_notifs" ,GFP_KERNEL ); + ssr->subdev.prepare = ssr_notify_prepare; + ssr->subdev.start = ssr_notify_start; + ssr->subdev.stop = ssr_notify_stop; ssr->subdev.unprepare = ssr_notify_unprepare; ssr->rproc_notif_list =kzalloc (sizeof (struct srcu_notifier_head ),GFP_KERNEL );include/linux/remoteproc.h +0
-0
include/linux/remoteproc.h struct rproc_dump_segment { · line 461
Quoted 10 lines
include/linux/remoteproc.h +7
-0@@ -452,6 +452,21 @@ struct rproc_dump_segment { };/** +* enum rproc_notif_type - Different stages of remoteproc notifications +* @RPROC_BEFORE_SHUTDOWN: unprepare stage of remoteproc +* @RPROC_AFTER_SHUTDOWN: stop stage of remoteproc +* @RPROC_BEFORE_POWERUP: prepare stage of remoteproc +* @RPROC_AFTER_POWERUP: start stage of remoteproc +*/ +enum rproc_notif_type {
As these are tied to the API defined in qcom_rproc.h, I think it better belong there.
include/linux/remoteproc.h struct rproc_dump_segment { · line 466
Quoted 5 lines
include/linux/remoteproc.h +5
-0+RPROC_BEFORE_SHUTDOWN , +RPROC_AFTER_SHUTDOWN , +RPROC_BEFORE_POWERUP , +RPROC_AFTER_POWERUP , +RPROC_MAX
Please omit the MAX, unless you have a specific purpose for it.
Regards,
Bjorn
Quoted 9 lines
include/linux/remoteproc.h +3
-0+}; + +/** * struct rproc - represents a physical remote processor device * @node: list node of this rproc object * @domain: iommu domain Signature · 2 lines
Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project