soc/apple/sart.c

0001 // SPDX-License-Identifier: GPL-2.0-only OR MIT
0002 /*
0003  * Apple SART device driver
0004  * Copyright (C) The Asahi Linux Contributors
0005  *
0006  * Apple SART is a simple address filter for some DMA transactions.
0007  * Regions of physical memory must be added to the SART's allow
0008  * list before any DMA can target these. Unlike a proper
0009  * IOMMU no remapping can be done and special support in the
0010  * consumer driver is required since not all DMA transactions of
0011  * a single device are subject to SART filtering.
0012  */
0013
0014 #include <linux/soc/apple/sart.h>
0015 #include <linux/atomic.h>
0016 #include <linux/bits.h>
0017 #include <linux/bitfield.h>
0018 #include <linux/device.h>
0019 #include <linux/io.h>
0020 #include <linux/module.h>
0021 #include <linux/of.h>
0022 #include <linux/of_platform.h>
0023 #include <linux/platform_device.h>
0024 #include <linux/types.h>
0025
0026 #define APPLE_SART_MAX_ENTRIES 16
0027
0028 /* This is probably a bitfield but the exact meaning of each bit is unknown. */
0029 #define APPLE_SART_FLAGS_ALLOW 0xff
0030
0031 /* SARTv2 registers */
0032 #define APPLE_SART2_CONFIG(idx)       (0x00 + 4 * (idx))
0033 #define APPLE_SART2_CONFIG_FLAGS      GENMASK(31, 24)
0034 #define APPLE_SART2_CONFIG_SIZE       GENMASK(23, 0)
0035 #define APPLE_SART2_CONFIG_SIZE_SHIFT 12
0036 #define APPLE_SART2_CONFIG_SIZE_MAX   GENMASK(23, 0)
0037
0038 #define APPLE_SART2_PADDR(idx)  (0x40 + 4 * (idx))
0039 #define APPLE_SART2_PADDR_SHIFT 12
0040
0041 /* SARTv3 registers */
0042 #define APPLE_SART3_CONFIG(idx) (0x00 + 4 * (idx))
0043
0044 #define APPLE_SART3_PADDR(idx)  (0x40 + 4 * (idx))
0045 #define APPLE_SART3_PADDR_SHIFT 12
0046
0047 #define APPLE_SART3_SIZE(idx)  (0x80 + 4 * (idx))
0048 #define APPLE_SART3_SIZE_SHIFT 12
0049 #define APPLE_SART3_SIZE_MAX   GENMASK(29, 0)
0050
0051 struct apple_sart_ops {
0052     void (*get_entry)(struct apple_sart *sart, int index, u8 *flags,
0053               phys_addr_t *paddr, size_t *size);
0054     void (*set_entry)(struct apple_sart *sart, int index, u8 flags,
0055               phys_addr_t paddr_shifted, size_t size_shifted);
0056     unsigned int size_shift;
0057     unsigned int paddr_shift;
0058     size_t size_max;
0059 };
0060
0061 struct apple_sart {
0062     struct device *dev;
0063     void __iomem *regs;
0064
0065     const struct apple_sart_ops *ops;
0066
0067     unsigned long protected_entries;
0068     unsigned long used_entries;
0069 };
0070
0071 static void sart2_get_entry(struct apple_sart *sart, int index, u8 *flags,
0072                 phys_addr_t *paddr, size_t *size)
0073 {
0074     u32 cfg = readl(sart->regs + APPLE_SART2_CONFIG(index));
0075     phys_addr_t paddr_ = readl(sart->regs + APPLE_SART2_PADDR(index));
0076     size_t size_ = FIELD_GET(APPLE_SART2_CONFIG_SIZE, cfg);
0077
0078     *flags = FIELD_GET(APPLE_SART2_CONFIG_FLAGS, cfg);
0079     *size = size_ << APPLE_SART2_CONFIG_SIZE_SHIFT;
0080     *paddr = paddr_ << APPLE_SART2_PADDR_SHIFT;
0081 }
0082
0083 static void sart2_set_entry(struct apple_sart *sart, int index, u8 flags,
0084                 phys_addr_t paddr_shifted, size_t size_shifted)
0085 {
0086     u32 cfg;
0087
0088     cfg = FIELD_PREP(APPLE_SART2_CONFIG_FLAGS, flags);
0089     cfg |= FIELD_PREP(APPLE_SART2_CONFIG_SIZE, size_shifted);
0090
0091     writel(paddr_shifted, sart->regs + APPLE_SART2_PADDR(index));
0092     writel(cfg, sart->regs + APPLE_SART2_CONFIG(index));
0093 }
0094
0095 static struct apple_sart_ops sart_ops_v2 = {
0096     .get_entry = sart2_get_entry,
0097     .set_entry = sart2_set_entry,
0098     .size_shift = APPLE_SART2_CONFIG_SIZE_SHIFT,
0099     .paddr_shift = APPLE_SART2_PADDR_SHIFT,
0100     .size_max = APPLE_SART2_CONFIG_SIZE_MAX,
0101 };
0102
0103 static void sart3_get_entry(struct apple_sart *sart, int index, u8 *flags,
0104                 phys_addr_t *paddr, size_t *size)
0105 {
0106     phys_addr_t paddr_ = readl(sart->regs + APPLE_SART3_PADDR(index));
0107     size_t size_ = readl(sart->regs + APPLE_SART3_SIZE(index));
0108
0109     *flags = readl(sart->regs + APPLE_SART3_CONFIG(index));
0110     *size = size_ << APPLE_SART3_SIZE_SHIFT;
0111     *paddr = paddr_ << APPLE_SART3_PADDR_SHIFT;
0112 }
0113
0114 static void sart3_set_entry(struct apple_sart *sart, int index, u8 flags,
0115                 phys_addr_t paddr_shifted, size_t size_shifted)
0116 {
0117     writel(paddr_shifted, sart->regs + APPLE_SART3_PADDR(index));
0118     writel(size_shifted, sart->regs + APPLE_SART3_SIZE(index));
0119     writel(flags, sart->regs + APPLE_SART3_CONFIG(index));
0120 }
0121
0122 static struct apple_sart_ops sart_ops_v3 = {
0123     .get_entry = sart3_get_entry,
0124     .set_entry = sart3_set_entry,
0125     .size_shift = APPLE_SART3_SIZE_SHIFT,
0126     .paddr_shift = APPLE_SART3_PADDR_SHIFT,
0127     .size_max = APPLE_SART3_SIZE_MAX,
0128 };
0129
0130 static int apple_sart_probe(struct platform_device *pdev)
0131 {
0132     int i;
0133     struct apple_sart *sart;
0134     struct device *dev = &pdev->dev;
0135
0136     sart = devm_kzalloc(dev, sizeof(*sart), GFP_KERNEL);
0137     if (!sart)
0138         return -ENOMEM;
0139
0140     sart->dev = dev;
0141     sart->ops = of_device_get_match_data(dev);
0142
0143     sart->regs = devm_platform_ioremap_resource(pdev, 0);
0144     if (IS_ERR(sart->regs))
0145         return PTR_ERR(sart->regs);
0146
0147     for (i = 0; i < APPLE_SART_MAX_ENTRIES; ++i) {
0148         u8 flags;
0149         size_t size;
0150         phys_addr_t paddr;
0151
0152         sart->ops->get_entry(sart, i, &flags, &paddr, &size);
0153
0154         if (!flags)
0155             continue;
0156
0157         dev_dbg(sart->dev,
0158             "SART bootloader entry: index %02d; flags: 0x%02x; paddr: %pa; size: 0x%zx\n",
0159             i, flags, &paddr, size);
0160         set_bit(i, &sart->protected_entries);
0161     }
0162
0163     platform_set_drvdata(pdev, sart);
0164     return 0;
0165 }
0166
0167 struct apple_sart *devm_apple_sart_get(struct device *dev)
0168 {
0169     struct device_node *sart_node;
0170     struct platform_device *sart_pdev;
0171     struct apple_sart *sart;
0172     int ret;
0173
0174     sart_node = of_parse_phandle(dev->of_node, "apple,sart", 0);
0175     if (!sart_node)
0176         return ERR_PTR(-ENODEV);
0177
0178     sart_pdev = of_find_device_by_node(sart_node);
0179     of_node_put(sart_node);
0180
0181     if (!sart_pdev)
0182         return ERR_PTR(-ENODEV);
0183
0184     sart = dev_get_drvdata(&sart_pdev->dev);
0185     if (!sart) {
0186         put_device(&sart_pdev->dev);
0187         return ERR_PTR(-EPROBE_DEFER);
0188     }
0189
0190     ret = devm_add_action_or_reset(dev, (void (*)(void *))put_device,
0191                        &sart_pdev->dev);
0192     if (ret)
0193         return ERR_PTR(ret);
0194
0195     device_link_add(dev, &sart_pdev->dev,
0196             DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER);
0197
0198     return sart;
0199 }
0200 EXPORT_SYMBOL_GPL(devm_apple_sart_get);
0201
0202 static int sart_set_entry(struct apple_sart *sart, int index, u8 flags,
0203               phys_addr_t paddr, size_t size)
0204 {
0205     if (size & ((1 << sart->ops->size_shift) - 1))
0206         return -EINVAL;
0207     if (paddr & ((1 << sart->ops->paddr_shift) - 1))
0208         return -EINVAL;
0209
0210     paddr >>= sart->ops->size_shift;
0211     size >>= sart->ops->paddr_shift;
0212
0213     if (size > sart->ops->size_max)
0214         return -EINVAL;
0215
0216     sart->ops->set_entry(sart, index, flags, paddr, size);
0217     return 0;
0218 }
0219
0220 int apple_sart_add_allowed_region(struct apple_sart *sart, phys_addr_t paddr,
0221                   size_t size)
0222 {
0223     int i, ret;
0224
0225     for (i = 0; i < APPLE_SART_MAX_ENTRIES; ++i) {
0226         if (test_bit(i, &sart->protected_entries))
0227             continue;
0228         if (test_and_set_bit(i, &sart->used_entries))
0229             continue;
0230
0231         ret = sart_set_entry(sart, i, APPLE_SART_FLAGS_ALLOW, paddr,
0232                      size);
0233         if (ret) {
0234             dev_dbg(sart->dev,
0235                 "unable to set entry %d to [%pa, 0x%zx]\n",
0236                 i, &paddr, size);
0237             clear_bit(i, &sart->used_entries);
0238             return ret;
0239         }
0240
0241         dev_dbg(sart->dev, "wrote [%pa, 0x%zx] to %d\n", &paddr, size,
0242             i);
0243         return 0;
0244     }
0245
0246     dev_warn(sart->dev,
0247          "no free entries left to add [paddr: 0x%pa, size: 0x%zx]\n",
0248          &paddr, size);
0249
0250     return -EBUSY;
0251 }
0252 EXPORT_SYMBOL_GPL(apple_sart_add_allowed_region);
0253
0254 int apple_sart_remove_allowed_region(struct apple_sart *sart, phys_addr_t paddr,
0255                      size_t size)
0256 {
0257     int i;
0258
0259     dev_dbg(sart->dev,
0260         "will remove [paddr: %pa, size: 0x%zx] from allowed regions\n",
0261         &paddr, size);
0262
0263     for (i = 0; i < APPLE_SART_MAX_ENTRIES; ++i) {
0264         u8 eflags;
0265         size_t esize;
0266         phys_addr_t epaddr;
0267
0268         if (test_bit(i, &sart->protected_entries))
0269             continue;
0270
0271         sart->ops->get_entry(sart, i, &eflags, &epaddr, &esize);
0272
0273         if (epaddr != paddr || esize != size)
0274             continue;
0275
0276         sart->ops->set_entry(sart, i, 0, 0, 0);
0277
0278         clear_bit(i, &sart->used_entries);
0279         dev_dbg(sart->dev, "cleared entry %d\n", i);
0280         return 0;
0281     }
0282
0283     dev_warn(sart->dev, "entry [paddr: 0x%pa, size: 0x%zx] not found\n",
0284          &paddr, size);
0285
0286     return -EINVAL;
0287 }
0288 EXPORT_SYMBOL_GPL(apple_sart_remove_allowed_region);
0289
0290 static void apple_sart_shutdown(struct platform_device *pdev)
0291 {
0292     struct apple_sart *sart = dev_get_drvdata(&pdev->dev);
0293     int i;
0294
0295     for (i = 0; i < APPLE_SART_MAX_ENTRIES; ++i) {
0296         if (test_bit(i, &sart->protected_entries))
0297             continue;
0298
0299         sart->ops->set_entry(sart, i, 0, 0, 0);
0300     }
0301 }
0302
0303 static const struct of_device_id apple_sart_of_match[] = {
0304     {
0305         .compatible = "apple,t6000-sart",
0306         .data = &sart_ops_v3,
0307     },
0308     {
0309         .compatible = "apple,t8103-sart",
0310         .data = &sart_ops_v2,
0311     },
0312     {}
0313 };
0314 MODULE_DEVICE_TABLE(of, apple_sart_of_match);
0315
0316 static struct platform_driver apple_sart_driver = {
0317     .driver = {
0318         .name = "apple-sart",
0319         .of_match_table = apple_sart_of_match,
0320     },
0321     .probe = apple_sart_probe,
0322     .shutdown = apple_sart_shutdown,
0323 };
0324 module_platform_driver(apple_sart_driver);
0325
0326 MODULE_LICENSE("Dual MIT/GPL");
0327 MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>");
0328 MODULE_DESCRIPTION("Apple SART driver");