1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for UniPhier AIDET (ARM Interrupt Detector) 4 * 5 * Copyright (C) 2017 Socionext Inc. 6 * Author: Masahiro Yamada <yamada.masahiro@socionext.com> 7 */ 8 9 #include <linux/bitops.h> 10 #include <linux/init.h> 11 #include <linux/irq.h> 12 #include <linux/irqdomain.h> 13 #include <linux/kernel.h> 14 #include <linux/of.h> 15 #include <linux/of_device.h> 16 #include <linux/of_irq.h> 17 #include <linux/platform_device.h> 18 #include <linux/spinlock.h> 19 20 #define UNIPHIER_AIDET_NR_IRQS 256 21 22 #define UNIPHIER_AIDET_DETCONF 0x04 /* inverter register base */ 23 24 struct uniphier_aidet_priv { 25 struct irq_domain *domain; 26 void __iomem *reg_base; 27 spinlock_t lock; 28 u32 saved_vals[UNIPHIER_AIDET_NR_IRQS / 32]; 29 }; 30 31 static void uniphier_aidet_reg_update(struct uniphier_aidet_priv *priv, 32 unsigned int reg, u32 mask, u32 val) 33 { 34 unsigned long flags; 35 u32 tmp; 36 37 spin_lock_irqsave(&priv->lock, flags); 38 tmp = readl_relaxed(priv->reg_base + reg); 39 tmp &= ~mask; 40 tmp |= mask & val; 41 writel_relaxed(tmp, priv->reg_base + reg); 42 spin_unlock_irqrestore(&priv->lock, flags); 43 } 44 45 static void uniphier_aidet_detconf_update(struct uniphier_aidet_priv *priv, 46 unsigned long index, unsigned int val) 47 { 48 unsigned int reg; 49 u32 mask; 50 51 reg = UNIPHIER_AIDET_DETCONF + index / 32 * 4; 52 mask = BIT(index % 32); 53 54 uniphier_aidet_reg_update(priv, reg, mask, val ? mask : 0); 55 } 56 57 static int uniphier_aidet_irq_set_type(struct irq_data *data, unsigned int type) 58 { 59 struct uniphier_aidet_priv *priv = data->chip_data; 60 unsigned int val; 61 62 /* enable inverter for active low triggers */ 63 switch (type) { 64 case IRQ_TYPE_EDGE_RISING: 65 case IRQ_TYPE_LEVEL_HIGH: 66 val = 0; 67 break; 68 case IRQ_TYPE_EDGE_FALLING: 69 val = 1; 70 type = IRQ_TYPE_EDGE_RISING; 71 break; 72 case IRQ_TYPE_LEVEL_LOW: 73 val = 1; 74 type = IRQ_TYPE_LEVEL_HIGH; 75 break; 76 default: 77 return -EINVAL; 78 } 79 80 uniphier_aidet_detconf_update(priv, data->hwirq, val); 81 82 return irq_chip_set_type_parent(data, type); 83 } 84 85 static struct irq_chip uniphier_aidet_irq_chip = { 86 .name = "AIDET", 87 .irq_mask = irq_chip_mask_parent, 88 .irq_unmask = irq_chip_unmask_parent, 89 .irq_eoi = irq_chip_eoi_parent, 90 .irq_set_affinity = irq_chip_set_affinity_parent, 91 .irq_set_type = uniphier_aidet_irq_set_type, 92 }; 93 94 static int uniphier_aidet_domain_translate(struct irq_domain *domain, 95 struct irq_fwspec *fwspec, 96 unsigned long *out_hwirq, 97 unsigned int *out_type) 98 { 99 if (WARN_ON(fwspec->param_count < 2)) 100 return -EINVAL; 101 102 *out_hwirq = fwspec->param[0]; 103 *out_type = fwspec->param[1] & IRQ_TYPE_SENSE_MASK; 104 105 return 0; 106 } 107 108 static int uniphier_aidet_domain_alloc(struct irq_domain *domain, 109 unsigned int virq, unsigned int nr_irqs, 110 void *arg) 111 { 112 struct irq_fwspec parent_fwspec; 113 irq_hw_number_t hwirq; 114 unsigned int type; 115 int ret; 116 117 if (nr_irqs != 1) 118 return -EINVAL; 119 120 ret = uniphier_aidet_domain_translate(domain, arg, &hwirq, &type); 121 if (ret) 122 return ret; 123 124 switch (type) { 125 case IRQ_TYPE_EDGE_RISING: 126 case IRQ_TYPE_LEVEL_HIGH: 127 break; 128 case IRQ_TYPE_EDGE_FALLING: 129 type = IRQ_TYPE_EDGE_RISING; 130 break; 131 case IRQ_TYPE_LEVEL_LOW: 132 type = IRQ_TYPE_LEVEL_HIGH; 133 break; 134 default: 135 return -EINVAL; 136 } 137 138 if (hwirq >= UNIPHIER_AIDET_NR_IRQS) 139 return -ENXIO; 140 141 ret = irq_domain_set_hwirq_and_chip(domain, virq, hwirq, 142 &uniphier_aidet_irq_chip, 143 domain->host_data); 144 if (ret) 145 return ret; 146 147 /* parent is GIC */ 148 parent_fwspec.fwnode = domain->parent->fwnode; 149 parent_fwspec.param_count = 3; 150 parent_fwspec.param[0] = 0; /* SPI */ 151 parent_fwspec.param[1] = hwirq; 152 parent_fwspec.param[2] = type; 153 154 return irq_domain_alloc_irqs_parent(domain, virq, 1, &parent_fwspec); 155 } 156 157 static const struct irq_domain_ops uniphier_aidet_domain_ops = { 158 .alloc = uniphier_aidet_domain_alloc, 159 .free = irq_domain_free_irqs_common, 160 .translate = uniphier_aidet_domain_translate, 161 }; 162 163 static int uniphier_aidet_probe(struct platform_device *pdev) 164 { 165 struct device *dev = &pdev->dev; 166 struct device_node *parent_np; 167 struct irq_domain *parent_domain; 168 struct uniphier_aidet_priv *priv; 169 struct resource *res; 170 171 parent_np = of_irq_find_parent(dev->of_node); 172 if (!parent_np) 173 return -ENXIO; 174 175 parent_domain = irq_find_host(parent_np); 176 of_node_put(parent_np); 177 if (!parent_domain) 178 return -EPROBE_DEFER; 179 180 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 181 if (!priv) 182 return -ENOMEM; 183 184 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 185 priv->reg_base = devm_ioremap_resource(dev, res); 186 if (IS_ERR(priv->reg_base)) 187 return PTR_ERR(priv->reg_base); 188 189 spin_lock_init(&priv->lock); 190 191 priv->domain = irq_domain_create_hierarchy( 192 parent_domain, 0, 193 UNIPHIER_AIDET_NR_IRQS, 194 of_node_to_fwnode(dev->of_node), 195 &uniphier_aidet_domain_ops, priv); 196 if (!priv->domain) 197 return -ENOMEM; 198 199 platform_set_drvdata(pdev, priv); 200 201 return 0; 202 } 203 204 static int __maybe_unused uniphier_aidet_suspend(struct device *dev) 205 { 206 struct uniphier_aidet_priv *priv = dev_get_drvdata(dev); 207 int i; 208 209 for (i = 0; i < ARRAY_SIZE(priv->saved_vals); i++) 210 priv->saved_vals[i] = readl_relaxed( 211 priv->reg_base + UNIPHIER_AIDET_DETCONF + i * 4); 212 213 return 0; 214 } 215 216 static int __maybe_unused uniphier_aidet_resume(struct device *dev) 217 { 218 struct uniphier_aidet_priv *priv = dev_get_drvdata(dev); 219 int i; 220 221 for (i = 0; i < ARRAY_SIZE(priv->saved_vals); i++) 222 writel_relaxed(priv->saved_vals[i], 223 priv->reg_base + UNIPHIER_AIDET_DETCONF + i * 4); 224 225 return 0; 226 } 227 228 static const struct dev_pm_ops uniphier_aidet_pm_ops = { 229 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(uniphier_aidet_suspend, 230 uniphier_aidet_resume) 231 }; 232 233 static const struct of_device_id uniphier_aidet_match[] = { 234 { .compatible = "socionext,uniphier-ld4-aidet" }, 235 { .compatible = "socionext,uniphier-pro4-aidet" }, 236 { .compatible = "socionext,uniphier-sld8-aidet" }, 237 { .compatible = "socionext,uniphier-pro5-aidet" }, 238 { .compatible = "socionext,uniphier-pxs2-aidet" }, 239 { .compatible = "socionext,uniphier-ld11-aidet" }, 240 { .compatible = "socionext,uniphier-ld20-aidet" }, 241 { .compatible = "socionext,uniphier-pxs3-aidet" }, 242 { /* sentinel */ } 243 }; 244 245 static struct platform_driver uniphier_aidet_driver = { 246 .probe = uniphier_aidet_probe, 247 .driver = { 248 .name = "uniphier-aidet", 249 .of_match_table = uniphier_aidet_match, 250 .pm = &uniphier_aidet_pm_ops, 251 }, 252 }; 253 builtin_platform_driver(uniphier_aidet_driver); 254