From: eLinux.org

Linux Drivers Device Tree Guide

Contents

Support of different hardware versions in a single driver

Examples of drivers that match more than one compatible string.

This list is not an endorsement of any particular technique. It is
instead a (partial) list of some existing code in the Linux kernel.

The examples are not meant to capture each method entirely; they are
instead meant to illustrate the basic concept.

Hardware Version in struct of_device_id.data

The hardware version is used throughout the driver to choose alternate
actions.

drivers/iommu/arm-smmu.c:

  1. static const struct of_device_id arm_smmu_of_match[] = {
  2.         { .compatible = "arm,smmu-v1", .data = (void *)ARM_SMMU_V1 },
  3.         { .compatible = "arm,smmu-v2", .data = (void *)ARM_SMMU_V2 },
  4.         { .compatible = "arm,mmu-400", .data = (void *)ARM_SMMU_V1 },
  5.         { .compatible = "arm,mmu-401", .data = (void *)ARM_SMMU_V1 },
  6.         { .compatible = "arm,mmu-500", .data = (void *)ARM_SMMU_V2 },
  7.         { },
  8. };
  9. MODULE_DEVICE_TABLE(of, arm_smmu_of_match);
  11. static int arm_smmu_device_dt_probe(struct platform_device *pdev)
  12. {
  13.         const struct of_device_id *of_id;
  15.         of_id = of_match_node(arm_smmu_of_match, dev->of_node);
  16.         smmu->version = (enum arm_smmu_arch_version)of_id->data;
  18.         ...
  20.         if (smmu->version > ARM_SMMU_V1) {
  21.                 ...
  22.         }
  23. }
  25. static struct platform_driver arm_smmu_driver = {
  26.        .driver = {
  27.                 .name           = "arm-smmu",
  28.                 .of_match_table = of_match_ptr(arm_smmu_of_match),
  29.         },
  30.         .probe  = arm_smmu_device_dt_probe,
  31.         .remove = arm_smmu_device_remove,
  32. };

Function Call Table pointer in struct of_device_id.data

The function call table is used throughout the driver to choose
alternate actions.

drivers/iio/adc/xilinx-xadc-core.c:

  1. static const struct xadc_ops xadc_zynq_ops = {
  2.         .read = xadc_zynq_read_adc_reg,
  3.         .write = xadc_zynq_write_adc_reg,
  4.         .setup = xadc_zynq_setup,
  5.         .get_dclk_rate = xadc_zynq_get_dclk_rate,
  6.         .interrupt_handler = xadc_zynq_interrupt_handler,
  7.         .threaded_interrupt_handler = xadc_zynq_threaded_interrupt_handler,
  8.         .update_alarm = xadc_zynq_update_alarm,
  9. };
  11. static const struct of_device_id xadc_of_match_table[] = {
  12.         { .compatible = "xlnx,zynq-xadc-1.00.a", (void *)&xadc_zynq_ops },
  13.         { .compatible = "xlnx,axi-xadc-1.00.a", (void *)&xadc_axi_ops },
  14.         { },
  15. };
  16. MODULE_DEVICE_TABLE(of, xadc_of_match_table);
  18. static int xadc_probe(struct platform_device *pdev)
  19. {
  20.         const struct of_device_id *id;
  21.         id = of_match_node(xadc_of_match_table, pdev->dev.of_node);
  22.         ...
  23.         indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*xadc));
  24.         xadc = iio_priv(indio_dev);
  25.         ...
  26.         xadc->ops = id->data;
  27.         ...
  28.         ret = xadc->ops->setup(pdev, indio_dev, irq);
  29.         ...
  30. }
  32. static struct platform_driver xadc_driver = {
  33.         .probe = xadc_probe,
  34.         .remove = xadc_remove,
  35.         .driver = {
  36.                 .name = "xadc",
  37.                 .of_match_table = xadc_of_match_table,
  38.         },
  39. };
  40. module_platform_driver(xadc_driver);

Hardware Description pointer in struct of_device_id.data

The hardware description data is used to configure the device.

This struct pointed to by struct of_device_id.data in this example
includes a function call table in addition to the hardware description
fields.

drivers/iio/adc/twl6030-gpadc.c:

  1. static const struct twl6030_gpadc_platform_data twl6030_pdata = {
  2.         .iio_channels = twl6030_gpadc_iio_channels,
  3.         .nchannels = TWL6030_GPADC_USED_CHANNELS,
  4.         .ideal = twl6030_ideal,
  5.         .start_conversion = twl6030_start_conversion,
  6.         .channel_to_reg = twl6030_channel_to_reg,
  7.         .calibrate = twl6030_calibration,
  8. };
  10. static const struct of_device_id of_twl6030_match_tbl[] = {
  11.         {
  12.                 .compatible = "ti,twl6030-gpadc",
  13.                 .data = &twl6030_pdata,
  14.         },
  15.         {
  16.                 .compatible = "ti,twl6032-gpadc",
  17.                 .data = &twl6032_pdata,
  18.         },
  19.         { /* end */ }
  20. };
  22. static int twl6030_gpadc_probe(struct platform_device *pdev)
  23. {
  24.         const struct of_device_id *match;
  25.         const struct twl6030_gpadc_platform_data *pdata;
  27.         match = of_match_device(of_twl6030_match_tbl, dev);
  28.         pdata = match->data;
  29.         indio_dev = devm_iio_device_alloc(dev, sizeof(*gpadc));
  30.         gpadc = iio_priv(indio_dev);
  31.         gpadc->pdata = pdata;
  32.         platform_set_drvdata(pdev, indio_dev);
  33.         ...
  34.         ret = pdata->calibrate(gpadc);
  35.         ...
  36.         indio_dev->channels = pdata->iio_channels;
  37.         indio_dev->num_channels = pdata->nchannels;
  38. }

Category: