| Message ID | 20180313085534.11650-1-vivek.gautam@codeaurora.org |
|---|---|
| Headers | show |
| Series | iommu/arm-smmu: Add runtime pm/sleep support | expand |
On Tuesday, March 13, 2018 9:55:30 AM CET Vivek Gautam wrote: > The lists managing the device-links can be traversed to > find the link between two devices. The device_link_add() APIs > does traverse these lists to check if there's already a link > setup between the two devices. > So, add a new APIs, device_link_find(), to find an existing > device link between two devices - suppliers and consumers. > > Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> > Cc: Rafael J. Wysocki <rjw@rjwysocki.net> > Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> > --- > > * New patch added to this series. > > drivers/base/core.c | 30 +++++++++++++++++++++++++++--- > include/linux/device.h | 2 ++ > 2 files changed, 29 insertions(+), 3 deletions(-) > > diff --git a/drivers/base/core.c b/drivers/base/core.c > index 5847364f25d9..e8c9774e4ba2 100644 > --- a/drivers/base/core.c > +++ b/drivers/base/core.c > @@ -144,6 +144,30 @@ static int device_reorder_to_tail(struct device *dev, void *not_used) > return 0; > } > > +/** > + * device_link_find - find any existing link between two devices. > + * @consumer: Consumer end of the link. > + * @supplier: Supplier end of the link. > + * > + * Returns pointer to the existing link between a supplier and > + * and consumer devices, or NULL if no link exists. > + */ > +struct device_link *device_link_find(struct device *consumer, > + struct device *supplier) > +{ > + struct device_link *link = NULL; > + > + if (!consumer || !supplier) > + return NULL; > + > + list_for_each_entry(link, &supplier->links.consumers, s_node) > + if (link->consumer == consumer) > + break; > + Any mutual exclusion? Or is the caller expected to take care of it? And if so, then how? > + return link; > +} > +EXPORT_SYMBOL_GPL(device_link_find); > + > /** > * device_link_add - Create a link between two devices. > * @consumer: Consumer end of the link. > @@ -195,9 +219,9 @@ struct device_link *device_link_add(struct device *consumer, > goto out; > } > > - list_for_each_entry(link, &supplier->links.consumers, s_node) > - if (link->consumer == consumer) > - goto out; > + link = device_link_find(consumer, supplier); > + if (link) > + goto out; > > link = kzalloc(sizeof(*link), GFP_KERNEL); > if (!link) > diff --git a/include/linux/device.h b/include/linux/device.h > index b093405ed525..13bc1884c3eb 100644 > --- a/include/linux/device.h > +++ b/include/linux/device.h > @@ -1278,6 +1278,8 @@ extern const char *dev_driver_string(const struct device *dev); > struct device_link *device_link_add(struct device *consumer, > struct device *supplier, u32 flags); > void device_link_del(struct device_link *link); > +struct device_link *device_link_find(struct device *consumer, > + struct device *supplier); > > #ifdef CONFIG_PRINTK > > -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Mar 13, 2018 at 3:10 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: > On Tuesday, March 13, 2018 9:55:30 AM CET Vivek Gautam wrote: >> The lists managing the device-links can be traversed to >> find the link between two devices. The device_link_add() APIs >> does traverse these lists to check if there's already a link >> setup between the two devices. >> So, add a new APIs, device_link_find(), to find an existing >> device link between two devices - suppliers and consumers. >> >> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >> Cc: Rafael J. Wysocki <rjw@rjwysocki.net> >> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> >> --- >> >> * New patch added to this series. >> >> drivers/base/core.c | 30 +++++++++++++++++++++++++++--- >> include/linux/device.h | 2 ++ >> 2 files changed, 29 insertions(+), 3 deletions(-) >> >> diff --git a/drivers/base/core.c b/drivers/base/core.c >> index 5847364f25d9..e8c9774e4ba2 100644 >> --- a/drivers/base/core.c >> +++ b/drivers/base/core.c >> @@ -144,6 +144,30 @@ static int device_reorder_to_tail(struct device *dev, void *not_used) >> return 0; >> } >> >> +/** >> + * device_link_find - find any existing link between two devices. >> + * @consumer: Consumer end of the link. >> + * @supplier: Supplier end of the link. >> + * >> + * Returns pointer to the existing link between a supplier and >> + * and consumer devices, or NULL if no link exists. >> + */ >> +struct device_link *device_link_find(struct device *consumer, >> + struct device *supplier) >> +{ >> + struct device_link *link = NULL; >> + >> + if (!consumer || !supplier) >> + return NULL; >> + >> + list_for_each_entry(link, &supplier->links.consumers, s_node) >> + if (link->consumer == consumer) >> + break; >> + > > Any mutual exclusion? > > Or is the caller expected to take care of it? And if so, then how? I think it's better that we take care of lock here in the code rather than depending on the caller. But i can't take device_links_write_lock() since device_link_add() already takes that. regards Vivek > >> + return link; >> +} >> +EXPORT_SYMBOL_GPL(device_link_find); >> + >> /** >> * device_link_add - Create a link between two devices. >> * @consumer: Consumer end of the link. >> @@ -195,9 +219,9 @@ struct device_link *device_link_add(struct device *consumer, >> goto out; >> } >> >> - list_for_each_entry(link, &supplier->links.consumers, s_node) >> - if (link->consumer == consumer) >> - goto out; >> + link = device_link_find(consumer, supplier); >> + if (link) >> + goto out; >> >> link = kzalloc(sizeof(*link), GFP_KERNEL); >> if (!link) >> diff --git a/include/linux/device.h b/include/linux/device.h >> index b093405ed525..13bc1884c3eb 100644 >> --- a/include/linux/device.h >> +++ b/include/linux/device.h >> @@ -1278,6 +1278,8 @@ extern const char *dev_driver_string(const struct device *dev); >> struct device_link *device_link_add(struct device *consumer, >> struct device *supplier, u32 flags); >> void device_link_del(struct device_link *link); >> +struct device_link *device_link_find(struct device *consumer, >> + struct device *supplier); >> >> #ifdef CONFIG_PRINTK >> >> > > > -- > To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Mar 13, 2018 at 2:25 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > The lists managing the device-links can be traversed to > find the link between two devices. The device_link_add() APIs > does traverse these lists to check if there's already a link > setup between the two devices. > So, add a new APIs, device_link_find(), to find an existing > device link between two devices - suppliers and consumers. > > Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> > Cc: Rafael J. Wysocki <rjw@rjwysocki.net> > Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> > --- > > * New patch added to this series. > > drivers/base/core.c | 30 +++++++++++++++++++++++++++--- > include/linux/device.h | 2 ++ > 2 files changed, 29 insertions(+), 3 deletions(-) > > diff --git a/drivers/base/core.c b/drivers/base/core.c > index 5847364f25d9..e8c9774e4ba2 100644 > --- a/drivers/base/core.c > +++ b/drivers/base/core.c > @@ -144,6 +144,30 @@ static int device_reorder_to_tail(struct device *dev, void *not_used) > return 0; > } > > +/** > + * device_link_find - find any existing link between two devices. > + * @consumer: Consumer end of the link. > + * @supplier: Supplier end of the link. > + * > + * Returns pointer to the existing link between a supplier and > + * and consumer devices, or NULL if no link exists. > + */ > +struct device_link *device_link_find(struct device *consumer, > + struct device *supplier) > +{ > + struct device_link *link = NULL; > + > + if (!consumer || !supplier) > + return NULL; > + > + list_for_each_entry(link, &supplier->links.consumers, s_node) > + if (link->consumer == consumer) > + break; > + > + return link; My bad, this too needs fixing (didn't add the changes to the patch :( ) list_for_each_entry(link, &supplier->links.consumers, s_node) if (link->consumer == consumer) return link; return NULL; > +} > +EXPORT_SYMBOL_GPL(device_link_find); > + > /** > * device_link_add - Create a link between two devices. > * @consumer: Consumer end of the link. > @@ -195,9 +219,9 @@ struct device_link *device_link_add(struct device *consumer, > goto out; > } > > - list_for_each_entry(link, &supplier->links.consumers, s_node) > - if (link->consumer == consumer) > - goto out; > + link = device_link_find(consumer, supplier); > + if (link) > + goto out; > > link = kzalloc(sizeof(*link), GFP_KERNEL); > if (!link) > diff --git a/include/linux/device.h b/include/linux/device.h > index b093405ed525..13bc1884c3eb 100644 > --- a/include/linux/device.h > +++ b/include/linux/device.h > @@ -1278,6 +1278,8 @@ extern const char *dev_driver_string(const struct device *dev); > struct device_link *device_link_add(struct device *consumer, > struct device *supplier, u32 flags); > void device_link_del(struct device_link *link); > +struct device_link *device_link_find(struct device *consumer, > + struct device *supplier); > > #ifdef CONFIG_PRINTK > > -- > QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member > of Code Aurora Forum, hosted by The Linux Foundation > > -- > To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Vivek, Thanks for the patch. On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > The lists managing the device-links can be traversed to > find the link between two devices. The device_link_add() APIs > does traverse these lists to check if there's already a link > setup between the two devices. > So, add a new APIs, device_link_find(), to find an existing > device link between two devices - suppliers and consumers. I'm wondering if this API would be useful for anything else that the problem we're trying to solve with deleting links without storing them anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a better alternative? Best regards, Tomasz -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Tomasz, On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: > Hi Vivek, > > Thanks for the patch. > > On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam > <vivek.gautam@codeaurora.org> wrote: >> The lists managing the device-links can be traversed to >> find the link between two devices. The device_link_add() APIs >> does traverse these lists to check if there's already a link >> setup between the two devices. >> So, add a new APIs, device_link_find(), to find an existing >> device link between two devices - suppliers and consumers. > > I'm wondering if this API would be useful for anything else that the > problem we're trying to solve with deleting links without storing them > anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a > better alternative? Yea, that sounds simpler i think. Will add this API instead of find_link(). Thanks. regards vivek > > Best regards, > Tomasz > -- > To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > Hi Tomasz, > > On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: >> Hi Vivek, >> >> Thanks for the patch. >> >> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam >> <vivek.gautam@codeaurora.org> wrote: >>> The lists managing the device-links can be traversed to >>> find the link between two devices. The device_link_add() APIs >>> does traverse these lists to check if there's already a link >>> setup between the two devices. >>> So, add a new APIs, device_link_find(), to find an existing >>> device link between two devices - suppliers and consumers. >> >> I'm wondering if this API would be useful for anything else that the >> problem we're trying to solve with deleting links without storing them >> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a >> better alternative? > > Yea, that sounds simpler i think. Will add this API instead of > find_link(). Thanks. Perhaps let's wait for a moment to see if there are other opinions. :) Rafael, Lucas, any thoughts? Best regards, Tomasz -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 13/03/18 09:55, Vivek Gautam wrote: > On Tue, Mar 13, 2018 at 3:10 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: >> On Tuesday, March 13, 2018 9:55:30 AM CET Vivek Gautam wrote: >>> The lists managing the device-links can be traversed to >>> find the link between two devices. The device_link_add() APIs >>> does traverse these lists to check if there's already a link >>> setup between the two devices. >>> So, add a new APIs, device_link_find(), to find an existing >>> device link between two devices - suppliers and consumers. >>> >>> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >>> Cc: Rafael J. Wysocki <rjw@rjwysocki.net> >>> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> >>> --- >>> >>> * New patch added to this series. >>> >>> drivers/base/core.c | 30 +++++++++++++++++++++++++++--- >>> include/linux/device.h | 2 ++ >>> 2 files changed, 29 insertions(+), 3 deletions(-) >>> >>> diff --git a/drivers/base/core.c b/drivers/base/core.c >>> index 5847364f25d9..e8c9774e4ba2 100644 >>> --- a/drivers/base/core.c >>> +++ b/drivers/base/core.c >>> @@ -144,6 +144,30 @@ static int device_reorder_to_tail(struct device *dev, void *not_used) >>> return 0; >>> } >>> >>> +/** >>> + * device_link_find - find any existing link between two devices. >>> + * @consumer: Consumer end of the link. >>> + * @supplier: Supplier end of the link. >>> + * >>> + * Returns pointer to the existing link between a supplier and >>> + * and consumer devices, or NULL if no link exists. >>> + */ >>> +struct device_link *device_link_find(struct device *consumer, >>> + struct device *supplier) >>> +{ >>> + struct device_link *link = NULL; >>> + >>> + if (!consumer || !supplier) >>> + return NULL; >>> + >>> + list_for_each_entry(link, &supplier->links.consumers, s_node) >>> + if (link->consumer == consumer) >>> + break; >>> + >> >> Any mutual exclusion? >> >> Or is the caller expected to take care of it? And if so, then how? > > I think it's better that we take care of lock here in the code rather > than depending > on the caller. > But i can't take device_links_write_lock() since device_link_add() > already takes that. Well, the normal pattern is to break out the internal helper function as-is, then add a public wrapper which validates inputs, handles locking, etc., equivalently to existing caller(s). See what device_link_del() and others do, e.g.: static struct device_link *__device_link_find(struct device *consumer, struct device *supplier) { list_for_each_entry(link, &supplier->links.consumers, s_node) if (link->consumer == consumer) return link; return NULL; } struct device_link *device_link_find(struct device *consumer, struct device *supplier) { struct device_link *link; if (!consumer || !supplier) return NULL; device_links_write_lock(); link = __device_link_find(consumer, supplier); device_links_write_unlock(); return link; } where device_link_add() would call __device_link_find() directly. However, as Tomasz points out (and I hadn't really considered), if the only reasonable thing to with a link once you've found it is to delete it, then in terms of the public API it may well make more sense to just implement something like a device_link_remove() which does both in one go. Robin. -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Robin, On Tue, Mar 13, 2018 at 6:19 PM, Robin Murphy <robin.murphy@arm.com> wrote: > On 13/03/18 09:55, Vivek Gautam wrote: >> >> On Tue, Mar 13, 2018 at 3:10 PM, Rafael J. Wysocki <rjw@rjwysocki.net> >> wrote: >>> >>> On Tuesday, March 13, 2018 9:55:30 AM CET Vivek Gautam wrote: >>>> >>>> The lists managing the device-links can be traversed to >>>> find the link between two devices. The device_link_add() APIs >>>> does traverse these lists to check if there's already a link >>>> setup between the two devices. >>>> So, add a new APIs, device_link_find(), to find an existing >>>> device link between two devices - suppliers and consumers. >>>> >>>> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >>>> Cc: Rafael J. Wysocki <rjw@rjwysocki.net> >>>> Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org> >>>> --- >>>> >>>> * New patch added to this series. >>>> >>>> drivers/base/core.c | 30 +++++++++++++++++++++++++++--- >>>> include/linux/device.h | 2 ++ >>>> 2 files changed, 29 insertions(+), 3 deletions(-) >>>> >>>> diff --git a/drivers/base/core.c b/drivers/base/core.c >>>> index 5847364f25d9..e8c9774e4ba2 100644 >>>> --- a/drivers/base/core.c >>>> +++ b/drivers/base/core.c >>>> @@ -144,6 +144,30 @@ static int device_reorder_to_tail(struct device >>>> *dev, void *not_used) >>>> return 0; >>>> } >>>> >>>> +/** >>>> + * device_link_find - find any existing link between two devices. >>>> + * @consumer: Consumer end of the link. >>>> + * @supplier: Supplier end of the link. >>>> + * >>>> + * Returns pointer to the existing link between a supplier and >>>> + * and consumer devices, or NULL if no link exists. >>>> + */ >>>> +struct device_link *device_link_find(struct device *consumer, >>>> + struct device *supplier) >>>> +{ >>>> + struct device_link *link = NULL; >>>> + >>>> + if (!consumer || !supplier) >>>> + return NULL; >>>> + >>>> + list_for_each_entry(link, &supplier->links.consumers, s_node) >>>> + if (link->consumer == consumer) >>>> + break; >>>> + >>> >>> >>> Any mutual exclusion? >>> >>> Or is the caller expected to take care of it? And if so, then how? >> >> >> I think it's better that we take care of lock here in the code rather >> than depending >> on the caller. >> But i can't take device_links_write_lock() since device_link_add() >> already takes that. > > > Well, the normal pattern is to break out the internal helper function as-is, > then add a public wrapper which validates inputs, handles locking, etc., > equivalently to existing caller(s). See what device_link_del() and others > do, e.g.: > > static struct device_link *__device_link_find(struct device *consumer, > struct device *supplier) > { > list_for_each_entry(link, &supplier->links.consumers, s_node) > if (link->consumer == consumer) > return link; > return NULL; > } > > struct device_link *device_link_find(struct device *consumer, > struct device *supplier) > { > struct device_link *link; > > if (!consumer || !supplier) > return NULL; > > device_links_write_lock(); > link = __device_link_find(consumer, supplier); > device_links_write_unlock(); > return link; > } > > where device_link_add() would call __device_link_find() directly. Right, I understand it now. Thanks for detailed explanation. regards Vivek > > However, as Tomasz points out (and I hadn't really considered), if the only > reasonable thing to with a link once you've found it is to delete it, then > in terms of the public API it may well make more sense to just implement > something like a device_link_remove() which does both in one go. > > Robin. > > -- > To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html
On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: > On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam > <vivek.gautam@codeaurora.org> wrote: > > Hi Tomasz, > > > > On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: > >> Hi Vivek, > >> > >> Thanks for the patch. > >> > >> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam > >> <vivek.gautam@codeaurora.org> wrote: > >>> The lists managing the device-links can be traversed to > >>> find the link between two devices. The device_link_add() APIs > >>> does traverse these lists to check if there's already a link > >>> setup between the two devices. > >>> So, add a new APIs, device_link_find(), to find an existing > >>> device link between two devices - suppliers and consumers. > >> > >> I'm wondering if this API would be useful for anything else that the > >> problem we're trying to solve with deleting links without storing them > >> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a > >> better alternative? > > > > Yea, that sounds simpler i think. Will add this API instead of > > find_link(). Thanks. > > Perhaps let's wait for a moment to see if there are other opinions. :) > > Rafael, Lucas, any thoughts? It is not clear to me what the device_link_del_dev(consumer, supplier) would do. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Mar 14, 2018 at 8:12 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: > On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: >> On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam >> <vivek.gautam@codeaurora.org> wrote: >> > Hi Tomasz, >> > >> > On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: >> >> Hi Vivek, >> >> >> >> Thanks for the patch. >> >> >> >> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam >> >> <vivek.gautam@codeaurora.org> wrote: >> >>> The lists managing the device-links can be traversed to >> >>> find the link between two devices. The device_link_add() APIs >> >>> does traverse these lists to check if there's already a link >> >>> setup between the two devices. >> >>> So, add a new APIs, device_link_find(), to find an existing >> >>> device link between two devices - suppliers and consumers. >> >> >> >> I'm wondering if this API would be useful for anything else that the >> >> problem we're trying to solve with deleting links without storing them >> >> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a >> >> better alternative? >> > >> > Yea, that sounds simpler i think. Will add this API instead of >> > find_link(). Thanks. >> >> Perhaps let's wait for a moment to see if there are other opinions. :) >> >> Rafael, Lucas, any thoughts? > > It is not clear to me what the device_link_del_dev(consumer, supplier) would do. It would delete a link between consumer and supplier. Best regards, Tomasz -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wednesday, March 14, 2018 12:50:54 PM CET Tomasz Figa wrote: > On Wed, Mar 14, 2018 at 8:12 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: > > On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: > >> On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam > >> <vivek.gautam@codeaurora.org> wrote: > >> > Hi Tomasz, > >> > > >> > On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: > >> >> Hi Vivek, > >> >> > >> >> Thanks for the patch. > >> >> > >> >> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam > >> >> <vivek.gautam@codeaurora.org> wrote: > >> >>> The lists managing the device-links can be traversed to > >> >>> find the link between two devices. The device_link_add() APIs > >> >>> does traverse these lists to check if there's already a link > >> >>> setup between the two devices. > >> >>> So, add a new APIs, device_link_find(), to find an existing > >> >>> device link between two devices - suppliers and consumers. > >> >> > >> >> I'm wondering if this API would be useful for anything else that the > >> >> problem we're trying to solve with deleting links without storing them > >> >> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a > >> >> better alternative? > >> > > >> > Yea, that sounds simpler i think. Will add this API instead of > >> > find_link(). Thanks. > >> > >> Perhaps let's wait for a moment to see if there are other opinions. :) > >> > >> Rafael, Lucas, any thoughts? > > > > It is not clear to me what the device_link_del_dev(consumer, supplier) would do. > > It would delete a link between consumer and supplier. If there's one I suppose. I'm wondering if you are somehow trying to address the same problem as the device links reference counting patch from Lukas that has been queued up for 4.17 already. Thanks, Rafael -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Rafael, On 14/03/18 11:57, Rafael J. Wysocki wrote: > On Wednesday, March 14, 2018 12:50:54 PM CET Tomasz Figa wrote: >> On Wed, Mar 14, 2018 at 8:12 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: >>> On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: >>>> On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam >>>> <vivek.gautam@codeaurora.org> wrote: >>>>> Hi Tomasz, >>>>> >>>>> On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: >>>>>> Hi Vivek, >>>>>> >>>>>> Thanks for the patch. >>>>>> >>>>>> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam >>>>>> <vivek.gautam@codeaurora.org> wrote: >>>>>>> The lists managing the device-links can be traversed to >>>>>>> find the link between two devices. The device_link_add() APIs >>>>>>> does traverse these lists to check if there's already a link >>>>>>> setup between the two devices. >>>>>>> So, add a new APIs, device_link_find(), to find an existing >>>>>>> device link between two devices - suppliers and consumers. >>>>>> >>>>>> I'm wondering if this API would be useful for anything else that the >>>>>> problem we're trying to solve with deleting links without storing them >>>>>> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a >>>>>> better alternative? >>>>> >>>>> Yea, that sounds simpler i think. Will add this API instead of >>>>> find_link(). Thanks. >>>> >>>> Perhaps let's wait for a moment to see if there are other opinions. :) >>>> >>>> Rafael, Lucas, any thoughts? >>> >>> It is not clear to me what the device_link_del_dev(consumer, supplier) would do. >> >> It would delete a link between consumer and supplier. > > If there's one I suppose. > > I'm wondering if you are somehow trying to address the same problem as the > device links reference counting patch from Lukas that has been queued up for 4.17 > already. Not quite - the issue here is that we have one supplier with an arbitrarily large number of consumers, and would prefer that supplier not to have to spend a whole bunch of memory to store all the struct device_link pointers for the sole reason of having something to give to device_link_del() at the end, given that the device links code is already keeping track of everything internally anyway. The current API would permit doing this: iommu_attach(dev) { ... if (!device_link_add(dev, iommu, IOMMU_LINK_FLAGS)) return -ENODEV; ... } iommu_detach(dev) { ... // Will return the existing link from earlier link = device_link_add(dev, iommu, IOMMU_LINK_FLAGS); device_link_del(link); // Needed once refcounting is in place //device_link_del(link); ... } but it looks so wacky and non-obvious that we'd like to encapsulate the same behaviour into a more formal interface (my personal naming preference would be device_link_remove(consumer, supplier)). Robin. -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Mar 14, 2018 at 12:12:05PM +0100, Rafael J. Wysocki wrote: > On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: > > On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > > > On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: > > >> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > > >>> The lists managing the device-links can be traversed to > > >>> find the link between two devices. The device_link_add() APIs > > >>> does traverse these lists to check if there's already a link > > >>> setup between the two devices. > > >>> So, add a new APIs, device_link_find(), to find an existing > > >>> device link between two devices - suppliers and consumers. > > >> > > >> I'm wondering if this API would be useful for anything else that the > > >> problem we're trying to solve with deleting links without storing them > > >> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a > > >> better alternative? > > > > > > Yea, that sounds simpler i think. Will add this API instead of > > > find_link(). Thanks. > > > > Perhaps let's wait for a moment to see if there are other opinions. :) > > > > Rafael, Lucas, any thoughts? > > It is not clear to me what the device_link_del_dev(consumer, supplier) > would do. The point appears to be that the pointer to the device_link need not be stored somewhere for later deletion. The newly added function would check if a device link exists and delete it if so. However I don't understand why storing the pointer would be a problem? Also, would using DL_FLAG_AUTOREMOVE avoid the need for the additional function? Thanks, Lukas -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Wed, Mar 14, 2018 at 12:14:15PM +0000, Robin Murphy wrote: > >>On Wed, Mar 14, 2018 at 8:12 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: > >>>On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: > >>>>On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > >>>>>On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: > >>>>>>On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: > >>>>>>>The lists managing the device-links can be traversed to > >>>>>>>find the link between two devices. The device_link_add() APIs > >>>>>>>does traverse these lists to check if there's already a link > >>>>>>>setup between the two devices. > >>>>>>>So, add a new APIs, device_link_find(), to find an existing > >>>>>>>device link between two devices - suppliers and consumers. > >>>>>> > >>>>>>I'm wondering if this API would be useful for anything else that the > >>>>>>problem we're trying to solve with deleting links without storing them > >>>>>>anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a > >>>>>>better alternative? > >>>>> > >>>>>Yea, that sounds simpler i think. Will add this API instead of > >>>>>find_link(). Thanks. > >>>> > >>>>Perhaps let's wait for a moment to see if there are other opinions. :) > >>>> > >>>>Rafael, Lucas, any thoughts? > >>> > >>>It is not clear to me what the device_link_del_dev(consumer, supplier) > >>>would do. > > Not quite - the issue here is that we have one supplier with an arbitrarily > large number of consumers, and would prefer that supplier not to have to > spend a whole bunch of memory to store all the struct device_link pointers > for the sole reason of having something to give to device_link_del() at the > end, given that the device links code is already keeping track of everything > internally anyway. Makes sense to me. How about an additional flag which autoremoves the link on provider unbind? Thanks, Lukas -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 13/03/18 08:55, Vivek Gautam wrote: > From: Sricharan R <sricharan@codeaurora.org> > > The smmu device probe/remove and add/remove master device callbacks > gets called when the smmu is not linked to its master, that is without > the context of the master device. So calling runtime apis in those places > separately. > > Signed-off-by: Sricharan R <sricharan@codeaurora.org> > [vivek: Cleanup pm runtime calls] > Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> > Reviewed-by: Tomasz Figa <tfiga@chromium.org> > --- > drivers/iommu/arm-smmu.c | 95 ++++++++++++++++++++++++++++++++++++++++++++---- > 1 file changed, 87 insertions(+), 8 deletions(-) > > diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c > index d5873d545024..56a04ae80bf3 100644 > --- a/drivers/iommu/arm-smmu.c > +++ b/drivers/iommu/arm-smmu.c > @@ -268,6 +268,20 @@ static struct arm_smmu_option_prop arm_smmu_options[] = { > { 0, NULL}, > }; > > +static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) > +{ > + if (pm_runtime_enabled(smmu->dev)) > + return pm_runtime_get_sync(smmu->dev); > + > + return 0; > +} > + > +static inline void arm_smmu_rpm_put(struct arm_smmu_device *smmu) > +{ > + if (pm_runtime_enabled(smmu->dev)) > + pm_runtime_put(smmu->dev); > +} > + > static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom) > { > return container_of(dom, struct arm_smmu_domain, domain); > @@ -913,11 +927,15 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) > struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); > struct arm_smmu_device *smmu = smmu_domain->smmu; > struct arm_smmu_cfg *cfg = &smmu_domain->cfg; > - int irq; > + int ret, irq; > > if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) > return; > > + ret = arm_smmu_rpm_get(smmu); > + if (ret < 0) > + return; > + > /* > * Disable the context bank and free the page tables before freeing > * it. > @@ -932,6 +950,8 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain) > > free_io_pgtable_ops(smmu_domain->pgtbl_ops); > __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); > + > + arm_smmu_rpm_put(smmu); > } > > static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) > @@ -1213,10 +1233,15 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) > return -ENODEV; > > smmu = fwspec_smmu(fwspec); > + > + ret = arm_smmu_rpm_get(smmu); > + if (ret < 0) > + return ret; > + > /* Ensure that the domain is finalised */ > ret = arm_smmu_init_domain_context(domain, smmu); > if (ret < 0) > - return ret; > + goto rpm_put; > > /* > * Sanity check the domain. We don't support domains across > @@ -1230,29 +1255,47 @@ static int arm_smmu_attach_dev(struct iommu_domain *domain, struct device *dev) > } > > /* Looks ok, so add the device to the domain */ > - return arm_smmu_domain_add_master(smmu_domain, fwspec); > + ret = arm_smmu_domain_add_master(smmu_domain, fwspec); > + > +rpm_put: > + arm_smmu_rpm_put(smmu); > + return ret; > } > > static int arm_smmu_map(struct iommu_domain *domain, unsigned long iova, > phys_addr_t paddr, size_t size, int prot) > { > struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; > + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); > + struct arm_smmu_device *smmu = smmu_domain->smmu; Nit: please use arm_smmu_domain for ops as well (as it was before 523d7423e21b), or consistently elide it for smmu - the mixture of both methods is just a horrible mess (here and in unmap). > + int ret; > > if (!ops) > return -ENODEV; > > - return ops->map(ops, iova, paddr, size, prot); > + arm_smmu_rpm_get(smmu); > + ret = ops->map(ops, iova, paddr, size, prot); > + arm_smmu_rpm_put(smmu); > + > + return ret; > } > > static size_t arm_smmu_unmap(struct iommu_domain *domain, unsigned long iova, > size_t size) > { > struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; > + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); > + struct arm_smmu_device *smmu = smmu_domain->smmu; > + size_t ret; > > if (!ops) > return 0; > > - return ops->unmap(ops, iova, size); > + arm_smmu_rpm_get(smmu); > + ret = ops->unmap(ops, iova, size); > + arm_smmu_rpm_put(smmu); > + > + return ret; > } > > static void arm_smmu_iotlb_sync(struct iommu_domain *domain) > @@ -1407,14 +1450,22 @@ static int arm_smmu_add_device(struct device *dev) > while (i--) > cfg->smendx[i] = INVALID_SMENDX; > > + ret = arm_smmu_rpm_get(smmu); > + if (ret < 0) > + goto out_cfg_free; > + > ret = arm_smmu_master_alloc_smes(dev); Nit: it would be easier to just do the rpm_put here; then you don't need to mess with the cleanup path. > if (ret) > - goto out_cfg_free; > + goto out_rpm_put; > > iommu_device_link(&smmu->iommu, dev); > > + arm_smmu_rpm_put(smmu); > + > return 0; > > +out_rpm_put: > + arm_smmu_rpm_put(smmu); > out_cfg_free: > kfree(cfg); > out_free: > @@ -1427,7 +1478,7 @@ static void arm_smmu_remove_device(struct device *dev) > struct iommu_fwspec *fwspec = dev->iommu_fwspec; > struct arm_smmu_master_cfg *cfg; > struct arm_smmu_device *smmu; > - > + int ret; > > if (!fwspec || fwspec->ops != &arm_smmu_ops) > return; > @@ -1435,8 +1486,15 @@ static void arm_smmu_remove_device(struct device *dev) > cfg = fwspec->iommu_priv; > smmu = cfg->smmu; > > + ret = arm_smmu_rpm_get(smmu); > + if (ret < 0) > + return; > + > iommu_device_unlink(&smmu->iommu, dev); > arm_smmu_master_free_smes(fwspec); > + > + arm_smmu_rpm_put(smmu); > + > iommu_group_remove_device(dev); > kfree(fwspec->iommu_priv); > iommu_fwspec_free(dev); > @@ -2124,6 +2182,8 @@ static int arm_smmu_device_probe(struct platform_device *pdev) > smmu->irqs[i] = irq; > } > > + platform_set_drvdata(pdev, smmu); > + > err = devm_clk_bulk_get(smmu->dev, smmu->num_clks, smmu->clks); > if (err) > return err; > @@ -2132,6 +2192,19 @@ static int arm_smmu_device_probe(struct platform_device *pdev) > if (err) > return err; > > + /* > + * We want to avoid touching dev->power.lock in fastpaths unless > + * it's really going to do something useful - pm_runtime_enabled() > + * can serve as an ideal proxy for that decision. So, conditionally > + * enable pm_runtime. > + */ > + if (dev->pm_domain) > + pm_runtime_enable(dev); > + > + err = arm_smmu_rpm_get(smmu); > + if (err < 0) > + return err; > + > err = arm_smmu_device_cfg_probe(smmu); > if (err) > return err; > @@ -2173,10 +2246,11 @@ static int arm_smmu_device_probe(struct platform_device *pdev) > return err; > } > > - platform_set_drvdata(pdev, smmu); > arm_smmu_device_reset(smmu); > arm_smmu_test_smr_masks(smmu); > > + arm_smmu_rpm_put(smmu); > + > /* > * For ACPI and generic DT bindings, an SMMU will be probed before > * any device which might need it, so we want the bus ops in place > @@ -2212,8 +2286,13 @@ static int arm_smmu_device_remove(struct platform_device *pdev) > if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) > dev_err(&pdev->dev, "removing device with active domains!\n"); > > + arm_smmu_rpm_get(smmu); > /* Turn the thing off */ > writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); > + arm_smmu_rpm_put(smmu); > + > + if (pm_runtime_enabled(smmu->dev)) > + pm_runtime_disable(smmu->dev); > > clk_bulk_unprepare(smmu->num_clks, smmu->clks); > I don't know how runtime and system PM interact - does the reset in arm_smmu_pm_resume need special treatment as well, or is the device guaranteed to be powered up at that point by other means? Robin. -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 13/03/18 08:55, Vivek Gautam wrote: > From: Sricharan R <sricharan@codeaurora.org> > > Finally add the device link between the master device and > smmu, so that the smmu gets runtime enabled/disabled only when the > master needs it. This is done from add_device callback which gets > called once when the master is added to the smmu. > > Signed-off-by: Sricharan R <sricharan@codeaurora.org> > Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> > Reviewed-by: Tomasz Figa <tfiga@chromium.org> > --- > drivers/iommu/arm-smmu.c | 29 +++++++++++++++++++++++++++++ > 1 file changed, 29 insertions(+) > > diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c > index 56a04ae80bf3..64953ff2281f 100644 > --- a/drivers/iommu/arm-smmu.c > +++ b/drivers/iommu/arm-smmu.c > @@ -1460,10 +1460,31 @@ static int arm_smmu_add_device(struct device *dev) > > iommu_device_link(&smmu->iommu, dev); > > + if (pm_runtime_enabled(smmu->dev)) { > + struct device_link *link; > + > + /* > + * Establish the link between smmu and master, so that the > + * smmu gets runtime enabled/disabled as per the master's > + * needs. > + */ > + link = device_link_add(dev, smmu->dev, DL_FLAG_PM_RUNTIME); > + if (!link) { FWIW, given that we don't really care about link itself, I'd be quite happy to simplify that lot down to: if (pm_runtime_enabled(smmu_dev) && !device_link_add(dev, smmu->dev, DL_FLAG_PM_RUNTIME)) { > + dev_warn(smmu->dev, > + "Unable to add link to the consumer %s\n", > + dev_name(dev)); (side note: since device_link_add() already prints a message on success, maybe it could print its own failure message too?) Robin. > + ret = -ENODEV; > + goto out_unlink; > + } > + } > + > arm_smmu_rpm_put(smmu); > > return 0; > > +out_unlink: > + iommu_device_unlink(&smmu->iommu, dev); > + arm_smmu_master_free_smes(fwspec); > out_rpm_put: > arm_smmu_rpm_put(smmu); > out_cfg_free: > @@ -1486,6 +1507,14 @@ static void arm_smmu_remove_device(struct device *dev) > cfg = fwspec->iommu_priv; > smmu = cfg->smmu; > > + if (pm_runtime_enabled(smmu->dev)) { > + struct device_link *link; > + > + link = device_link_find(dev, smmu->dev); > + if (link) > + device_link_del(link); > + } > + > ret = arm_smmu_rpm_get(smmu); > if (ret < 0) > return; > -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Thu, Mar 15, 2018 at 2:50 AM, Robin Murphy <robin.murphy@arm.com> wrote: > On 13/03/18 08:55, Vivek Gautam wrote: >> >> From: Sricharan R <sricharan@codeaurora.org> >> >> Finally add the device link between the master device and >> smmu, so that the smmu gets runtime enabled/disabled only when the >> master needs it. This is done from add_device callback which gets >> called once when the master is added to the smmu. >> >> Signed-off-by: Sricharan R <sricharan@codeaurora.org> >> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >> Reviewed-by: Tomasz Figa <tfiga@chromium.org> >> --- >> drivers/iommu/arm-smmu.c | 29 +++++++++++++++++++++++++++++ >> 1 file changed, 29 insertions(+) >> >> diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c >> index 56a04ae80bf3..64953ff2281f 100644 >> --- a/drivers/iommu/arm-smmu.c >> +++ b/drivers/iommu/arm-smmu.c >> @@ -1460,10 +1460,31 @@ static int arm_smmu_add_device(struct device *dev) >> iommu_device_link(&smmu->iommu, dev); >> + if (pm_runtime_enabled(smmu->dev)) { >> + struct device_link *link; >> + >> + /* >> + * Establish the link between smmu and master, so that the >> + * smmu gets runtime enabled/disabled as per the master's >> + * needs. >> + */ >> + link = device_link_add(dev, smmu->dev, >> DL_FLAG_PM_RUNTIME); >> + if (!link) { > > > FWIW, given that we don't really care about link itself, I'd be quite happy > to simplify that lot down to: > > if (pm_runtime_enabled(smmu_dev) && > !device_link_add(dev, smmu->dev, DL_FLAG_PM_RUNTIME)) { > >> + dev_warn(smmu->dev, >> + "Unable to add link to the consumer >> %s\n", >> + dev_name(dev)); > > > (side note: since device_link_add() already prints a message on success, > maybe it could print its own failure message too?) I think we care whether adding the link succeeded. If it fails to be added, we might end up with a complete system lockup on a system with power domains. Best regards, Tomasz -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Thu, Mar 15, 2018 at 2:46 AM, Robin Murphy <robin.murphy@arm.com> wrote: > On 13/03/18 08:55, Vivek Gautam wrote: >> >> From: Sricharan R <sricharan@codeaurora.org> >> >> The smmu device probe/remove and add/remove master device callbacks >> gets called when the smmu is not linked to its master, that is without >> the context of the master device. So calling runtime apis in those places >> separately. >> >> Signed-off-by: Sricharan R <sricharan@codeaurora.org> >> [vivek: Cleanup pm runtime calls] >> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >> Reviewed-by: Tomasz Figa <tfiga@chromium.org> >> --- >> drivers/iommu/arm-smmu.c | 95 >> ++++++++++++++++++++++++++++++++++++++++++++---- >> 1 file changed, 87 insertions(+), 8 deletions(-) >> >> diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c >> index d5873d545024..56a04ae80bf3 100644 >> --- a/drivers/iommu/arm-smmu.c >> +++ b/drivers/iommu/arm-smmu.c >> @@ -268,6 +268,20 @@ static struct arm_smmu_option_prop arm_smmu_options[] >> = { >> { 0, NULL}, >> }; >> +static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) >> +{ >> + if (pm_runtime_enabled(smmu->dev)) >> + return pm_runtime_get_sync(smmu->dev); >> + >> + return 0; >> +} >> + >> +static inline void arm_smmu_rpm_put(struct arm_smmu_device *smmu) >> +{ >> + if (pm_runtime_enabled(smmu->dev)) >> + pm_runtime_put(smmu->dev); >> +} >> + >> static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain *dom) >> { >> return container_of(dom, struct arm_smmu_domain, domain); >> @@ -913,11 +927,15 @@ static void arm_smmu_destroy_domain_context(struct >> iommu_domain *domain) >> struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> struct arm_smmu_device *smmu = smmu_domain->smmu; >> struct arm_smmu_cfg *cfg = &smmu_domain->cfg; >> - int irq; >> + int ret, irq; >> if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) >> return; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return; >> + >> /* >> * Disable the context bank and free the page tables before >> freeing >> * it. >> @@ -932,6 +950,8 @@ static void arm_smmu_destroy_domain_context(struct >> iommu_domain *domain) >> free_io_pgtable_ops(smmu_domain->pgtbl_ops); >> __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); >> + >> + arm_smmu_rpm_put(smmu); >> } >> static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) >> @@ -1213,10 +1233,15 @@ static int arm_smmu_attach_dev(struct iommu_domain >> *domain, struct device *dev) >> return -ENODEV; >> smmu = fwspec_smmu(fwspec); >> + >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return ret; >> + >> /* Ensure that the domain is finalised */ >> ret = arm_smmu_init_domain_context(domain, smmu); >> if (ret < 0) >> - return ret; >> + goto rpm_put; >> /* >> * Sanity check the domain. We don't support domains across >> @@ -1230,29 +1255,47 @@ static int arm_smmu_attach_dev(struct iommu_domain >> *domain, struct device *dev) >> } >> /* Looks ok, so add the device to the domain */ >> - return arm_smmu_domain_add_master(smmu_domain, fwspec); >> + ret = arm_smmu_domain_add_master(smmu_domain, fwspec); >> + >> +rpm_put: >> + arm_smmu_rpm_put(smmu); >> + return ret; >> } >> static int arm_smmu_map(struct iommu_domain *domain, unsigned long >> iova, >> phys_addr_t paddr, size_t size, int prot) >> { >> struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; >> + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> + struct arm_smmu_device *smmu = smmu_domain->smmu; > > > Nit: please use arm_smmu_domain for ops as well (as it was before > 523d7423e21b), or consistently elide it for smmu - the mixture of both > methods is just a horrible mess (here and in unmap). > > >> + int ret; >> if (!ops) >> return -ENODEV; >> - return ops->map(ops, iova, paddr, size, prot); >> + arm_smmu_rpm_get(smmu); >> + ret = ops->map(ops, iova, paddr, size, prot); >> + arm_smmu_rpm_put(smmu); >> + >> + return ret; >> } >> static size_t arm_smmu_unmap(struct iommu_domain *domain, unsigned >> long iova, >> size_t size) >> { >> struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; >> + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> + struct arm_smmu_device *smmu = smmu_domain->smmu; >> + size_t ret; >> if (!ops) >> return 0; >> - return ops->unmap(ops, iova, size); >> + arm_smmu_rpm_get(smmu); >> + ret = ops->unmap(ops, iova, size); >> + arm_smmu_rpm_put(smmu); >> + >> + return ret; >> } >> static void arm_smmu_iotlb_sync(struct iommu_domain *domain) >> @@ -1407,14 +1450,22 @@ static int arm_smmu_add_device(struct device *dev) >> while (i--) >> cfg->smendx[i] = INVALID_SMENDX; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + goto out_cfg_free; >> + >> ret = arm_smmu_master_alloc_smes(dev); > > > Nit: it would be easier to just do the rpm_put here; then you don't need to > mess with the cleanup path. > > >> if (ret) >> - goto out_cfg_free; >> + goto out_rpm_put; >> iommu_device_link(&smmu->iommu, dev); >> + arm_smmu_rpm_put(smmu); >> + >> return 0; >> +out_rpm_put: >> + arm_smmu_rpm_put(smmu); >> out_cfg_free: >> kfree(cfg); >> out_free: >> @@ -1427,7 +1478,7 @@ static void arm_smmu_remove_device(struct device >> *dev) >> struct iommu_fwspec *fwspec = dev->iommu_fwspec; >> struct arm_smmu_master_cfg *cfg; >> struct arm_smmu_device *smmu; >> - >> + int ret; >> if (!fwspec || fwspec->ops != &arm_smmu_ops) >> return; >> @@ -1435,8 +1486,15 @@ static void arm_smmu_remove_device(struct device >> *dev) >> cfg = fwspec->iommu_priv; >> smmu = cfg->smmu; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return; >> + >> iommu_device_unlink(&smmu->iommu, dev); >> arm_smmu_master_free_smes(fwspec); >> + >> + arm_smmu_rpm_put(smmu); >> + >> iommu_group_remove_device(dev); >> kfree(fwspec->iommu_priv); >> iommu_fwspec_free(dev); >> @@ -2124,6 +2182,8 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> smmu->irqs[i] = irq; >> } >> + platform_set_drvdata(pdev, smmu); >> + >> err = devm_clk_bulk_get(smmu->dev, smmu->num_clks, smmu->clks); >> if (err) >> return err; >> @@ -2132,6 +2192,19 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> if (err) >> return err; >> + /* >> + * We want to avoid touching dev->power.lock in fastpaths unless >> + * it's really going to do something useful - pm_runtime_enabled() >> + * can serve as an ideal proxy for that decision. So, >> conditionally >> + * enable pm_runtime. >> + */ >> + if (dev->pm_domain) >> + pm_runtime_enable(dev); >> + >> + err = arm_smmu_rpm_get(smmu); >> + if (err < 0) >> + return err; >> + >> err = arm_smmu_device_cfg_probe(smmu); >> if (err) >> return err; >> @@ -2173,10 +2246,11 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> return err; >> } >> - platform_set_drvdata(pdev, smmu); >> arm_smmu_device_reset(smmu); >> arm_smmu_test_smr_masks(smmu); >> + arm_smmu_rpm_put(smmu); >> + >> /* >> * For ACPI and generic DT bindings, an SMMU will be probed before >> * any device which might need it, so we want the bus ops in place >> @@ -2212,8 +2286,13 @@ static int arm_smmu_device_remove(struct >> platform_device *pdev) >> if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) >> dev_err(&pdev->dev, "removing device with active >> domains!\n"); >> + arm_smmu_rpm_get(smmu); >> /* Turn the thing off */ >> writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); >> + arm_smmu_rpm_put(smmu); >> + >> + if (pm_runtime_enabled(smmu->dev)) >> + pm_runtime_disable(smmu->dev); >> clk_bulk_unprepare(smmu->num_clks, smmu->clks); >> > > > I don't know how runtime and system PM interact - does the reset in > arm_smmu_pm_resume need special treatment as well, or is the device > guaranteed to be powered up at that point by other means? Actually, it's quite complicated... 1) device_prepare(), prevents suspending active devices by getting a runtime enable count [1] and then, depending on whether there is a prepare callback that could be called for this device [2] or the device doesn't have any PM callbacks [3], it might set the "direct_complete" flag [4]. 2) Later, when device_suspend() is called, if "direct_complete" is set (and disabling runtime PM ends up with the device still runtime-suspended) [5], the .suspend callback will be skipped. If "direct_complete" is not set (or direct complete fails), the suspend callback (if one exists) would be called regardless of runtime PM state of the device [6]. 3) During system resume, if "direct_complete" was set, the resume callback would be completely skipped [7]. Otherwise it would be called without any special conditions [8]. 4) At the end of the whole process, device_complete() would put the remaining reference count and potentially trigger a runtime idle and suspend, if the device was active. [9] Now, the behavior of what happens past 2) and before 3) is affected by PM domain callbacks, namely prepare, suspend_noirq and resume_noirq. For genpd, genpd_prepare() never returns a positive value, so "direct_complete" would never happen [10]. genpd_finish_suspend() [11], called from genpd_suspend_noirq(), attempts to cut off the power, while genpd_resume_noirq() restore it [12], so it looks like the power would be on during the SMMU resume callback. [1] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1671 [2] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1688 [3] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1683 [4] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1719 [5] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1492 [6] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1506 [7] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L833 [8] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L888 [9] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/main.c#L1012 [10] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/domain.c#L1019 [11] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/domain.c#L1032 [12] https://elixir.bootlin.com/linux/latest/source/drivers/base/power/domain.c#L1085 Phew. This is still with skipped wake up capability handling, since SMMU doesn't have such. Best regards, Tomasz -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Robin, On Wed, Mar 14, 2018 at 11:20 PM, Robin Murphy <robin.murphy@arm.com> wrote: > On 13/03/18 08:55, Vivek Gautam wrote: >> >> From: Sricharan R <sricharan@codeaurora.org> >> >> Finally add the device link between the master device and >> smmu, so that the smmu gets runtime enabled/disabled only when the >> master needs it. This is done from add_device callback which gets >> called once when the master is added to the smmu. >> >> Signed-off-by: Sricharan R <sricharan@codeaurora.org> >> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >> Reviewed-by: Tomasz Figa <tfiga@chromium.org> >> --- >> drivers/iommu/arm-smmu.c | 29 +++++++++++++++++++++++++++++ >> 1 file changed, 29 insertions(+) >> >> diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c >> index 56a04ae80bf3..64953ff2281f 100644 >> --- a/drivers/iommu/arm-smmu.c >> +++ b/drivers/iommu/arm-smmu.c >> @@ -1460,10 +1460,31 @@ static int arm_smmu_add_device(struct device *dev) >> iommu_device_link(&smmu->iommu, dev); >> + if (pm_runtime_enabled(smmu->dev)) { >> + struct device_link *link; >> + >> + /* >> + * Establish the link between smmu and master, so that the >> + * smmu gets runtime enabled/disabled as per the master's >> + * needs. >> + */ >> + link = device_link_add(dev, smmu->dev, >> DL_FLAG_PM_RUNTIME); >> + if (!link) { > > > FWIW, given that we don't really care about link itself, I'd be quite happy > to simplify that lot down to: > > if (pm_runtime_enabled(smmu_dev) && > !device_link_add(dev, smmu->dev, DL_FLAG_PM_RUNTIME)) { Sure, will update this. > >> + dev_warn(smmu->dev, >> + "Unable to add link to the consumer >> %s\n", >> + dev_name(dev)); > > > (side note: since device_link_add() already prints a message on success, > maybe it could print its own failure message too?) Should we make device_link that verbose - to print failure messages at each step (there are atleast a couple where we return link as NULL), or we can let the users handle printing the message? regards Vivek > > Robin. > > >> + ret = -ENODEV; >> + goto out_unlink; >> + } >> + } >> + >> arm_smmu_rpm_put(smmu); >> return 0; >> +out_unlink: >> + iommu_device_unlink(&smmu->iommu, dev); >> + arm_smmu_master_free_smes(fwspec); >> out_rpm_put: >> arm_smmu_rpm_put(smmu); >> out_cfg_free: >> @@ -1486,6 +1507,14 @@ static void arm_smmu_remove_device(struct device >> *dev) >> cfg = fwspec->iommu_priv; >> smmu = cfg->smmu; >> + if (pm_runtime_enabled(smmu->dev)) { >> + struct device_link *link; >> + >> + link = device_link_find(dev, smmu->dev); >> + if (link) >> + device_link_del(link); >> + } >> + >> ret = arm_smmu_rpm_get(smmu); >> if (ret < 0) >> return; >> >
On 15/03/18 06:18, Tomasz Figa wrote: > On Thu, Mar 15, 2018 at 2:50 AM, Robin Murphy <robin.murphy@arm.com> wrote: >> On 13/03/18 08:55, Vivek Gautam wrote: >>> >>> From: Sricharan R <sricharan@codeaurora.org> >>> >>> Finally add the device link between the master device and >>> smmu, so that the smmu gets runtime enabled/disabled only when the >>> master needs it. This is done from add_device callback which gets >>> called once when the master is added to the smmu. >>> >>> Signed-off-by: Sricharan R <sricharan@codeaurora.org> >>> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >>> Reviewed-by: Tomasz Figa <tfiga@chromium.org> >>> --- >>> drivers/iommu/arm-smmu.c | 29 +++++++++++++++++++++++++++++ >>> 1 file changed, 29 insertions(+) >>> >>> diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c >>> index 56a04ae80bf3..64953ff2281f 100644 >>> --- a/drivers/iommu/arm-smmu.c >>> +++ b/drivers/iommu/arm-smmu.c >>> @@ -1460,10 +1460,31 @@ static int arm_smmu_add_device(struct device *dev) >>> iommu_device_link(&smmu->iommu, dev); >>> + if (pm_runtime_enabled(smmu->dev)) { >>> + struct device_link *link; >>> + >>> + /* >>> + * Establish the link between smmu and master, so that the >>> + * smmu gets runtime enabled/disabled as per the master's >>> + * needs. >>> + */ >>> + link = device_link_add(dev, smmu->dev, >>> DL_FLAG_PM_RUNTIME); >>> + if (!link) { >> >> >> FWIW, given that we don't really care about link itself, I'd be quite happy >> to simplify that lot down to: >> >> if (pm_runtime_enabled(smmu_dev) && >> !device_link_add(dev, smmu->dev, DL_FLAG_PM_RUNTIME)) { >> >>> + dev_warn(smmu->dev, >>> + "Unable to add link to the consumer >>> %s\n", >>> + dev_name(dev)); >> >> >> (side note: since device_link_add() already prints a message on success, >> maybe it could print its own failure message too?) > > I think we care whether adding the link succeeded. If it fails to be > added, we might end up with a complete system lockup on a system with > power domains. Well, yeah, that was implicit - the point is that we *only* care about whether it succeeded or not. Thus we may as well just check for NULL directly instead of assigning the value as if we were actually going to do anything with it. Robin. -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Lukasz, On 3/14/2018 5:57 PM, Lukas Wunner wrote: > On Wed, Mar 14, 2018 at 12:14:15PM +0000, Robin Murphy wrote: >>>> On Wed, Mar 14, 2018 at 8:12 PM, Rafael J. Wysocki <rjw@rjwysocki.net> wrote: >>>>> On Tuesday, March 13, 2018 12:23:34 PM CET Tomasz Figa wrote: >>>>>> On Tue, Mar 13, 2018 at 7:34 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: >>>>>>> On Tue, Mar 13, 2018 at 3:45 PM, Tomasz Figa <tfiga@chromium.org> wrote: >>>>>>>> On Tue, Mar 13, 2018 at 5:55 PM, Vivek Gautam <vivek.gautam@codeaurora.org> wrote: >>>>>>>>> The lists managing the device-links can be traversed to >>>>>>>>> find the link between two devices. The device_link_add() APIs >>>>>>>>> does traverse these lists to check if there's already a link >>>>>>>>> setup between the two devices. >>>>>>>>> So, add a new APIs, device_link_find(), to find an existing >>>>>>>>> device link between two devices - suppliers and consumers. >>>>>>>> I'm wondering if this API would be useful for anything else that the >>>>>>>> problem we're trying to solve with deleting links without storing them >>>>>>>> anywhere. Perhaps a device_link_del_dev(consumer, supplier) would be a >>>>>>>> better alternative? >>>>>>> Yea, that sounds simpler i think. Will add this API instead of >>>>>>> find_link(). Thanks. >>>>>> Perhaps let's wait for a moment to see if there are other opinions. :) >>>>>> >>>>>> Rafael, Lucas, any thoughts? >>>>> It is not clear to me what the device_link_del_dev(consumer, supplier) >>>>> would do. >> Not quite - the issue here is that we have one supplier with an arbitrarily >> large number of consumers, and would prefer that supplier not to have to >> spend a whole bunch of memory to store all the struct device_link pointers >> for the sole reason of having something to give to device_link_del() at the >> end, given that the device links code is already keeping track of everything >> internally anyway. > Makes sense to me. How about an additional flag which autoremoves the > link on provider unbind? If I understand this correctly, if we create the device link with DL_FLAG_AUTOREMOVE, the link is deleted after a consumer unbind. During a supplier unbind all we get is a WARN_ON with DL_FLAG_AUTOREMOVE. I guess that's an intended behavior? If this is the case, then the consumer/supplier drivers just don't have to take care of deleting the device link explicitly. Is my understanding correct? regards Vivek > > Thanks, > > Lukas -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Robin, On 3/14/2018 11:16 PM, Robin Murphy wrote: > On 13/03/18 08:55, Vivek Gautam wrote: >> From: Sricharan R <sricharan@codeaurora.org> >> >> The smmu device probe/remove and add/remove master device callbacks >> gets called when the smmu is not linked to its master, that is without >> the context of the master device. So calling runtime apis in those >> places >> separately. >> >> Signed-off-by: Sricharan R <sricharan@codeaurora.org> >> [vivek: Cleanup pm runtime calls] >> Signed-off-by: Vivek Gautam <vivek.gautam@codeaurora.org> >> Reviewed-by: Tomasz Figa <tfiga@chromium.org> >> --- >> drivers/iommu/arm-smmu.c | 95 >> ++++++++++++++++++++++++++++++++++++++++++++---- >> 1 file changed, 87 insertions(+), 8 deletions(-) >> >> diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c >> index d5873d545024..56a04ae80bf3 100644 >> --- a/drivers/iommu/arm-smmu.c >> +++ b/drivers/iommu/arm-smmu.c >> @@ -268,6 +268,20 @@ static struct arm_smmu_option_prop >> arm_smmu_options[] = { >> { 0, NULL}, >> }; >> +static inline int arm_smmu_rpm_get(struct arm_smmu_device *smmu) >> +{ >> + if (pm_runtime_enabled(smmu->dev)) >> + return pm_runtime_get_sync(smmu->dev); >> + >> + return 0; >> +} >> + >> +static inline void arm_smmu_rpm_put(struct arm_smmu_device *smmu) >> +{ >> + if (pm_runtime_enabled(smmu->dev)) >> + pm_runtime_put(smmu->dev); >> +} >> + >> static struct arm_smmu_domain *to_smmu_domain(struct iommu_domain >> *dom) >> { >> return container_of(dom, struct arm_smmu_domain, domain); >> @@ -913,11 +927,15 @@ static void >> arm_smmu_destroy_domain_context(struct iommu_domain *domain) >> struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> struct arm_smmu_device *smmu = smmu_domain->smmu; >> struct arm_smmu_cfg *cfg = &smmu_domain->cfg; >> - int irq; >> + int ret, irq; >> if (!smmu || domain->type == IOMMU_DOMAIN_IDENTITY) >> return; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return; >> + >> /* >> * Disable the context bank and free the page tables before >> freeing >> * it. >> @@ -932,6 +950,8 @@ static void >> arm_smmu_destroy_domain_context(struct iommu_domain *domain) >> free_io_pgtable_ops(smmu_domain->pgtbl_ops); >> __arm_smmu_free_bitmap(smmu->context_map, cfg->cbndx); >> + >> + arm_smmu_rpm_put(smmu); >> } >> static struct iommu_domain *arm_smmu_domain_alloc(unsigned type) >> @@ -1213,10 +1233,15 @@ static int arm_smmu_attach_dev(struct >> iommu_domain *domain, struct device *dev) >> return -ENODEV; >> smmu = fwspec_smmu(fwspec); >> + >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return ret; >> + >> /* Ensure that the domain is finalised */ >> ret = arm_smmu_init_domain_context(domain, smmu); >> if (ret < 0) >> - return ret; >> + goto rpm_put; >> /* >> * Sanity check the domain. We don't support domains across >> @@ -1230,29 +1255,47 @@ static int arm_smmu_attach_dev(struct >> iommu_domain *domain, struct device *dev) >> } >> /* Looks ok, so add the device to the domain */ >> - return arm_smmu_domain_add_master(smmu_domain, fwspec); >> + ret = arm_smmu_domain_add_master(smmu_domain, fwspec); >> + >> +rpm_put: >> + arm_smmu_rpm_put(smmu); >> + return ret; >> } >> static int arm_smmu_map(struct iommu_domain *domain, unsigned >> long iova, >> phys_addr_t paddr, size_t size, int prot) >> { >> struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; >> + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> + struct arm_smmu_device *smmu = smmu_domain->smmu; > > Nit: please use arm_smmu_domain for ops as well (as it was before > 523d7423e21b), or consistently elide it for smmu - the mixture of both > methods is just a horrible mess (here and in unmap). Sure, will make it consistent for arm_smmu_device (in both places - map/unmap) struct arm_smmu_device *smmu = to_smmu_domain(domain)->smmu; > >> + int ret; >> if (!ops) >> return -ENODEV; >> - return ops->map(ops, iova, paddr, size, prot); >> + arm_smmu_rpm_get(smmu); >> + ret = ops->map(ops, iova, paddr, size, prot); >> + arm_smmu_rpm_put(smmu); >> + >> + return ret; >> } >> static size_t arm_smmu_unmap(struct iommu_domain *domain, >> unsigned long iova, >> size_t size) >> { >> struct io_pgtable_ops *ops = to_smmu_domain(domain)->pgtbl_ops; >> + struct arm_smmu_domain *smmu_domain = to_smmu_domain(domain); >> + struct arm_smmu_device *smmu = smmu_domain->smmu; >> + size_t ret; >> if (!ops) >> return 0; >> - return ops->unmap(ops, iova, size); >> + arm_smmu_rpm_get(smmu); >> + ret = ops->unmap(ops, iova, size); >> + arm_smmu_rpm_put(smmu); >> + >> + return ret; >> } >> static void arm_smmu_iotlb_sync(struct iommu_domain *domain) >> @@ -1407,14 +1450,22 @@ static int arm_smmu_add_device(struct device >> *dev) >> while (i--) >> cfg->smendx[i] = INVALID_SMENDX; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + goto out_cfg_free; >> + >> ret = arm_smmu_master_alloc_smes(dev); > > Nit: it would be easier to just do the rpm_put here; then you don't > need to mess with the cleanup path. Sure, will do that. It will be cleaner. > >> if (ret) >> - goto out_cfg_free; >> + goto out_rpm_put; >> iommu_device_link(&smmu->iommu, dev); >> + arm_smmu_rpm_put(smmu); >> + >> return 0; >> +out_rpm_put: >> + arm_smmu_rpm_put(smmu); >> out_cfg_free: >> kfree(cfg); >> out_free: >> @@ -1427,7 +1478,7 @@ static void arm_smmu_remove_device(struct >> device *dev) >> struct iommu_fwspec *fwspec = dev->iommu_fwspec; >> struct arm_smmu_master_cfg *cfg; >> struct arm_smmu_device *smmu; >> - >> + int ret; >> if (!fwspec || fwspec->ops != &arm_smmu_ops) >> return; >> @@ -1435,8 +1486,15 @@ static void arm_smmu_remove_device(struct >> device *dev) >> cfg = fwspec->iommu_priv; >> smmu = cfg->smmu; >> + ret = arm_smmu_rpm_get(smmu); >> + if (ret < 0) >> + return; >> + >> iommu_device_unlink(&smmu->iommu, dev); >> arm_smmu_master_free_smes(fwspec); >> + >> + arm_smmu_rpm_put(smmu); >> + >> iommu_group_remove_device(dev); >> kfree(fwspec->iommu_priv); >> iommu_fwspec_free(dev); >> @@ -2124,6 +2182,8 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> smmu->irqs[i] = irq; >> } >> + platform_set_drvdata(pdev, smmu); >> + >> err = devm_clk_bulk_get(smmu->dev, smmu->num_clks, smmu->clks); >> if (err) >> return err; >> @@ -2132,6 +2192,19 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> if (err) >> return err; >> + /* >> + * We want to avoid touching dev->power.lock in fastpaths unless >> + * it's really going to do something useful - pm_runtime_enabled() >> + * can serve as an ideal proxy for that decision. So, conditionally >> + * enable pm_runtime. >> + */ >> + if (dev->pm_domain) >> + pm_runtime_enable(dev); >> + >> + err = arm_smmu_rpm_get(smmu); >> + if (err < 0) >> + return err; >> + >> err = arm_smmu_device_cfg_probe(smmu); >> if (err) >> return err; >> @@ -2173,10 +2246,11 @@ static int arm_smmu_device_probe(struct >> platform_device *pdev) >> return err; >> } >> - platform_set_drvdata(pdev, smmu); >> arm_smmu_device_reset(smmu); >> arm_smmu_test_smr_masks(smmu); >> + arm_smmu_rpm_put(smmu); >> + >> /* >> * For ACPI and generic DT bindings, an SMMU will be probed before >> * any device which might need it, so we want the bus ops in place >> @@ -2212,8 +2286,13 @@ static int arm_smmu_device_remove(struct >> platform_device *pdev) >> if (!bitmap_empty(smmu->context_map, ARM_SMMU_MAX_CBS)) >> dev_err(&pdev->dev, "removing device with active domains!\n"); >> + arm_smmu_rpm_get(smmu); >> /* Turn the thing off */ >> writel(sCR0_CLIENTPD, ARM_SMMU_GR0_NS(smmu) + ARM_SMMU_GR0_sCR0); >> + arm_smmu_rpm_put(smmu); >> + >> + if (pm_runtime_enabled(smmu->dev)) >> + pm_runtime_disable(smmu->dev); >> clk_bulk_unprepare(smmu->num_clks, smmu->clks); > > I don't know how runtime and system PM interact - does the reset in > arm_smmu_pm_resume need special treatment as well, or is the device > guaranteed to be powered up at that point by other means? So, as Tomasz wrote, we should be okay with this. Thanks. regards Vivek > > Robin. > -- > To unsubscribe from this list: send the line "unsubscribe > linux-arm-msm" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
This series provides the support for turning on the arm-smmu's clocks/power domains using runtime pm. This is done using the recently introduced device links patches, which lets the smmu's runtime to follow the master's runtime pm, so the smmu remains powered only when the masters use it. As not all implementations support clock/power gating, we are checking for a valid 'smmu->dev's pm_domain' to conditionally enable the runtime power management for such smmu implementations that can support it. This series also adds support for Qcom's arm-smmu-v2 variant that has different clocks and power requirements. Took some reference from the exynos runtime patches [1]. With conditional runtime pm now, we avoid touching dev->power.lock in fastpaths for smmu implementations that don't need to do anything useful with pm_runtime. This lets us to use the much-argued pm_runtime_get_sync/put_sync() calls in map/unmap callbacks so that the clients do not have to worry about handling any of the arm-smmu's power. Previous version of this patch series is @ [5]. [v9] * Removed 'rpm_supported' flag, instead checking on pm_domain to enable runtime pm. * Creating device link only when the runtime pm is enabled, as we don't need a device link besides managing the power dependency between supplier and consumer devices. * Introducing a patch to add device_link_find() API that finds and existing link between supplier and consumer devices. Also, made necessary change to device_link_add() to use this API. * arm_smmu_remove_device() now uses this device_link_find() to find the device link between smmu device and the master device, and then delete this link. * Dropped the destroy_domain_context() fix [8] as it was rather, introducing catastrophically bad problem by destroying 'good dev's domain context. * Added 'Reviwed-by' tag for Tomasz's review. [v8] * Major change - - Added a flag 'rpm_supported' which each platform that supports runtime pm, can enable, and we enable runtime_pm over arm-smmu only when this flag is set. - Adding the conditional pm_runtime_get/put() calls to .map, .unmap and .attach_dev ops. - Dropped the patch [6] that exported pm_runtim_get/put_suupliers(), and also dropped the user driver patch [7] for these APIs. * Clock code further cleanup - doing only clk_bulk_enable() and clk_bulk_disable() in runtime pm callbacks. We shouldn't be taking a slow path (clk_prepare/unprepare()) from these runtime pm callbacks. Thereby, moved clk_bulk_prepare() to arm_smmu_device_probe(), and clk_bulk_unprepare() to arm_smmu_device_remove(). - clk data filling to a common method arm_smmu_fill_clk_data() that fills the clock ids and number of clocks. * Addressed other nits and comments - device_link_add() error path fixed. - Fix for checking negative error value from pm_runtime_get_sync(). - Documentation redo. * Added another patch fixing the error path in arm_smmu_attach_dev() to destroy allocated domain context. [v7] * Addressed review comments given by Robin Murphy - - Added device_link_del() in .remove_device path. - Error path cleanup in arm_smmu_add_device(). - Added pm_runtime_get/put_sync() in .remove path, and replaced pm_runtime_force_suspend() with pm_runtime_disable(). - clk_names cleanup in arm_smmu_init_clks() * Added 'Reviewed-by' given by Rob H. [V6] * Added Ack given by Rafael to first patch in the series. * Addressed Rob Herring's comment for adding soc specific compatible string as well besides 'qcom,smmu-v2'. [V5] * Dropped runtime pm calls from "arm_smmu_unmap" op as discussed over the list [3] for the last patch series. * Added a patch to export pm_runtime_get/put_suppliers() APIs to the series as agreed with Rafael [4]. * Added the related patch for msm drm iommu layer to use pm_runtime_get/put_suppliers() APIs in msm_mmu_funcs. * Dropped arm-mmu500 clock patch since that would break existing platforms. * Changed compatible 'qcom,msm8996-smmu-v2' to 'qcom,smmu-v2' to reflect the IP version rather than the platform on which it is used. The same IP is used across multiple platforms including msm8996, and sdm845 etc. * Using clock bulk APIs to handle the clocks available to the IP as suggested by Stephen Boyd. * The first patch in v4 version of the patch-series: ("iommu/arm-smmu: Fix the error path in arm_smmu_add_device") has already made it to mainline. [V4] * Reworked the clock handling part. We now take clock names as data in the driver for supported compatible versions, and loop over them to get, enable, and disable the clocks. * Using qcom,msm8996 based compatibles for bindings instead of a generic qcom compatible. * Refactor MMU500 patch to just add the necessary clock names data and corresponding bindings. * Added the pm_runtime_get/put() calls in .unmap iommu op (fix added by Stanimir on top of previous patch version. * Added a patch to fix error path in arm_smmu_add_device() * Removed patch 3/5 of V3 patch series that added qcom,smmu-v2 bindings. [V3] * Reworked the patches to keep the clocks init/enabling function separately for each compatible. * Added clocks bindings for MMU40x/500. * Added a new compatible for qcom,smmu-v2 implementation and the clock bindings for the same. * Rebased on top of 4.11-rc1 [V2] * Split the patches little differently. * Addressed comments. * Removed the patch #4 [2] from previous post for arm-smmu context save restore. Planning to post this separately after reworking/addressing Robin's feedback. * Reversed the sequence to disable clocks than enabling. This was required for those cases where the clocks are populated in a dependent order from DT. [1] https://lkml.org/lkml/2016/10/20/70 [2] https://patchwork.kernel.org/patch/9389717/ [3] https://patchwork.kernel.org/patch/10204925/ [4] https://patchwork.kernel.org/patch/10102445/ [5] https://lkml.org/lkml/2018/3/2/325 [6] https://patchwork.kernel.org/patch/10204945/ [7] https://patchwork.kernel.org/patch/10204925/ [8] https://patchwork.kernel.org/patch/10254105/ Sricharan R (3): iommu/arm-smmu: Add pm_runtime/sleep ops iommu/arm-smmu: Invoke pm_runtime during probe, add/remove device iommu/arm-smmu: Add the device_link between masters and smmu Vivek Gautam (2): driver core: Find an existing link between two devices iommu/arm-smmu: Add support for qcom,smmu-v2 variant .../devicetree/bindings/iommu/arm,smmu.txt | 42 +++++ drivers/base/core.c | 30 +++- drivers/iommu/arm-smmu.c | 198 +++++++++++++++++++-- include/linux/device.h | 2 + 4 files changed, 259 insertions(+), 13 deletions(-)