How to add device tree support and DMA assignement to character device module?

Hello fellow developers,

I am developing a Linux kernel module that uses a DMA channel to transfer memory
(on STM32MP157F).

This works but additional tuning should be made. The STM mdma kernel module makes this possible by using this private configuration struct:

struct stm32_mdma_chan_config {
	u32 request;
    u32 priority_level;
    u32 transfer_config;
    u32 mask_addr;
    u32 mask_data;
    bool m2m_hw;
};

I would like set the priority from 0x0 to 0x3 which is its maximum allowed value.

The variable priority_level is set in stm32_mdma_of_xlate function:

static struct dma_chan *stm32_mdma_of_xlate(struct of_phandle_args *dma_spec,
					    struct of_dma *ofdma)
{
	struct stm32_mdma_chan_config config;


	config.request = dma_spec->args[0];
	config.priority_level = dma_spec->args[1];
    ....
}

Other modules/drivers in the system use a device tree setting like this for its and the used DMA channel configuration.

spi@44004000 {
	#address-cells = <0x01>;
	#size-cells = <0x00>;
	dmas = <0x0e 0x25 0x400 0x01 0x0e 0x26 0x400 0x01>;
	dma-names = "rx
spi@44004000 {
#address-cells = <0x01>;
#size-cells = <0x00>;
dmas = <0x0e 0x25 0x400 0x01 0x0e 0x26 0x400 0x01>;
dma-names = "rx\0tx";
};
tx";
};

spi-stm32.c calls of_match_device in its stm32_spi_probe function. I believe the dma configuration is done during its execution.

I would like something similar for my character device driver:

mydriver@0 {
 	compatible = "mydriver";
	dmas = <&mdma1 36 0x0 0x40008 0x0 0x0>,
	       <&mdma1 37 0x0 0x40002 0x0 0x0>;
	dma-names = "rx", "tx";
};

But this is currently ignored because I do not have a platform device I could use to call
of_match_device. I seem to be blinded by to much source code to look at ...

Any tips for me?

Update:
Currently studying http://xillybus.com/tutorials/device-tree-zynq-3

Best regards Gunther

I solved my issues after doing some extra research.
These are the steps:

I had to add a custom entry to the device tree:

<!-- language: lang-dts -->

mydriver_0: mydriver@0 {
    compatible = "mydriver";
    dmas = <&mdma1 22 0x3 0x1200000a 0x48001008 0x00000020 1>;
    dma-names = "dma0";
};

Make the driver loadable as a platform driver. Create an of_device_id match table matching the device tree entry. Change module_init() to call platform_driver_register() to register the matching table. Then implement a probe function calling the previous init function. Store pdev.

<!-- language: lang-c -->

static int mydriver_drv_probe(struct platform_device *pdev)
{
  // store pdev for later call to: dma_channel_req(&pdev->dev, "dma0");    
  // TODO init driver    
  return 0;
}

/* Connection to device tree */
static struct of_device_id mydriver_of_match[] =
{
    { .compatible = "mydriver" },
    {}
};
MODULE_DEVICE_TABLE(of, mydriver_of_match);

static struct platform_driver mydriver_platform_driver = {
  .probe = mydriver_drv_probe,
  .remove = mydriver_drv_remove,
  .driver = {
    .name = "mydriver",
    .owner = THIS_MODULE,
    .of_match_table = mydriver_of_match,
  },
};

static int __init _mydriver_driver_init(void)
{
    return platform_driver_register(&mydriver_platform_driver);
}
module_init(_mydriver_driver_init);

Get the correctly configured DMA channel:

<!-- language: lang-c -->

chan = dma_request_chan(&pdev->dev, "dma0");

I tested this and it worked. The requested DMA channel is configured using the my device tree "dmas" entry.

I hope this of use for somebody else!