1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright 2011-2012, Meador Inge, Mentor Graphics Corporation.
5 * Some ideas based on un-pushed work done by Vivek Mahajan, Jason Jin, and
6 * Mingkai Hu from Freescale Semiconductor, Inc.
9 #include <linux/list.h>
10 #include <linux/of_address.h>
11 #include <linux/of_irq.h>
12 #include <linux/of_platform.h>
13 #include <linux/errno.h>
14 #include <linux/err.h>
15 #include <linux/export.h>
16 #include <linux/slab.h>
17 #include <asm/hw_irq.h>
18 #include <asm/ppc-pci.h>
19 #include <asm/mpic_msgr.h>
21 #define MPIC_MSGR_REGISTERS_PER_BLOCK 4
22 #define MPIC_MSGR_STRIDE 0x10
23 #define MPIC_MSGR_MER_OFFSET 0x100
27 static struct mpic_msgr **mpic_msgrs;
28 static unsigned int mpic_msgr_count;
29 static DEFINE_RAW_SPINLOCK(msgrs_lock);
31 static inline void _mpic_msgr_mer_write(struct mpic_msgr *msgr, u32 value)
33 out_be32(msgr->mer, value);
36 static inline u32 _mpic_msgr_mer_read(struct mpic_msgr *msgr)
38 return in_be32(msgr->mer);
41 static inline void _mpic_msgr_disable(struct mpic_msgr *msgr)
43 u32 mer = _mpic_msgr_mer_read(msgr);
45 _mpic_msgr_mer_write(msgr, mer & ~(1 << msgr->num));
48 struct mpic_msgr *mpic_msgr_get(unsigned int reg_num)
51 struct mpic_msgr *msgr;
53 /* Assume busy until proven otherwise. */
54 msgr = ERR_PTR(-EBUSY);
56 if (reg_num >= mpic_msgr_count)
57 return ERR_PTR(-ENODEV);
59 raw_spin_lock_irqsave(&msgrs_lock, flags);
60 msgr = mpic_msgrs[reg_num];
61 if (msgr->in_use == MSGR_FREE)
62 msgr->in_use = MSGR_INUSE;
63 raw_spin_unlock_irqrestore(&msgrs_lock, flags);
67 EXPORT_SYMBOL_GPL(mpic_msgr_get);
69 void mpic_msgr_put(struct mpic_msgr *msgr)
73 raw_spin_lock_irqsave(&msgr->lock, flags);
74 msgr->in_use = MSGR_FREE;
75 _mpic_msgr_disable(msgr);
76 raw_spin_unlock_irqrestore(&msgr->lock, flags);
78 EXPORT_SYMBOL_GPL(mpic_msgr_put);
80 void mpic_msgr_enable(struct mpic_msgr *msgr)
85 raw_spin_lock_irqsave(&msgr->lock, flags);
86 mer = _mpic_msgr_mer_read(msgr);
87 _mpic_msgr_mer_write(msgr, mer | (1 << msgr->num));
88 raw_spin_unlock_irqrestore(&msgr->lock, flags);
90 EXPORT_SYMBOL_GPL(mpic_msgr_enable);
92 void mpic_msgr_disable(struct mpic_msgr *msgr)
96 raw_spin_lock_irqsave(&msgr->lock, flags);
97 _mpic_msgr_disable(msgr);
98 raw_spin_unlock_irqrestore(&msgr->lock, flags);
100 EXPORT_SYMBOL_GPL(mpic_msgr_disable);
102 /* The following three functions are used to compute the order and number of
103 * the message register blocks. They are clearly very inefficient. However,
104 * they are called *only* a few times during device initialization.
106 static unsigned int mpic_msgr_number_of_blocks(void)
109 struct device_node *aliases;
112 aliases = of_find_node_by_name(NULL, "aliases");
118 snprintf(buf, sizeof(buf), "mpic-msgr-block%d", count);
119 if (!of_find_property(aliases, buf, NULL))
129 static unsigned int mpic_msgr_number_of_registers(void)
131 return mpic_msgr_number_of_blocks() * MPIC_MSGR_REGISTERS_PER_BLOCK;
134 static int mpic_msgr_block_number(struct device_node *node)
136 struct device_node *aliases;
137 unsigned int index, number_of_blocks;
140 number_of_blocks = mpic_msgr_number_of_blocks();
141 aliases = of_find_node_by_name(NULL, "aliases");
145 for (index = 0; index < number_of_blocks; ++index) {
146 struct property *prop;
148 snprintf(buf, sizeof(buf), "mpic-msgr-block%d", index);
149 prop = of_find_property(aliases, buf, NULL);
150 if (node == of_find_node_by_path(prop->value))
154 return index == number_of_blocks ? -1 : index;
157 /* The probe function for a single message register block.
159 static int mpic_msgr_probe(struct platform_device *dev)
161 void __iomem *msgr_block_addr;
163 struct resource rsrc;
165 unsigned int irq_index;
166 struct device_node *np = dev->dev.of_node;
167 unsigned int receive_mask;
168 const unsigned int *prop;
171 dev_err(&dev->dev, "Device OF-Node is NULL");
175 /* Allocate the message register array upon the first device
179 mpic_msgr_count = mpic_msgr_number_of_registers();
180 dev_info(&dev->dev, "Found %d message registers\n",
183 mpic_msgrs = kcalloc(mpic_msgr_count, sizeof(*mpic_msgrs),
187 "No memory for message register blocks\n");
191 dev_info(&dev->dev, "Of-device full name %pOF\n", np);
193 /* IO map the message register block. */
194 of_address_to_resource(np, 0, &rsrc);
195 msgr_block_addr = devm_ioremap(&dev->dev, rsrc.start, resource_size(&rsrc));
196 if (!msgr_block_addr) {
197 dev_err(&dev->dev, "Failed to iomap MPIC message registers");
201 /* Ensure the block has a defined order. */
202 block_number = mpic_msgr_block_number(np);
203 if (block_number < 0) {
205 "Failed to find message register block alias\n");
208 dev_info(&dev->dev, "Setting up message register block %d\n",
211 /* Grab the receive mask which specifies what registers can receive
214 prop = of_get_property(np, "mpic-msgr-receive-mask", NULL);
215 receive_mask = (prop) ? *prop : 0xF;
217 /* Build up the appropriate message register data structures. */
218 for (i = 0, irq_index = 0; i < MPIC_MSGR_REGISTERS_PER_BLOCK; ++i) {
219 struct mpic_msgr *msgr;
220 unsigned int reg_number;
222 msgr = kzalloc(sizeof(struct mpic_msgr), GFP_KERNEL);
224 dev_err(&dev->dev, "No memory for message register\n");
228 reg_number = block_number * MPIC_MSGR_REGISTERS_PER_BLOCK + i;
229 msgr->base = msgr_block_addr + i * MPIC_MSGR_STRIDE;
230 msgr->mer = (u32 *)((u8 *)msgr->base + MPIC_MSGR_MER_OFFSET);
231 msgr->in_use = MSGR_FREE;
233 raw_spin_lock_init(&msgr->lock);
235 if (receive_mask & (1 << i)) {
236 msgr->irq = irq_of_parse_and_map(np, irq_index);
239 "Missing interrupt specifier");
248 mpic_msgrs[reg_number] = msgr;
249 mpic_msgr_disable(msgr);
250 dev_info(&dev->dev, "Register %d initialized: irq %d\n",
251 reg_number, msgr->irq);
258 static const struct of_device_id mpic_msgr_ids[] = {
260 .compatible = "fsl,mpic-v3.1-msgr",
266 static struct platform_driver mpic_msgr_driver = {
269 .of_match_table = mpic_msgr_ids,
271 .probe = mpic_msgr_probe,
274 static __init int mpic_msgr_init(void)
276 return platform_driver_register(&mpic_msgr_driver);
278 subsys_initcall(mpic_msgr_init);