1 /* 2 * Texas Instruments Keystone IRQ controller IP driver 3 * 4 * Copyright (C) 2014 Texas Instruments, Inc. 5 * Author: Sajesh Kumar Saran <sajesh@ti.com> 6 * Grygorii Strashko <grygorii.strashko@ti.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation version 2. 11 * 12 * This program is distributed "as is" WITHOUT ANY WARRANTY of any 13 * kind, whether express or implied; without even the implied warranty 14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 */ 17 18 #include <linux/irq.h> 19 #include <linux/bitops.h> 20 #include <linux/module.h> 21 #include <linux/moduleparam.h> 22 #include <linux/irqdomain.h> 23 #include <linux/irqchip.h> 24 #include <linux/irqchip/chained_irq.h> 25 #include <linux/of.h> 26 #include <linux/of_platform.h> 27 #include <linux/mfd/syscon.h> 28 #include <linux/regmap.h> 29 30 /* The source ID bits start from 4 to 31 (total 28 bits)*/ 31 #define BIT_OFS 4 32 #define KEYSTONE_N_IRQ (32 - BIT_OFS) 33 34 struct keystone_irq_device { 35 struct device *dev; 36 struct irq_chip chip; 37 u32 mask; 38 int irq; 39 struct irq_domain *irqd; 40 struct regmap *devctrl_regs; 41 u32 devctrl_offset; 42 }; 43 44 static inline u32 keystone_irq_readl(struct keystone_irq_device *kirq) 45 { 46 int ret; 47 u32 val = 0; 48 49 ret = regmap_read(kirq->devctrl_regs, kirq->devctrl_offset, &val); 50 if (ret < 0) 51 dev_dbg(kirq->dev, "irq read failed ret(%d)\n", ret); 52 return val; 53 } 54 55 static inline void 56 keystone_irq_writel(struct keystone_irq_device *kirq, u32 value) 57 { 58 int ret; 59 60 ret = regmap_write(kirq->devctrl_regs, kirq->devctrl_offset, value); 61 if (ret < 0) 62 dev_dbg(kirq->dev, "irq write failed ret(%d)\n", ret); 63 } 64 65 static void keystone_irq_setmask(struct irq_data *d) 66 { 67 struct keystone_irq_device *kirq = irq_data_get_irq_chip_data(d); 68 69 kirq->mask |= BIT(d->hwirq); 70 dev_dbg(kirq->dev, "mask %lu [%x]\n", d->hwirq, kirq->mask); 71 } 72 73 static void keystone_irq_unmask(struct irq_data *d) 74 { 75 struct keystone_irq_device *kirq = irq_data_get_irq_chip_data(d); 76 77 kirq->mask &= ~BIT(d->hwirq); 78 dev_dbg(kirq->dev, "unmask %lu [%x]\n", d->hwirq, kirq->mask); 79 } 80 81 static void keystone_irq_ack(struct irq_data *d) 82 { 83 /* nothing to do here */ 84 } 85 86 static void keystone_irq_handler(struct irq_desc *desc) 87 { 88 unsigned int irq = irq_desc_get_irq(desc); 89 struct keystone_irq_device *kirq = irq_desc_get_handler_data(desc); 90 unsigned long pending; 91 int src, virq; 92 93 dev_dbg(kirq->dev, "start irq %d\n", irq); 94 95 chained_irq_enter(irq_desc_get_chip(desc), desc); 96 97 pending = keystone_irq_readl(kirq); 98 keystone_irq_writel(kirq, pending); 99 100 dev_dbg(kirq->dev, "pending 0x%lx, mask 0x%x\n", pending, kirq->mask); 101 102 pending = (pending >> BIT_OFS) & ~kirq->mask; 103 104 dev_dbg(kirq->dev, "pending after mask 0x%lx\n", pending); 105 106 for (src = 0; src < KEYSTONE_N_IRQ; src++) { 107 if (BIT(src) & pending) { 108 virq = irq_find_mapping(kirq->irqd, src); 109 dev_dbg(kirq->dev, "dispatch bit %d, virq %d\n", 110 src, virq); 111 if (!virq) 112 dev_warn(kirq->dev, "sporious irq detected hwirq %d, virq %d\n", 113 src, virq); 114 generic_handle_irq(virq); 115 } 116 } 117 118 chained_irq_exit(irq_desc_get_chip(desc), desc); 119 120 dev_dbg(kirq->dev, "end irq %d\n", irq); 121 } 122 123 static int keystone_irq_map(struct irq_domain *h, unsigned int virq, 124 irq_hw_number_t hw) 125 { 126 struct keystone_irq_device *kirq = h->host_data; 127 128 irq_set_chip_data(virq, kirq); 129 irq_set_chip_and_handler(virq, &kirq->chip, handle_level_irq); 130 set_irq_flags(virq, IRQF_VALID | IRQF_PROBE); 131 return 0; 132 } 133 134 static const struct irq_domain_ops keystone_irq_ops = { 135 .map = keystone_irq_map, 136 .xlate = irq_domain_xlate_onecell, 137 }; 138 139 static int keystone_irq_probe(struct platform_device *pdev) 140 { 141 struct device *dev = &pdev->dev; 142 struct device_node *np = dev->of_node; 143 struct keystone_irq_device *kirq; 144 int ret; 145 146 if (np == NULL) 147 return -EINVAL; 148 149 kirq = devm_kzalloc(dev, sizeof(*kirq), GFP_KERNEL); 150 if (!kirq) 151 return -ENOMEM; 152 153 kirq->devctrl_regs = 154 syscon_regmap_lookup_by_phandle(np, "ti,syscon-dev"); 155 if (IS_ERR(kirq->devctrl_regs)) 156 return PTR_ERR(kirq->devctrl_regs); 157 158 ret = of_property_read_u32_index(np, "ti,syscon-dev", 1, 159 &kirq->devctrl_offset); 160 if (ret) { 161 dev_err(dev, "couldn't read the devctrl_offset offset!\n"); 162 return ret; 163 } 164 165 kirq->irq = platform_get_irq(pdev, 0); 166 if (kirq->irq < 0) { 167 dev_err(dev, "no irq resource %d\n", kirq->irq); 168 return kirq->irq; 169 } 170 171 kirq->dev = dev; 172 kirq->mask = ~0x0; 173 kirq->chip.name = "keystone-irq"; 174 kirq->chip.irq_ack = keystone_irq_ack; 175 kirq->chip.irq_mask = keystone_irq_setmask; 176 kirq->chip.irq_unmask = keystone_irq_unmask; 177 178 kirq->irqd = irq_domain_add_linear(np, KEYSTONE_N_IRQ, 179 &keystone_irq_ops, kirq); 180 if (!kirq->irqd) { 181 dev_err(dev, "IRQ domain registration failed\n"); 182 return -ENODEV; 183 } 184 185 platform_set_drvdata(pdev, kirq); 186 187 irq_set_chained_handler_and_data(kirq->irq, keystone_irq_handler, kirq); 188 189 /* clear all source bits */ 190 keystone_irq_writel(kirq, ~0x0); 191 192 dev_info(dev, "irqchip registered, nr_irqs %u\n", KEYSTONE_N_IRQ); 193 194 return 0; 195 } 196 197 static int keystone_irq_remove(struct platform_device *pdev) 198 { 199 struct keystone_irq_device *kirq = platform_get_drvdata(pdev); 200 int hwirq; 201 202 for (hwirq = 0; hwirq < KEYSTONE_N_IRQ; hwirq++) 203 irq_dispose_mapping(irq_find_mapping(kirq->irqd, hwirq)); 204 205 irq_domain_remove(kirq->irqd); 206 return 0; 207 } 208 209 static const struct of_device_id keystone_irq_dt_ids[] = { 210 { .compatible = "ti,keystone-irq", }, 211 {}, 212 }; 213 MODULE_DEVICE_TABLE(of, keystone_irq_dt_ids); 214 215 static struct platform_driver keystone_irq_device_driver = { 216 .probe = keystone_irq_probe, 217 .remove = keystone_irq_remove, 218 .driver = { 219 .name = "keystone_irq", 220 .of_match_table = of_match_ptr(keystone_irq_dt_ids), 221 } 222 }; 223 224 module_platform_driver(keystone_irq_device_driver); 225 226 MODULE_AUTHOR("Texas Instruments"); 227 MODULE_AUTHOR("Sajesh Kumar Saran"); 228 MODULE_AUTHOR("Grygorii Strashko"); 229 MODULE_DESCRIPTION("Keystone IRQ chip"); 230 MODULE_LICENSE("GPL v2"); 231