drivers/reset/reset-meson-audio-arb.c

0001 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
0002 // Copyright (c) 2018 BayLibre, SAS.
0003 // Author: Jerome Brunet <jbrunet@baylibre.com>
0004
0005 #include <linux/clk.h>
0006 #include <linux/io.h>
0007 #include <linux/module.h>
0008 #include <linux/of_platform.h>
0009 #include <linux/reset-controller.h>
0010 #include <linux/spinlock.h>
0011
0012 #include <dt-bindings/reset/amlogic,meson-axg-audio-arb.h>
0013
0014 struct meson_audio_arb_data {
0015     struct reset_controller_dev rstc;
0016     void __iomem *regs;
0017     struct clk *clk;
0018     const unsigned int *reset_bits;
0019     spinlock_t lock;
0020 };
0021
0022 struct meson_audio_arb_match_data {
0023     const unsigned int *reset_bits;
0024     unsigned int reset_num;
0025 };
0026
0027 #define ARB_GENERAL_BIT 31
0028
0029 static const unsigned int axg_audio_arb_reset_bits[] = {
0030     [AXG_ARB_TODDR_A]   = 0,
0031     [AXG_ARB_TODDR_B]   = 1,
0032     [AXG_ARB_TODDR_C]   = 2,
0033     [AXG_ARB_FRDDR_A]   = 4,
0034     [AXG_ARB_FRDDR_B]   = 5,
0035     [AXG_ARB_FRDDR_C]   = 6,
0036 };
0037
0038 static const struct meson_audio_arb_match_data axg_audio_arb_match = {
0039     .reset_bits = axg_audio_arb_reset_bits,
0040     .reset_num = ARRAY_SIZE(axg_audio_arb_reset_bits),
0041 };
0042
0043 static const unsigned int sm1_audio_arb_reset_bits[] = {
0044     [AXG_ARB_TODDR_A]   = 0,
0045     [AXG_ARB_TODDR_B]   = 1,
0046     [AXG_ARB_TODDR_C]   = 2,
0047     [AXG_ARB_FRDDR_A]   = 4,
0048     [AXG_ARB_FRDDR_B]   = 5,
0049     [AXG_ARB_FRDDR_C]   = 6,
0050     [AXG_ARB_TODDR_D]   = 3,
0051     [AXG_ARB_FRDDR_D]   = 7,
0052 };
0053
0054 static const struct meson_audio_arb_match_data sm1_audio_arb_match = {
0055     .reset_bits = sm1_audio_arb_reset_bits,
0056     .reset_num = ARRAY_SIZE(sm1_audio_arb_reset_bits),
0057 };
0058
0059 static int meson_audio_arb_update(struct reset_controller_dev *rcdev,
0060                   unsigned long id, bool assert)
0061 {
0062     u32 val;
0063     struct meson_audio_arb_data *arb =
0064         container_of(rcdev, struct meson_audio_arb_data, rstc);
0065
0066     spin_lock(&arb->lock);
0067     val = readl(arb->regs);
0068
0069     if (assert)
0070         val &= ~BIT(arb->reset_bits[id]);
0071     else
0072         val |= BIT(arb->reset_bits[id]);
0073
0074     writel(val, arb->regs);
0075     spin_unlock(&arb->lock);
0076
0077     return 0;
0078 }
0079
0080 static int meson_audio_arb_status(struct reset_controller_dev *rcdev,
0081                   unsigned long id)
0082 {
0083     u32 val;
0084     struct meson_audio_arb_data *arb =
0085         container_of(rcdev, struct meson_audio_arb_data, rstc);
0086
0087     val = readl(arb->regs);
0088
0089     return !(val & BIT(arb->reset_bits[id]));
0090 }
0091
0092 static int meson_audio_arb_assert(struct reset_controller_dev *rcdev,
0093                   unsigned long id)
0094 {
0095     return meson_audio_arb_update(rcdev, id, true);
0096 }
0097
0098 static int meson_audio_arb_deassert(struct reset_controller_dev *rcdev,
0099                     unsigned long id)
0100 {
0101     return meson_audio_arb_update(rcdev, id, false);
0102 }
0103
0104 static const struct reset_control_ops meson_audio_arb_rstc_ops = {
0105     .assert = meson_audio_arb_assert,
0106     .deassert = meson_audio_arb_deassert,
0107     .status = meson_audio_arb_status,
0108 };
0109
0110 static const struct of_device_id meson_audio_arb_of_match[] = {
0111     {
0112         .compatible = "amlogic,meson-axg-audio-arb",
0113         .data = &axg_audio_arb_match,
0114     }, {
0115         .compatible = "amlogic,meson-sm1-audio-arb",
0116         .data = &sm1_audio_arb_match,
0117     },
0118     {}
0119 };
0120 MODULE_DEVICE_TABLE(of, meson_audio_arb_of_match);
0121
0122 static int meson_audio_arb_remove(struct platform_device *pdev)
0123 {
0124     struct meson_audio_arb_data *arb = platform_get_drvdata(pdev);
0125
0126     /* Disable all access */
0127     spin_lock(&arb->lock);
0128     writel(0, arb->regs);
0129     spin_unlock(&arb->lock);
0130
0131     clk_disable_unprepare(arb->clk);
0132
0133     return 0;
0134 }
0135
0136 static int meson_audio_arb_probe(struct platform_device *pdev)
0137 {
0138     struct device *dev = &pdev->dev;
0139     const struct meson_audio_arb_match_data *data;
0140     struct meson_audio_arb_data *arb;
0141     struct resource *res;
0142     int ret;
0143
0144     data = of_device_get_match_data(dev);
0145     if (!data)
0146         return -EINVAL;
0147
0148     arb = devm_kzalloc(dev, sizeof(*arb), GFP_KERNEL);
0149     if (!arb)
0150         return -ENOMEM;
0151     platform_set_drvdata(pdev, arb);
0152
0153     arb->clk = devm_clk_get(dev, NULL);
0154     if (IS_ERR(arb->clk)) {
0155         if (PTR_ERR(arb->clk) != -EPROBE_DEFER)
0156             dev_err(dev, "failed to get clock\n");
0157         return PTR_ERR(arb->clk);
0158     }
0159
0160     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0161     arb->regs = devm_ioremap_resource(dev, res);
0162     if (IS_ERR(arb->regs))
0163         return PTR_ERR(arb->regs);
0164
0165     spin_lock_init(&arb->lock);
0166     arb->reset_bits = data->reset_bits;
0167     arb->rstc.nr_resets = data->reset_num;
0168     arb->rstc.ops = &meson_audio_arb_rstc_ops;
0169     arb->rstc.of_node = dev->of_node;
0170     arb->rstc.owner = THIS_MODULE;
0171
0172     /*
0173      * Enable general :
0174      * In the initial state, all memory interfaces are disabled
0175      * and the general bit is on
0176      */
0177     ret = clk_prepare_enable(arb->clk);
0178     if (ret) {
0179         dev_err(dev, "failed to enable arb clock\n");
0180         return ret;
0181     }
0182     writel(BIT(ARB_GENERAL_BIT), arb->regs);
0183
0184     /* Register reset controller */
0185     ret = devm_reset_controller_register(dev, &arb->rstc);
0186     if (ret) {
0187         dev_err(dev, "failed to register arb reset controller\n");
0188         meson_audio_arb_remove(pdev);
0189     }
0190
0191     return ret;
0192 }
0193
0194 static struct platform_driver meson_audio_arb_pdrv = {
0195     .probe = meson_audio_arb_probe,
0196     .remove = meson_audio_arb_remove,
0197     .driver = {
0198         .name = "meson-audio-arb-reset",
0199         .of_match_table = meson_audio_arb_of_match,
0200     },
0201 };
0202 module_platform_driver(meson_audio_arb_pdrv);
0203
0204 MODULE_DESCRIPTION("Amlogic A113 Audio Memory Arbiter");
0205 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
0206 MODULE_LICENSE("GPL v2");