1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * arch/powerpc/sysdev/qe_lib/qe_ic.c
5 * Copyright (C) 2006 Freescale Semiconductor, Inc. All rights reserved.
7 * Author: Li Yang <leoli@freescale.com>
8 * Based on code from Shlomi Gridish <gridish@freescale.com>
10 * QUICC ENGINE Interrupt Controller
13 #include <linux/of_irq.h>
14 #include <linux/of_address.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/errno.h>
18 #include <linux/reboot.h>
19 #include <linux/slab.h>
20 #include <linux/stddef.h>
21 #include <linux/sched.h>
22 #include <linux/signal.h>
23 #include <linux/device.h>
24 #include <linux/spinlock.h>
27 #include <soc/fsl/qe/qe.h>
28 #include <soc/fsl/qe/qe_ic.h>
32 static DEFINE_RAW_SPINLOCK(qe_ic_lock);
34 static struct qe_ic_info qe_ic_info[] = {
37 .mask_reg = QEIC_CIMR,
39 .pri_reg = QEIC_CIPWCC,
43 .mask_reg = QEIC_CIMR,
45 .pri_reg = QEIC_CIPWCC,
49 .mask_reg = QEIC_CIMR,
51 .pri_reg = QEIC_CIPWCC,
55 .mask_reg = QEIC_CIMR,
57 .pri_reg = QEIC_CIPZCC,
61 .mask_reg = QEIC_CIMR,
63 .pri_reg = QEIC_CIPZCC,
67 .mask_reg = QEIC_CIMR,
69 .pri_reg = QEIC_CIPZCC,
73 .mask_reg = QEIC_CIMR,
75 .pri_reg = QEIC_CIPZCC,
79 .mask_reg = QEIC_CIMR,
81 .pri_reg = QEIC_CIPZCC,
85 .mask_reg = QEIC_CIMR,
87 .pri_reg = QEIC_CIPZCC,
91 .mask_reg = QEIC_CRIMR,
93 .pri_reg = QEIC_CIPRTA,
97 .mask_reg = QEIC_CRIMR,
99 .pri_reg = QEIC_CIPRTB,
103 .mask_reg = QEIC_CRIMR,
105 .pri_reg = QEIC_CIPRTB,
109 .mask_reg = QEIC_CRIMR,
111 .pri_reg = QEIC_CIPRTB,
115 .mask_reg = QEIC_CRIMR,
117 .pri_reg = QEIC_CIPRTB,
121 .mask_reg = QEIC_CIMR,
123 .pri_reg = QEIC_CIPXCC,
127 .mask_reg = QEIC_CIMR,
129 .pri_reg = QEIC_CIPXCC,
133 .mask_reg = QEIC_CIMR,
135 .pri_reg = QEIC_CIPXCC,
139 .mask_reg = QEIC_CIMR,
141 .pri_reg = QEIC_CIPXCC,
145 .mask_reg = QEIC_CIMR,
147 .pri_reg = QEIC_CIPXCC,
151 .mask_reg = QEIC_CIMR,
153 .pri_reg = QEIC_CIPYCC,
157 .mask_reg = QEIC_CIMR,
159 .pri_reg = QEIC_CIPYCC,
163 .mask_reg = QEIC_CIMR,
165 .pri_reg = QEIC_CIPYCC,
169 .mask_reg = QEIC_CIMR,
171 .pri_reg = QEIC_CIPYCC,
175 static inline u32 qe_ic_read(__be32 __iomem *base, unsigned int reg)
177 return qe_ioread32be(base + (reg >> 2));
180 static inline void qe_ic_write(__be32 __iomem *base, unsigned int reg,
183 qe_iowrite32be(value, base + (reg >> 2));
186 static inline struct qe_ic *qe_ic_from_irq(unsigned int virq)
188 return irq_get_chip_data(virq);
191 static inline struct qe_ic *qe_ic_from_irq_data(struct irq_data *d)
193 return irq_data_get_irq_chip_data(d);
196 static void qe_ic_unmask_irq(struct irq_data *d)
198 struct qe_ic *qe_ic = qe_ic_from_irq_data(d);
199 unsigned int src = irqd_to_hwirq(d);
203 raw_spin_lock_irqsave(&qe_ic_lock, flags);
205 temp = qe_ic_read(qe_ic->regs, qe_ic_info[src].mask_reg);
206 qe_ic_write(qe_ic->regs, qe_ic_info[src].mask_reg,
207 temp | qe_ic_info[src].mask);
209 raw_spin_unlock_irqrestore(&qe_ic_lock, flags);
212 static void qe_ic_mask_irq(struct irq_data *d)
214 struct qe_ic *qe_ic = qe_ic_from_irq_data(d);
215 unsigned int src = irqd_to_hwirq(d);
219 raw_spin_lock_irqsave(&qe_ic_lock, flags);
221 temp = qe_ic_read(qe_ic->regs, qe_ic_info[src].mask_reg);
222 qe_ic_write(qe_ic->regs, qe_ic_info[src].mask_reg,
223 temp & ~qe_ic_info[src].mask);
225 /* Flush the above write before enabling interrupts; otherwise,
226 * spurious interrupts will sometimes happen. To be 100% sure
227 * that the write has reached the device before interrupts are
228 * enabled, the mask register would have to be read back; however,
229 * this is not required for correctness, only to avoid wasting
230 * time on a large number of spurious interrupts. In testing,
231 * a sync reduced the observed spurious interrupts to zero.
235 raw_spin_unlock_irqrestore(&qe_ic_lock, flags);
238 static struct irq_chip qe_ic_irq_chip = {
240 .irq_unmask = qe_ic_unmask_irq,
241 .irq_mask = qe_ic_mask_irq,
242 .irq_mask_ack = qe_ic_mask_irq,
245 static int qe_ic_host_match(struct irq_domain *h, struct device_node *node,
246 enum irq_domain_bus_token bus_token)
248 /* Exact match, unless qe_ic node is NULL */
249 struct device_node *of_node = irq_domain_get_of_node(h);
250 return of_node == NULL || of_node == node;
253 static int qe_ic_host_map(struct irq_domain *h, unsigned int virq,
256 struct qe_ic *qe_ic = h->host_data;
257 struct irq_chip *chip;
259 if (hw >= ARRAY_SIZE(qe_ic_info)) {
260 pr_err("%s: Invalid hw irq number for QEIC\n", __func__);
264 if (qe_ic_info[hw].mask == 0) {
265 printk(KERN_ERR "Can't map reserved IRQ\n");
269 chip = &qe_ic->hc_irq;
271 irq_set_chip_data(virq, qe_ic);
272 irq_set_status_flags(virq, IRQ_LEVEL);
274 irq_set_chip_and_handler(virq, chip, handle_level_irq);
279 static const struct irq_domain_ops qe_ic_host_ops = {
280 .match = qe_ic_host_match,
281 .map = qe_ic_host_map,
282 .xlate = irq_domain_xlate_onetwocell,
285 /* Return an interrupt vector or NO_IRQ if no interrupt is pending. */
286 unsigned int qe_ic_get_low_irq(struct qe_ic *qe_ic)
290 BUG_ON(qe_ic == NULL);
292 /* get the interrupt source vector. */
293 irq = qe_ic_read(qe_ic->regs, QEIC_CIVEC) >> 26;
298 return irq_linear_revmap(qe_ic->irqhost, irq);
301 /* Return an interrupt vector or NO_IRQ if no interrupt is pending. */
302 unsigned int qe_ic_get_high_irq(struct qe_ic *qe_ic)
306 BUG_ON(qe_ic == NULL);
308 /* get the interrupt source vector. */
309 irq = qe_ic_read(qe_ic->regs, QEIC_CHIVEC) >> 26;
314 return irq_linear_revmap(qe_ic->irqhost, irq);
317 void __init qe_ic_init(struct device_node *node, unsigned int flags,
318 void (*low_handler)(struct irq_desc *desc),
319 void (*high_handler)(struct irq_desc *desc))
323 u32 temp = 0, ret, high_active = 0;
325 ret = of_address_to_resource(node, 0, &res);
329 qe_ic = kzalloc(sizeof(*qe_ic), GFP_KERNEL);
333 qe_ic->irqhost = irq_domain_add_linear(node, NR_QE_IC_INTS,
334 &qe_ic_host_ops, qe_ic);
335 if (qe_ic->irqhost == NULL) {
340 qe_ic->regs = ioremap(res.start, resource_size(&res));
342 qe_ic->hc_irq = qe_ic_irq_chip;
344 qe_ic->virq_high = irq_of_parse_and_map(node, 0);
345 qe_ic->virq_low = irq_of_parse_and_map(node, 1);
347 if (qe_ic->virq_low == NO_IRQ) {
348 printk(KERN_ERR "Failed to map QE_IC low IRQ\n");
353 /* default priority scheme is grouped. If spread mode is */
354 /* required, configure cicr accordingly. */
355 if (flags & QE_IC_SPREADMODE_GRP_W)
357 if (flags & QE_IC_SPREADMODE_GRP_X)
359 if (flags & QE_IC_SPREADMODE_GRP_Y)
361 if (flags & QE_IC_SPREADMODE_GRP_Z)
363 if (flags & QE_IC_SPREADMODE_GRP_RISCA)
365 if (flags & QE_IC_SPREADMODE_GRP_RISCB)
368 /* choose destination signal for highest priority interrupt */
369 if (flags & QE_IC_HIGH_SIGNAL) {
370 temp |= (SIGNAL_HIGH << CICR_HPIT_SHIFT);
374 qe_ic_write(qe_ic->regs, QEIC_CICR, temp);
376 irq_set_handler_data(qe_ic->virq_low, qe_ic);
377 irq_set_chained_handler(qe_ic->virq_low, low_handler);
379 if (qe_ic->virq_high != NO_IRQ &&
380 qe_ic->virq_high != qe_ic->virq_low) {
381 irq_set_handler_data(qe_ic->virq_high, qe_ic);
382 irq_set_chained_handler(qe_ic->virq_high, high_handler);
386 void qe_ic_set_highest_priority(unsigned int virq, int high)
388 struct qe_ic *qe_ic = qe_ic_from_irq(virq);
389 unsigned int src = virq_to_hw(virq);
392 temp = qe_ic_read(qe_ic->regs, QEIC_CICR);
394 temp &= ~CICR_HP_MASK;
395 temp |= src << CICR_HP_SHIFT;
397 temp &= ~CICR_HPIT_MASK;
398 temp |= (high ? SIGNAL_HIGH : SIGNAL_LOW) << CICR_HPIT_SHIFT;
400 qe_ic_write(qe_ic->regs, QEIC_CICR, temp);
403 /* Set Priority level within its group, from 1 to 8 */
404 int qe_ic_set_priority(unsigned int virq, unsigned int priority)
406 struct qe_ic *qe_ic = qe_ic_from_irq(virq);
407 unsigned int src = virq_to_hw(virq);
410 if (priority > 8 || priority == 0)
412 if (WARN_ONCE(src >= ARRAY_SIZE(qe_ic_info),
413 "%s: Invalid hw irq number for QEIC\n", __func__))
415 if (qe_ic_info[src].pri_reg == 0)
418 temp = qe_ic_read(qe_ic->regs, qe_ic_info[src].pri_reg);
421 temp &= ~(0x7 << (32 - priority * 3));
422 temp |= qe_ic_info[src].pri_code << (32 - priority * 3);
424 temp &= ~(0x7 << (24 - priority * 3));
425 temp |= qe_ic_info[src].pri_code << (24 - priority * 3);
428 qe_ic_write(qe_ic->regs, qe_ic_info[src].pri_reg, temp);
433 /* Set a QE priority to use high irq, only priority 1~2 can use high irq */
434 int qe_ic_set_high_priority(unsigned int virq, unsigned int priority, int high)
436 struct qe_ic *qe_ic = qe_ic_from_irq(virq);
437 unsigned int src = virq_to_hw(virq);
438 u32 temp, control_reg = QEIC_CICNR, shift = 0;
440 if (priority > 2 || priority == 0)
442 if (WARN_ONCE(src >= ARRAY_SIZE(qe_ic_info),
443 "%s: Invalid hw irq number for QEIC\n", __func__))
446 switch (qe_ic_info[src].pri_reg) {
448 shift = CICNR_ZCC1T_SHIFT;
451 shift = CICNR_WCC1T_SHIFT;
454 shift = CICNR_YCC1T_SHIFT;
457 shift = CICNR_XCC1T_SHIFT;
460 shift = CRICR_RTA1T_SHIFT;
461 control_reg = QEIC_CRICR;
464 shift = CRICR_RTB1T_SHIFT;
465 control_reg = QEIC_CRICR;
471 shift += (2 - priority) * 2;
472 temp = qe_ic_read(qe_ic->regs, control_reg);
473 temp &= ~(SIGNAL_MASK << shift);
474 temp |= (high ? SIGNAL_HIGH : SIGNAL_LOW) << shift;
475 qe_ic_write(qe_ic->regs, control_reg, temp);
480 static struct bus_type qe_ic_subsys = {
485 static struct device device_qe_ic = {
487 .bus = &qe_ic_subsys,
490 static int __init init_qe_ic_sysfs(void)
494 printk(KERN_DEBUG "Registering qe_ic with sysfs...\n");
496 rc = subsys_system_register(&qe_ic_subsys, NULL);
498 printk(KERN_ERR "Failed registering qe_ic sys class\n");
501 rc = device_register(&device_qe_ic);
503 printk(KERN_ERR "Failed registering qe_ic sys device\n");
509 subsys_initcall(init_qe_ic_sysfs);