| Message ID | 1448612982-28141-4-git-send-email-peter.ujfalusi@ti.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Friday 27 November 2015 10:29:39 Peter Ujfalusi wrote: > struct dma_chan *dma_request_chan(struct device *dev, const char *name, > const dma_cap_mask_t *mask); > To request a slave channel. The mask parameter is optional and it is used > to check if the received channel's capabilities can satisfy the requested > mask. The dma_request_chan() will try to find the channel via DT, ACPI or > in case if the kernel booted in non DT/ACPI mode it will use a filter > lookup table and retrieves the RESOURCE_DMA from the requester's device. > This legacy mode needs changes in platform code, in dmaengine drivers and > finally the dmaengine user drivers can be converted: I think we should not introduce the mask parameter at all. In the rare case that we actually need to pass a mask other than DMA_SLAVE today, we should be able to encode that in the data we pass to the filter function. > RESOURCE_DMA needs to be added to the platform devices with names > > For each dmaengine driver a string array listing the devices handled by the > given DMA driver: > > static char *da8xx_edma0_devices[] = { > "davinci-mcasp.0", > "da830-mmc.0", > }; > > This information is going to be needed by the dmaengine driver, so > modification to the platform_data is needed, and the driver map should be > added to the pdata of the DMA driver: However, a lot of drivers definitely need to pass a data pointer for each device. I see that you currently rely on the IORESOURCE_DMA method that a couple of platforms use today, but I think it would be backwards to do it that way for the platforms that require passing more than an integer number today. Having a pointer as the filter function argument is intentional and I'd prefer to change the platforms that currently use IORESOURCE_DMA (davinci, pxa, omap1, blackfin, alchemy) to stop doing it instead, and return IORESOURCE_DMA to its original meaning that was limited to ISAPNP style devices not using the dmaengine API. Arnd -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 11/27/2015 01:00 PM, Arnd Bergmann wrote: > On Friday 27 November 2015 10:29:39 Peter Ujfalusi wrote: >> struct dma_chan *dma_request_chan(struct device *dev, const char *name, >> const dma_cap_mask_t *mask); >> To request a slave channel. The mask parameter is optional and it is used >> to check if the received channel's capabilities can satisfy the requested >> mask. The dma_request_chan() will try to find the channel via DT, ACPI or >> in case if the kernel booted in non DT/ACPI mode it will use a filter >> lookup table and retrieves the RESOURCE_DMA from the requester's device. >> This legacy mode needs changes in platform code, in dmaengine drivers and >> finally the dmaengine user drivers can be converted: > > I think we should not introduce the mask parameter at all. In the rare > case that we actually need to pass a mask other than DMA_SLAVE today, > we should be able to encode that in the data we pass to the filter > function. I have seen that drivers check the capabilities themselves after getting the channel, so I thought that if we move that also to the core we can save on duplicated lines around the kernel. It is not needed to get the channel. As you can see in the mmc patch, I pass NULL and the channel I got is the correct one. Sure, I can remove it. >> RESOURCE_DMA needs to be added to the platform devices with names >> >> For each dmaengine driver a string array listing the devices handled by the >> given DMA driver: >> >> static char *da8xx_edma0_devices[] = { >> "davinci-mcasp.0", >> "da830-mmc.0", >> }; >> >> This information is going to be needed by the dmaengine driver, so >> modification to the platform_data is needed, and the driver map should be >> added to the pdata of the DMA driver: > > However, a lot of drivers definitely need to pass a data pointer for > each device. I see that you currently rely on the IORESOURCE_DMA > method that a couple of platforms use today, but I think it would > be backwards to do it that way for the platforms that require passing > more than an integer number today. > > Having a pointer as the filter function argument is intentional and I'd > prefer to change the platforms that currently use IORESOURCE_DMA (davinci, > pxa, omap1, blackfin, alchemy) to stop doing it instead, and return > IORESOURCE_DMA to its original meaning that was limited to ISAPNP style > devices not using the dmaengine API. Something like this: /* include/linux/dmaengine.h */ struct dma_filter_map { char *devname; char *slave; void *param; }; struct dma_filter { dma_filter_fn filter_fn; int mapcnt; struct dma_filter_map *map; }; /* arch/arm/mach-davinci/devices-da8xx.c */ static struct dma_filter_map da8xx_edma0_map[] = { { .devname = "davinci-mcasp.0", .slave = "tx", .param = (void*)DAVINCI_DA8XX_DMA_MCASP0_AXEVT, }, { .devname = "davinci-mcasp.0", .slave = "rx", .param = (void*)DAVINCI_DA8XX_DMA_MCASP0_AREVT, }, { .devname = "da830-mmc.0", .slave = "tx", .param = (void*)DA8XX_DMA_MMCSD0_TX, }, { .devname = "da830-mmc.0", .slave = "rx", .param = (void*)DA8XX_DMA_MMCSD0_RX, }, }; I had this version first, but decided to go with a simpler one present in this RFC series.
On Friday 27 November 2015 13:16:37 Peter Ujfalusi wrote: > On 11/27/2015 01:00 PM, Arnd Bergmann wrote: > > On Friday 27 November 2015 10:29:39 Peter Ujfalusi wrote: > >> struct dma_chan *dma_request_chan(struct device *dev, const char *name, > >> const dma_cap_mask_t *mask); > >> To request a slave channel. The mask parameter is optional and it is used > >> to check if the received channel's capabilities can satisfy the requested > >> mask. The dma_request_chan() will try to find the channel via DT, ACPI or > >> in case if the kernel booted in non DT/ACPI mode it will use a filter > >> lookup table and retrieves the RESOURCE_DMA from the requester's device. > >> This legacy mode needs changes in platform code, in dmaengine drivers and > >> finally the dmaengine user drivers can be converted: > > > > I think we should not introduce the mask parameter at all. In the rare > > case that we actually need to pass a mask other than DMA_SLAVE today, > > we should be able to encode that in the data we pass to the filter > > function. > > I have seen that drivers check the capabilities themselves after getting the > channel, so I thought that if we move that also to the core we can save on > duplicated lines around the kernel. It is not needed to get the channel. As > you can see in the mmc patch, I pass NULL and the channel I got is the correct > one. > Sure, I can remove it. Ok. > >> RESOURCE_DMA needs to be added to the platform devices with names > >> > >> For each dmaengine driver a string array listing the devices handled by the > >> given DMA driver: > >> > >> static char *da8xx_edma0_devices[] = { > >> "davinci-mcasp.0", > >> "da830-mmc.0", > >> }; > >> > >> This information is going to be needed by the dmaengine driver, so > >> modification to the platform_data is needed, and the driver map should be > >> added to the pdata of the DMA driver: > > > > However, a lot of drivers definitely need to pass a data pointer for > > each device. I see that you currently rely on the IORESOURCE_DMA > > method that a couple of platforms use today, but I think it would > > be backwards to do it that way for the platforms that require passing > > more than an integer number today. > > > > Having a pointer as the filter function argument is intentional and I'd > > prefer to change the platforms that currently use IORESOURCE_DMA (davinci, > > pxa, omap1, blackfin, alchemy) to stop doing it instead, and return > > IORESOURCE_DMA to its original meaning that was limited to ISAPNP style > > devices not using the dmaengine API. > > Something like this: > > /* include/linux/dmaengine.h */ > > struct dma_filter_map { > char *devname; > char *slave; > void *param; > }; > > struct dma_filter { > dma_filter_fn filter_fn; > int mapcnt; > struct dma_filter_map *map; > }; > > /* arch/arm/mach-davinci/devices-da8xx.c */ > > static struct dma_filter_map da8xx_edma0_map[] = { > { > .devname = "davinci-mcasp.0", > .slave = "tx", > .param = (void*)DAVINCI_DA8XX_DMA_MCASP0_AXEVT, > }, > { > .devname = "davinci-mcasp.0", > .slave = "rx", > .param = (void*)DAVINCI_DA8XX_DMA_MCASP0_AREVT, > }, > { > .devname = "da830-mmc.0", > .slave = "tx", > .param = (void*)DA8XX_DMA_MMCSD0_TX, > }, > { > .devname = "da830-mmc.0", > .slave = "rx", > .param = (void*)DA8XX_DMA_MMCSD0_RX, > }, > }; > > I had this version first, but decided to go with a simpler one present in this > RFC series. Yes, that is what I had in mind. Let's see what others think about the two options. I would also avoid the 'struct dma_filter' entirely by using a zero-terminated list and passing the filter function and map table separately, but your approach seems reasonable as well. In my initial suggestion, the idea was to do the registration of the filter map separately from registering the dmaengine device to give us a little more flexibility in converting existing code, but it requires listing both the dmaengine device and the slave devname in the map, so your approach is probably better in the long run even if it requires a little more work for doing the conversion. Arnd -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c index 1249165fb4b2..14c8e8a76641 100644 --- a/drivers/dma/dmaengine.c +++ b/drivers/dma/dmaengine.c @@ -43,6 +43,7 @@ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#include <linux/platform_device.h> #include <linux/dma-mapping.h> #include <linux/init.h> #include <linux/module.h> @@ -715,6 +716,96 @@ struct dma_chan *dma_request_slave_channel(struct device *dev, } EXPORT_SYMBOL_GPL(dma_request_slave_channel); +static bool dma_filter_dev_is_match(struct dma_device *device, + struct device *dev) +{ + bool found = false; + int i; + + if (!device->filter_map.devcnt) + return false; + + for (i = 0; i < device->filter_map.devcnt; i++) { + if (!strcmp(device->filter_map.devnames[i], dev_name(dev))) { + found = true; + break; + } + } + + return found; +} + +struct dma_chan *dma_request_chan(struct device *dev, const char *name, + const dma_cap_mask_t *mask) +{ + struct dma_device *device, *_d; + struct dma_chan *chan = NULL; + + /* If device-tree is present get slave info from here */ + if (dev->of_node) + chan = of_dma_request_slave_channel(dev->of_node, name); + + /* If device was enumerated by ACPI get slave info from here */ + if (ACPI_HANDLE(dev) && !chan) + chan = acpi_dma_request_slave_chan_by_name(dev, name); + + if (chan) + goto validate; + + /* Try to find the channel via the DMA filter map(s) */ + mutex_lock(&dma_list_mutex); + list_for_each_entry_safe(device, _d, &dma_device_list, global_node) { + bool match = dma_filter_dev_is_match(device, dev); + struct resource *r; + + if (!match) + continue; + + r = platform_get_resource_byname(to_platform_device(dev), + IORESOURCE_DMA, name); + if (!r) + continue; + + chan = dma_get_channel(device, mask, + device->filter_map.filter_fn, + &r->start); + if (!IS_ERR(chan)) + break; + } + mutex_unlock(&dma_list_mutex); + + if (!chan) + return ERR_PTR(-EPROBE_DEFER); +validate: + if (IS_ERR(chan) || !mask) + return chan; + + if (!__dma_device_satisfies_mask(chan->device, mask)) { + dev_dbg(chan->device->dev, "%s: wrong capabilities for %s:%s\n", + __func__, dev_name(dev), name); + dma_release_channel(chan); + chan = ERR_PTR(-ENODEV); + } + + return chan; +} +EXPORT_SYMBOL_GPL(dma_request_chan); + +struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask) +{ + struct dma_chan *chan; + + if (!mask) + return ERR_PTR(-ENODEV); + + chan = __dma_request_channel(mask, NULL, NULL); + if (!chan) + chan = ERR_PTR(-ENODEV); + + return chan; +} +EXPORT_SYMBOL_GPL(dma_request_chan_by_mask); + void dma_release_channel(struct dma_chan *chan) { mutex_lock(&dma_list_mutex); diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h index a2b7c2071cf4..e17be9a136f1 100644 --- a/include/linux/dmaengine.h +++ b/include/linux/dmaengine.h @@ -606,6 +606,12 @@ enum dmaengine_alignment { DMAENGINE_ALIGN_64_BYTES = 6, }; +struct dma_filter { + dma_filter_fn filter_fn; + int devcnt; + char **devnames; +}; + /** * struct dma_device - info on the entity supplying DMA services * @chancnt: how many DMA channels are supported @@ -669,6 +675,7 @@ struct dma_device { unsigned int privatecnt; struct list_head channels; struct list_head global_node; + struct dma_filter filter_map; dma_cap_mask_t cap_mask; unsigned short max_xor; unsigned short max_pq; @@ -1235,6 +1242,11 @@ struct dma_chan *__dma_request_channel(const dma_cap_mask_t *mask, struct dma_chan *dma_request_slave_channel_reason(struct device *dev, const char *name); struct dma_chan *dma_request_slave_channel(struct device *dev, const char *name); + +struct dma_chan *dma_request_chan(struct device *dev, const char *name, + const dma_cap_mask_t *mask); +struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask); + void dma_release_channel(struct dma_chan *chan); int dma_get_slave_caps(struct dma_chan *chan, struct dma_slave_caps *caps); #else @@ -1268,6 +1280,15 @@ static inline struct dma_chan *dma_request_slave_channel(struct device *dev, { return NULL; } +static inline struct dma_chan *dma_request_chan(struct device *dev, + const char *name, const dma_cap_mask_t *mask) +{ + return ERR_PTR(-ENODEV); +} +static inline struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask) +{ + return ERR_PTR(-ENODEV); +} static inline void dma_release_channel(struct dma_chan *chan) { }
The two API function can cover most, if not all current APIs used to request a channel. With minimal effort dmaengine drivers, platforms and dmaengine user drivers can be converted to use the two function. struct dma_chan *dma_request_chan_by_mask(const dma_cap_mask_t *mask); To request any channel matching with the requested capabilities, can be used to request channel for memcpy, memset, xor, etc where no hardware synchronization is needed. struct dma_chan *dma_request_chan(struct device *dev, const char *name, const dma_cap_mask_t *mask); To request a slave channel. The mask parameter is optional and it is used to check if the received channel's capabilities can satisfy the requested mask. The dma_request_chan() will try to find the channel via DT, ACPI or in case if the kernel booted in non DT/ACPI mode it will use a filter lookup table and retrieves the RESOURCE_DMA from the requester's device. This legacy mode needs changes in platform code, in dmaengine drivers and finally the dmaengine user drivers can be converted: RESOURCE_DMA needs to be added to the platform devices with names For each dmaengine driver a string array listing the devices handled by the given DMA driver: static char *da8xx_edma0_devices[] = { "davinci-mcasp.0", "da830-mmc.0", }; This information is going to be needed by the dmaengine driver, so modification to the platform_data is needed, and the driver map should be added to the pdata of the DMA driver: da8xx_edma0_pdata.devnames = da8xx_edma0_devices; da8xx_edma0_pdata.devcnt = ARRAY_SIZE(da8xx_edma0_devices); The DMA driver then needs to convigure the needed device -> filter_fn mapping before it registers with dma_async_device_register() : if (info->devnames) { ecc->dma_slave.filter_map.devnames = info->devnames; ecc->dma_slave.filter_map.devcnt = info->devcnt; ecc->dma_slave.filter_map.filter_fn = edma_filter_fn; } When neither DT or ACPI lookup is available the dma_request_chan() will try to match the requester's device name with the filter_map's list of device names, when a match found it will requests the named DMA resource using the requester's pdev and with the needed information available it will try to get the channele with the dma_get_channel() internal function. Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com> --- drivers/dma/dmaengine.c | 91 +++++++++++++++++++++++++++++++++++++++++++++++ include/linux/dmaengine.h | 21 +++++++++++ 2 files changed, 112 insertions(+)