| Message ID | 1510158582-5343-2-git-send-email-okaya@codeaurora.org (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On 11/08/2017 10:29 AM, Sinan Kaya wrote: > +#define HIDMA_MAX_DEV_MATCH 10 > + > +struct hidma_cap { > + const struct of_device_id of[HIDMA_MAX_DEV_MATCH]; > + const struct acpi_device_id acpi[HIDMA_MAX_DEV_MATCH]; > +}; This seems wrong. You're defining an array of size 10, but it only has three elements. And the third element is a sentinel, which is typically used to avoid specifying the size of the array.
On 11/8/2017 11:49 AM, Timur Tabi wrote: > On 11/08/2017 10:29 AM, Sinan Kaya wrote: >> +#define HIDMA_MAX_DEV_MATCH 10 >> + >> +struct hidma_cap { >> + const struct of_device_id of[HIDMA_MAX_DEV_MATCH]; >> + const struct acpi_device_id acpi[HIDMA_MAX_DEV_MATCH]; >> +}; > > This seems wrong. You're defining an array of size 10, but it only has three elements. And the third element is a sentinel, which is typically used to avoid specifying the size of the array. > It is true that I define an array of size 10. It is just some arbitrary number with forward thinking. I don't really have to use it to the maximum today as long as I satisfy the calling conventions. What is important is that the of_device_match() and acpi_device_match() functions will stop searching only if they find an empty element. The {} element. That's the calling semantics of of_device_match() and acpi_device_match(). Besides, C compiler also won't let me put two arrays together like this. struct my_struct { struct some_struct array1[] struct some_struct array2[] }
On 11/08/2017 10:58 AM, Sinan Kaya wrote: > Besides, C compiler also won't let me put two arrays together like this. > > struct my_struct { > struct some_struct array1[] > struct some_struct array2[] > } Why not this: const struct of_device_id hidma_msi_of_ids[] = { {.compatible = "qcom,hidma-1.1",}, {.compatible = "qcom,hidma-1.2",}, {}, }, static const struct acpi_device_id hidma_msi_acpi_ids[] = { {"QCOM8001", QDF2XXX_V1}, {"QCOM8002", QDF2XXX_V2}, {}, }; struct hidma_cap { const struct of_device_id *of; const struct acpi_device_id *acpi; }; static struct hidma_cap hidma_msi_cap = { hidma_msi_of_ids, hidma_msi_acpi_ids } Keep in mind that you also need to add MODULE_DEVICE_TABLE entries, which you can't really do with your approach. MODULE_DEVICE_TABLE(of, hidma_msi_of_ids); MODULE_DEVICE_TABLE(acpi, hidma_msi_acpi_ids);
On 11/8/2017 12:12 PM, Timur Tabi wrote: > On 11/08/2017 10:58 AM, Sinan Kaya wrote: >> Besides, C compiler also won't let me put two arrays together like this. >> >> struct my_struct { >> struct some_struct array1[] >> struct some_struct array2[] >> } > > Why not this: > > const struct of_device_id hidma_msi_of_ids[] = { > {.compatible = "qcom,hidma-1.1",}, > {.compatible = "qcom,hidma-1.2",}, > {}, > }, > > static const struct acpi_device_id hidma_msi_acpi_ids[] = { > {"QCOM8001", QDF2XXX_V1}, > {"QCOM8002", QDF2XXX_V2}, > {}, > }; > > struct hidma_cap { > const struct of_device_id *of; > const struct acpi_device_id *acpi; > }; > > static struct hidma_cap hidma_msi_cap = { > hidma_msi_of_ids, > hidma_msi_acpi_ids > } > I think we are talking styles here. I started with your proposal and wanted to group the settings together as much as I can for maintenance reasons only because I don't have to remember that there are two different arrays that I need to take care of when I add a new HW in the future. +static struct hidma_cap hidma_msi_cap = { + .of = { + {.compatible = "qcom,hidma-1.1",}, + {.compatible = "qcom,hidma-1.2",}, + {}, + }, + + .acpi = { + {"QCOM8062"}, + {"QCOM8063"}, + {}, + } +}; I like this better than what you are proposing. > Keep in mind that you also need to add MODULE_DEVICE_TABLE entries, which you can't really do with your approach. > > MODULE_DEVICE_TABLE(of, hidma_msi_of_ids); > MODULE_DEVICE_TABLE(acpi, hidma_msi_acpi_ids); > HIDMA capable devices are a subset of the devices that need to be probed. That's also why I don't touch the device_table. In the end both approaches work. It is a choice between what is more manageable. That was the initial objection. I tried to close on this request.
On 08/11/17 16:29, Sinan Kaya wrote: > Add support for probing the newer HW and also organize MSI capable hardware > into an array for maintenance reasons. > > Signed-off-by: Sinan Kaya <okaya@codeaurora.org> > --- > drivers/dma/qcom/hidma.c | 41 +++++++++++++++++++++++++++++------------ > 1 file changed, 29 insertions(+), 12 deletions(-) > > diff --git a/drivers/dma/qcom/hidma.c b/drivers/dma/qcom/hidma.c > index e366985..4ef7d6f 100644 > --- a/drivers/dma/qcom/hidma.c > +++ b/drivers/dma/qcom/hidma.c > @@ -50,6 +50,7 @@ > #include <linux/slab.h> > #include <linux/spinlock.h> > #include <linux/of_dma.h> > +#include <linux/of_device.h> > #include <linux/property.h> > #include <linux/delay.h> > #include <linux/acpi.h> > @@ -104,6 +105,26 @@ static void hidma_free(struct hidma_dev *dmadev) > module_param(nr_desc_prm, uint, 0644); > MODULE_PARM_DESC(nr_desc_prm, "number of descriptors (default: 0)"); > > +#define HIDMA_MAX_DEV_MATCH 10 > + > +struct hidma_cap { > + const struct of_device_id of[HIDMA_MAX_DEV_MATCH]; > + const struct acpi_device_id acpi[HIDMA_MAX_DEV_MATCH]; > +}; > + > +static struct hidma_cap hidma_msi_cap = { > + .of = { > + {.compatible = "qcom,hidma-1.1",}, > + {.compatible = "qcom,hidma-1.2",}, > + {}, > + }, > + > + .acpi = { > + {"QCOM8062"}, > + {"QCOM8063"}, > + {}, > + } > +}; Yikes, I dread to imagine where this is going... Apologies if I wasn't very clear, but what I meant to imply by dropping the of_device_get_match_data() hint was to follow one of the common patterns where you either just have some version token: enum foo_ver { FOO_V1, ... } struct acpi_device_id foo_acpi_ids[] = { { "_FOO0001", FOO_V1 }, ... } struct of_device_id foo_of_match[] = { { .compatible = "foo,v1", .data = (void *)FOO_V1 }, ... } int foo_probe(struct device *dev) { ... foodev->version = (enum foo_ver) of_device_get_match_data(&dev->of_node) ... } int foo_reset(struct foodev *foodev) { if (foodev->version == FOO_V1) writel(0, foodev->base + 0x20); else writel(0, foodev->base + 0x30); } or if it fits the code better, encapsulate the relevant details directly: struct foodata { .offset = 0x20, } foo_v1_data; struct acpi_device_id foo_acpi_ids[] = { { "_FOO0001", (unsigned long)&foo_v1_data }, ... } struct of_device_id foo_of_match[] = { { .compatible = "foo,v1", .data = &foo_v1_data }, ... } int foo_probe(struct device *dev) { ... foodev->data = of_device_get_match_data(dev->of_node) ... } int foo_reset(struct foodev *foodev) { writel(0, foodev->base + foodev->data->offset); } Creating multiple sets of match tables seems completely backwards, and frankly looks worse than the open-coded strcmps IMO. Robin. > > /* process completed descriptors */ > static void hidma_process_completed(struct hidma_chan *mchan) > @@ -739,22 +760,16 @@ static int hidma_request_msi(struct hidma_dev *dmadev, > static bool hidma_msi_capable(struct device *dev) > { > struct acpi_device *adev = ACPI_COMPANION(dev); > - const char *of_compat; > - int ret = -EINVAL; > - > - if (!adev || acpi_disabled) { > - ret = device_property_read_string(dev, "compatible", > - &of_compat); > - if (ret) > - return false; > + int ret; > > - ret = strcmp(of_compat, "qcom,hidma-1.1"); > - } else { > + if (!adev || acpi_disabled) > + ret = of_match_device(hidma_msi_cap.of, dev) != NULL; > + else { > #ifdef CONFIG_ACPI > - ret = strcmp(acpi_device_hid(adev), "QCOM8062"); > + ret = acpi_match_device(hidma_msi_cap.acpi, dev) != NULL; > #endif > } > - return ret == 0; > + return ret; > } > > static int hidma_probe(struct platform_device *pdev) > @@ -954,6 +969,7 @@ static int hidma_remove(struct platform_device *pdev) > static const struct acpi_device_id hidma_acpi_ids[] = { > {"QCOM8061"}, > {"QCOM8062"}, > + {"QCOM8063"}, > {}, > }; > MODULE_DEVICE_TABLE(acpi, hidma_acpi_ids); > @@ -962,6 +978,7 @@ static int hidma_remove(struct platform_device *pdev) > static const struct of_device_id hidma_match[] = { > {.compatible = "qcom,hidma-1.0",}, > {.compatible = "qcom,hidma-1.1",}, > + {.compatible = "qcom,hidma-1.2",}, > {}, > }; > MODULE_DEVICE_TABLE(of, hidma_match); >
On 11/08/2017 11:37 AM, Sinan Kaya wrote:
> I think we are talking styles here.
I don't think my suggestions are stylistic. Your version wastes space.
However, if you really insist on your approach, that's fine with me.
I'm not the maintainer.
+linux-acpi, +Rafael for context On 11/8/2017 12:51 PM, Robin Murphy wrote: > Apologies if I wasn't very clear, but what I meant to imply by dropping the of_device_get_match_data() hint was to follow one of the common patterns where you either just have some version token: > > enum foo_ver { > FOO_V1, > ... > } > > struct acpi_device_id foo_acpi_ids[] = { > { "_FOO0001", FOO_V1 }, > ... > } > > struct of_device_id foo_of_match[] = { > { .compatible = "foo,v1", .data = (void *)FOO_V1 }, > ... > } > > int foo_probe(struct device *dev) { > ... > foodev->version = (enum foo_ver) > of_device_get_match_data(&dev->of_node) > ... > } > > int foo_reset(struct foodev *foodev) { > if (foodev->version == FOO_V1) > writel(0, foodev->base + 0x20); > else > writel(0, foodev->base + 0x30); > } I did post v3 with this approach. However, I could not really find a ACPI function that returns the driver data very similar to of_device_get_match_data(). The only thing that is closer is acpi_match_device(). I introduced this new function as part of the v3 series. Let me know if I'm missing something.
On 11/10/2017 08:03 AM, Sinan Kaya wrote: > I did post v3 with this approach. However, I could not really find a ACPI function that > returns the driver data very similar to of_device_get_match_data(). The only thing > that is closer is acpi_match_device(). This is what I do in the EMAC driver: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/net/ethernet/qualcomm/emac/emac-sgmii.c#n245
On 10/11/17 14:03, Sinan Kaya wrote: > +linux-acpi, +Rafael for context > > On 11/8/2017 12:51 PM, Robin Murphy wrote: >> Apologies if I wasn't very clear, but what I meant to imply by dropping the of_device_get_match_data() hint was to follow one of the common patterns where you either just have some version token: >> >> enum foo_ver { >> FOO_V1, >> ... >> } >> >> struct acpi_device_id foo_acpi_ids[] = { >> { "_FOO0001", FOO_V1 }, >> ... >> } >> >> struct of_device_id foo_of_match[] = { >> { .compatible = "foo,v1", .data = (void *)FOO_V1 }, >> ... >> } >> >> int foo_probe(struct device *dev) { >> ... >> foodev->version = (enum foo_ver) >> of_device_get_match_data(&dev->of_node) >> ... >> } >> >> int foo_reset(struct foodev *foodev) { >> if (foodev->version == FOO_V1) >> writel(0, foodev->base + 0x20); >> else >> writel(0, foodev->base + 0x30); >> } > > I did post v3 with this approach. However, I could not really find a ACPI function that > returns the driver data very similar to of_device_get_match_data(). The only thing > that is closer is acpi_match_device(). Yeah, I left the "follow the status quo and open-code it" part out of the above example for brevity ;) Probably 95% of the calls to acpi_match_device() are only doing so to retrieve the driver_data, so the helper could provide scope for further cleanup if anyone wants, too. > I introduced this new function as part of the v3 series. > > Let me know if I'm missing something. v3 looks good, thanks for persevering - I'll leave the rest up to Vinod and Rafael. Cheers, Robin.
diff --git a/drivers/dma/qcom/hidma.c b/drivers/dma/qcom/hidma.c index e366985..4ef7d6f 100644 --- a/drivers/dma/qcom/hidma.c +++ b/drivers/dma/qcom/hidma.c @@ -50,6 +50,7 @@ #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/of_dma.h> +#include <linux/of_device.h> #include <linux/property.h> #include <linux/delay.h> #include <linux/acpi.h> @@ -104,6 +105,26 @@ static void hidma_free(struct hidma_dev *dmadev) module_param(nr_desc_prm, uint, 0644); MODULE_PARM_DESC(nr_desc_prm, "number of descriptors (default: 0)"); +#define HIDMA_MAX_DEV_MATCH 10 + +struct hidma_cap { + const struct of_device_id of[HIDMA_MAX_DEV_MATCH]; + const struct acpi_device_id acpi[HIDMA_MAX_DEV_MATCH]; +}; + +static struct hidma_cap hidma_msi_cap = { + .of = { + {.compatible = "qcom,hidma-1.1",}, + {.compatible = "qcom,hidma-1.2",}, + {}, + }, + + .acpi = { + {"QCOM8062"}, + {"QCOM8063"}, + {}, + } +}; /* process completed descriptors */ static void hidma_process_completed(struct hidma_chan *mchan) @@ -739,22 +760,16 @@ static int hidma_request_msi(struct hidma_dev *dmadev, static bool hidma_msi_capable(struct device *dev) { struct acpi_device *adev = ACPI_COMPANION(dev); - const char *of_compat; - int ret = -EINVAL; - - if (!adev || acpi_disabled) { - ret = device_property_read_string(dev, "compatible", - &of_compat); - if (ret) - return false; + int ret; - ret = strcmp(of_compat, "qcom,hidma-1.1"); - } else { + if (!adev || acpi_disabled) + ret = of_match_device(hidma_msi_cap.of, dev) != NULL; + else { #ifdef CONFIG_ACPI - ret = strcmp(acpi_device_hid(adev), "QCOM8062"); + ret = acpi_match_device(hidma_msi_cap.acpi, dev) != NULL; #endif } - return ret == 0; + return ret; } static int hidma_probe(struct platform_device *pdev) @@ -954,6 +969,7 @@ static int hidma_remove(struct platform_device *pdev) static const struct acpi_device_id hidma_acpi_ids[] = { {"QCOM8061"}, {"QCOM8062"}, + {"QCOM8063"}, {}, }; MODULE_DEVICE_TABLE(acpi, hidma_acpi_ids); @@ -962,6 +978,7 @@ static int hidma_remove(struct platform_device *pdev) static const struct of_device_id hidma_match[] = { {.compatible = "qcom,hidma-1.0",}, {.compatible = "qcom,hidma-1.1",}, + {.compatible = "qcom,hidma-1.2",}, {}, }; MODULE_DEVICE_TABLE(of, hidma_match);
Add support for probing the newer HW and also organize MSI capable hardware into an array for maintenance reasons. Signed-off-by: Sinan Kaya <okaya@codeaurora.org> --- drivers/dma/qcom/hidma.c | 41 +++++++++++++++++++++++++++++------------ 1 file changed, 29 insertions(+), 12 deletions(-)