MPIC Bindings and Bindings for AMP Systems
Hi All,
I am currently doing some work on Linux PPC AMP systems (with Hollis, CC'd). We are using device trees to partition resources between the different OSes. To help with this effort, we would like to introduce some new bindings to the MPIC.
Currently, there are no bindings for the MPIC under '.../Documentation/powerpc/dts-bindings/'. I think most folks are following the IEEE 1275 bindings for Open PIC.
It would be nice to check-in a binding for the MPIC that is a superset of the 1275 bindings as a place to document extensions. The already in use property 'protected-sources', for example, could be placed there.
I have included a draft proposal of what this would like. It includes some properties ('no-reset') and a node (for message registers) that we are currently using for our AMP implementation and we would really like to push upstream. If the general idea seems sound, then I will clean up the proposal and submit a patch for the bindings.
Thoughts?
============================
* MPIC Binding
This binding specifies what properties and child nodes must be available on the device tree representation of the MPIC interrupt controller. This binding is a superset of the binding defined for Open PIC in [1].
** Required properties:
- All of the required properties mentioned in [1].
** Optional properties:
- no-reset : the presence of this property indicates that the interrupt controller should not be reset during OS initialization.
- protected-sources : a list of interrupt sources that are not available for use.
** Example:
mpic: pic@40000 {
interrupt-controller;
#address-cells = <0>;
#interrupt-cells = <2>;
reg = <0x40000 0x40000>;
compatible = "chrp,open-pic";
device_type = "open-pic";
protected-sources = <0xb1 0xb2>;
no-reset;
};* MPIC Message Registers
This binding specifies how the MPIC message registers implemented on some Freescale platforms for interprocessor communication should be represented.
** Required parent:
- Message register nodes should always been nested under a MPIC node.
** Required properties:
- compatible : compatible list, contains 2 entries, first is "fsl,CHIP-msgr", where CHIP is the processor (p2020, mpc8572, etc ...) and the second is "fsl,mpic-msgr".
- reg : should contain the address and the length of the
message register block.
- cell-index : the index of the message register block.
- interrupts : each one of the interrupts here represents the interrupt line for one message register. These interrupts are routed internally to the MPIC.
NOTE: The 'interrupt-parent' is implicit since message register nodes
are always children of interrupt controller nodes.
** Example:
mpic: pic@40000 {
interrupt-controller;
#address-cells = <0>;
#interrupt-cells = <2>;
reg = <0x40000 0x40000>;
compatible = "chrp,open-pic";
device_type = "open-pic";
protected-sources = <0xb1>;
msgr@1400 {
compatible = "fsl,p2020-msgr", "fsl,mpic-msgr";
reg = <0x1400 0x200>;
cell-index = <0>;
interrupts = <0xb0 0x2 0xb1 0x2
0xb2 0x2 0xb3 0x2>;
};
msgr@2400 {
compatible = "fsl,p2020-msgr", "fsl,mpic-msgr";
reg = <0x2400 0x200>;
cell-index = <1>;
interrupts = <0xb4 0x2 0xb5 0x2
0xb6 0x2 0xb7 0x2>;
};
};* References
[1] PowerPC Microprocessor Common Hardware Reference Platform (CHRP) Binding, Version 1.8, 1998. Published by the Open Firmware Working Group. (http://playground.sun.com/1275/bindings/chrp/chrp1_8a.ps)
Signature · 2 lines
Meador Inge | meador_inge AT mentor.com Mentor Embedded | http://www.mentor.com/embedded-software
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 22 lines · On Wed, 22 Dec 2010 23:58:09 -0600 Meador Inge…
NOTE: The 'interrupt-parent' is implicit since message register nodes
are always children of interrupt controller nodes.** Example:
mpic: pic@40000 { interrupt-controller; #address-cells = <0>; #interrupt-cells = <2>; reg = <0x40000 0x40000>; compatible = "chrp,open-pic"; device_type = "open-pic"; protected-sources = <0xb1>; msgr@1400 { compatible = "fsl,p2020-msgr", "fsl,mpic-msgr"; reg = <0x1400 0x200>; cell-index = <0>; interrupts = <0xb0 0x2 0xb1 0x2 0xb2 0x2 0xb3 0x2>; };
Quoted 8 lines
msgr@2400 {
compatible = "fsl,p2020-msgr", "fsl,mpic-msgr";
reg = <0x2400 0x200>;
cell-index = <1>;
interrupts = <0xb4 0x2 0xb5 0x2
0xb6 0x2 0xb7 0x2>;
};
};These nodes cannot go under the mpic node, because interrupt controllers need #address-cells = <0>.
It would be nice if the binding provided some way of partitioning up individual message interrupts within a block.
Interrupt generation could be exported as a "service", similar to (inbound) interrupts and gpios.
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:
msg1: mpic-msg@1400 {
compatible = "fsl,mpic-v3.0-msg";
reg = <0x1400 0x200>;
interrupts <176 2 178 2>;
// We have message registers 0 and 2 for sending,
// and 1 and 3 for receiving.
// If absent, we own all message registers in this block.
fsl,mpic-msg-send-mask = <0x5>;
fsl,mpic-msg-receive-mask = <0xa>;
doorbell-controller;
// split into #doorbell-send-cells and #doorbell-receive-cells?
#doorbell-cells = <1>;
};some-amp-protocol-thingy {
send-doorbells = <&msg1 0>; // generate messages on MSGR0 receive-doorbells = <&msg1 0>; // receive messages on MSGR1
};
some-other-amp-protocol-thingy {
send-doorbells = <&msg1 1>; // generate messages on MSGR2 receive-doorbells = <&msg1 1>; // receive messages on MSGR3
};
Doorbell capabilities such as passing a 32-bit message can be negotiated between the drivers for the doorbell controller and the doorbell client.
-Scott
A message that is not in the archive (sent off-list or not yet received): 20110103142200.738c0b17-N/[email protected]
Thanks for the feedback Scott.
Quoted 3 lines · Scott Wood
On Wed, 22 Dec 2010 23:58:09 -0600
These nodes cannot go under the mpic node, because interrupt controllers need #address-cells =<0>.
Good point. Do they actually need it or is that just the way it currently is? [1] mandates it, I didn't see anything in [2] and I can't access [3].
However, AFAIK '#address-cells' is taken directly from the parent node and is not inherited from ancestors higher in the tree. So another option would be to do something like:
mpic: pic@40000 {
...
message-registers@0 {
#address-cells = <1>;
#size-cells = <1>;
msgr@1400 {
compatible = "fsl,mpic-v3.0-msgr";
reg = <0x1400 0x200>;
interrupts = <0xb0 0x2 0xb1 0x2 0xb2 0x2 0xb3 0x2>;
};
msgr@2400 {
compatible = "fsl,mpic-v3.0-msgr";
reg = <0x2400 0x200>;
interrupts = <0xb4 0x2 0xb5 0x2 0xb6 0x2 0xb7 0x2>;
};
};
};I like the nesting as it models the physical relationship closer and creates a clean namespace.
Quoted 8 lines
It would be nice if the binding provided some way of partitioning up individual message interrupts within a block.
Interrupt generation could be exported as a "service", similar to (inbound) interrupts and gpios.
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:
I need to think about this proposal more, but our original intent was to just have a simple description of the message registers in the device tree and the policy for how those message registers are used is in software (not necessarily an exact API use case, but you get the point):
/* Core 0 */ mpic_msgr_reserve(0); mpic_msgr_reserve(1); /* Send message to Core 1 */ mpic_msgr_write(3, 13); /* Read a value */ u32 value; mpic_msgr_read(0, &value); /* Free the register */ mpic_msgr_release(0); ... /* Core 1 */ mpic_msgr_reserve(3); mpic_msgr_reserve(4); /* Send message to Core 0 */ mpic_msgr_write(0, 1);
Note that a "reservation" is still isolated to a particular core, e.g. 'mpic_msgr_reserve(0)' on core 0 will not cause 'mpic_msgr_reserve(0)' to fail on another core. Where as two invocations of 'mpic_msgr_reserve(0)' on the same core without an interleaved 'mpic_msgr_release(0)' would, of course, fail.
Quoted 29 lines
msg1: mpic-msg@1400 { compatible = "fsl,mpic-v3.0-msg"; reg =<0x1400 0x200>; interrupts<176 2 178 2>; // We have message registers 0 and 2 for sending, // and 1 and 3 for receiving. // If absent, we own all message registers in this block. fsl,mpic-msg-send-mask =<0x5>; fsl,mpic-msg-receive-mask =<0xa>; doorbell-controller; // split into #doorbell-send-cells and #doorbell-receive-cells? #doorbell-cells =<1>; };some-amp-protocol-thingy {
send-doorbells =<&msg1 0>; // generate messages on MSGR0 receive-doorbells =<&msg1 0>; // receive messages on MSGR1
};some-other-amp-protocol-thingy {
send-doorbells =<&msg1 1>; // generate messages on MSGR2 receive-doorbells =<&msg1 1>; // receive messages on MSGR3
};Doorbell capabilities such as passing a 32-bit message can be negotiated between the drivers for the doorbell controller and the doorbell client.
Signature · 6 lines
Meador Inge | meador_inge AT mentor.com Mentor Embedded | http://www.mentor.com/embedded-software [1] Power.org™ Standard for Embedded Power Architecture™ Platform Requirements (ePAPR) Version 1.0 [2] PowerPC Microprocessor Common Hardware Reference Platform (CHRP) Binding, Version 1.8, 1998. Published by the Open Firmware Working Group. [3] The Open Programmable Interrupt Controller (PIC) Register Interface Specification Revision 1.2
A message that is not in the archive (sent off-list or not yet received): [email protected]
Quoted 10 lines · On Tue, 4 Jan 2011 17:52:38 -0600 Meador Inge…
Thanks for the feedback Scott.
Quoted 3 lines · Scott Wood
On Wed, 22 Dec 2010 23:58:09 -0600
These nodes cannot go under the mpic node, because interrupt controllers need #address-cells =<0>.Good point. Do they actually need it or is that just the way it currently is? [1] mandates it, I didn't see anything in [2] and I can't access [3].
It's because of the way interrupt maps work -- a full interrupt specifier includes the node's reg address as well as the values in the interrupts property. This is useful for things like PCI controllers, but normal interrupt controllers won't have any use for it.
In theory, I suppose you could have a non-zero #address-cells in an interrupt controller, but then you'd have to pad the parent interrupt specifiers in any interrupt map entries that point at the MPIC node with that many don't-care cells.
Better to just avoid the issue.
Quoted 16 lines
However, AFAIK '#address-cells' is taken directly from the parent node and is not inherited from ancestors higher in the tree. So another option would be to do something like:
mpic: pic@40000 { ... message-registers@0 { #address-cells = <1>; #size-cells = <1>; msgr@1400 { compatible = "fsl,mpic-v3.0-msgr"; reg = <0x1400 0x200>; interrupts = <0xb0 0x2 0xb1 0x2 0xb2 0x2 0xb3 0x2>; };
Quoted 7 lines
msgr@2400 {
compatible = "fsl,mpic-v3.0-msgr";
reg = <0x2400 0x200>;
interrupts = <0xb4 0x2 0xb5 0x2 0xb6 0x2 0xb7 0x2>;
};
};
};Won't work, the reg addresses need to be translatable through ranges all the way up to the root.
Quoted 2 lines
I like the nesting as it models the physical relationship closer and creates a clean namespace.
Sure, if it weren't for the #address-cells issue I'd agree.
Quoted 6 lines
Quoted 6 lines
It would be nice if the binding provided some way of partitioning up individual message interrupts within a block.
Interrupt generation could be exported as a "service", similar to (inbound) interrupts and gpios.
Quoted 7 lines
Quoted 2 lines
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:
I need to think about this proposal more, but our original intent was to just have a simple description of the message registers in the device tree and the policy for how those message registers are used is in software (not necessarily an exact API use case, but you get the point):
That may be fine for your use case (just as some people may be happy to hardcode device knowledge into their kernel), but in the general case inter-partition protocols are effectively a non-probeable part of the "hardware" the partition runs on. It's good to have a standard way of labelling what goes where. The details of the protocol would still be in software, referenced by the compatible string on the protocol node.
Quoted 13 lines
/* Core 0 */
mpic_msgr_reserve(0);
mpic_msgr_reserve(1);
/* Send message to Core 1 */
mpic_msgr_write(3, 13);
/* Read a value */
u32 value;
mpic_msgr_read(0, &value);
/* Free the register */
mpic_msgr_release(0);Quoted 8 lines
...
/* Core 1 */
mpic_msgr_reserve(3);
mpic_msgr_reserve(4);
/* Send message to Core 0 */
mpic_msgr_write(0, 1);You're hardcoding into software that core 0 gets msg0 and msg1, and core 1 gets msg3 and msg4, etc. Not much different than hardcoding that core 0 gets enet0 and core 1 gets enet1 and enet2.
Quoted 5 lines
Note that a "reservation" is still isolated to a particular core, e.g. '
mpic_msgr_reserve(0)' on core 0 will not cause 'mpic_msgr_reserve(0)' to fail on another core. Where as two invocations of 'mpic_msgr_reserve(0)' on the same core without an interleaved 'mpic_msgr_release(0)' would, of course, fail.
So basically, you're assigning the resource to both partitions, and relying on dynamic cooperation. That's fine, in that case both partitions would see the resource in their device tree, hopefully along with something to indicate what the situation is. But dedicated ownership is common enough, and similar enough to the question of whether the hardware exists at all, that it's nice to be able to express it in the device tree. It also makes it easier to deal with situations where you later want to plug in different hardware (or possibly a virtualized interface) underneath the protocol.
I'm not sure how much practical benefit there is to dynamically allocating message registers across partitions, though -- you'd have to have some way of communicating to the other end the result of the allocation, so it knows which one to send a message on. And if you only have 2 cores, and unhypervised AMP, you'll be able to dedicate 4 message registers to each partition...
-Scott
Quoted 19 lines · Scott Wood
Quoted 10 lines · On Tue, 4 Jan 2011 17:52:38 -0600 Meador Inge<[email protected]> wrote:
Thanks for the feedback Scott.
Quoted 3 lines · Scott Wood
On Wed, 22 Dec 2010 23:58:09 -0600
These nodes cannot go under the mpic node, because interrupt controllers need #address-cells =<0>.Good point. Do they actually need it or is that just the way it currently is? [1] mandates it, I didn't see anything in [2] and I can't access [3].
It's because of the way interrupt maps work -- a full interrupt specifier includes the node's reg address as well as the values in the interrupts property. This is useful for things like PCI controllers, but normal interrupt controllers won't have any use for it.
Quoted 6 lines
In theory, I suppose you could have a non-zero #address-cells in an interrupt controller, but then you'd have to pad the parent interrupt specifiers in any interrupt map entries that point at the MPIC node with that many don't-care cells.
Better to just avoid the issue.
Agreed, it would be nasty to have padding for this.
Quoted 24 lines
Quoted 16 lines
However, AFAIK '#address-cells' is taken directly from the parent node and is not inherited from ancestors higher in the tree. So another option would be to do something like:
mpic: pic@40000 { ... message-registers@0 { #address-cells =<1>; #size-cells =<1>; msgr@1400 { compatible = "fsl,mpic-v3.0-msgr"; reg =<0x1400 0x200>; interrupts =<0xb0 0x2 0xb1 0x2 0xb2 0x2 0xb3 0x2>; };Quoted 7 lines
msgr@2400 { compatible = "fsl,mpic-v3.0-msgr"; reg =<0x2400 0x200>; interrupts =<0xb4 0x2 0xb5 0x2 0xb6 0x2 0xb7 0x2>; }; }; };
Quoted 2 lines
Won't work, the reg addresses need to be translatable through ranges all the way up to the root.
Ah, I see. This is because we would have to add 'ranges' on 'message-registers' and 'pic', but 'pic' needs to have '#address-cells' > 0 to interpret 'ranges'. Fun :) I will hoist the message registers nodes out of the MPIC node.
Quoted 58 lines
Quoted 2 lines
I like the nesting as it models the physical relationship closer and creates a clean namespace.
Sure, if it weren't for the #address-cells issue I'd agree.
Quoted 6 lines
Quoted 6 lines
It would be nice if the binding provided some way of partitioning up individual message interrupts within a block.
Interrupt generation could be exported as a "service", similar to (inbound) interrupts and gpios.
Quoted 7 lines
Quoted 2 lines
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:
I need to think about this proposal more, but our original intent was to just have a simple description of the message registers in the device tree and the policy for how those message registers are used is in software (not necessarily an exact API use case, but you get the point):
That may be fine for your use case (just as some people may be happy to hardcode device knowledge into their kernel), but in the general case inter-partition protocols are effectively a non-probeable part of the "hardware" the partition runs on. It's good to have a standard way of labelling what goes where. The details of the protocol would still be in software, referenced by the compatible string on the protocol node.
Quoted 13 lines
/* Core 0 */ mpic_msgr_reserve(0); mpic_msgr_reserve(1); /* Send message to Core 1 */ mpic_msgr_write(3, 13); /* Read a value */ u32 value; mpic_msgr_read(0,&value); /* Free the register */ mpic_msgr_release(0);Quoted 8 lines
... /* Core 1 */ mpic_msgr_reserve(3); mpic_msgr_reserve(4); /* Send message to Core 0 */ mpic_msgr_write(0, 1);You're hardcoding into software that core 0 gets msg0 and msg1, and core 1 gets msg3 and msg4, etc. Not much different than hardcoding that core 0 gets enet0 and core 1 gets enet1 and enet2.
Quoted 5 lines
Note that a "reservation" is still isolated to a particular core, e.g. '
mpic_msgr_reserve(0)' on core 0 will not cause 'mpic_msgr_reserve(0)' to fail on another core. Where as two invocations of 'mpic_msgr_reserve(0)' on the same core without an interleaved 'mpic_msgr_release(0)' would, of course, fail.
Quoted 9 lines
So basically, you're assigning the resource to both partitions, and relying on dynamic cooperation. That's fine, in that case both partitions would see the resource in their device tree, hopefully along with something to indicate what the situation is. But dedicated ownership is common enough, and similar enough to the question of whether the hardware exists at all, that it's nice to be able to express it in the device tree. It also makes it easier to deal with situations where you later want to plug in different hardware (or possibly a virtualized interface) underneath the protocol.
I agree that it would be nice to have some elements of the protocol represented in the device tree. I would just like to do this in small steps. We are going to need the data in the device tree for the message registers no matter what. We are also going to need a simple API for interfacing with the registers. The bottom layer so to speak. These building blocks can be utilized later by a higher-level protocol if need be. For now I would just like to propose the MPIC bindings, the initial message register bindings, and the message registers API. Sound good?
Quoted 6 lines
I'm not sure how much practical benefit there is to dynamically allocating message registers across partitions, though -- you'd have to have some way of communicating to the other end the result of the allocation, so it knows which one to send a message on. And if you only have 2 cores, and unhypervised AMP, you'll be able to dedicate 4 message registers to each partition...
Hollis and I discussed that a bit already. The problem with our use case (and presumably others) is that we are using the message registers to aid in communicating over shared memory. If we go into dynamic allocation of message registers across partitions, then we need to coordinate between the partitions across shared memory. So you need shared memory communication to setup shared memory communication. Also, if we just get the basic pieces in place with the message register API ('reserve', 'release', 'read', 'write', etc...) we can perhaps figure out a way to build a dynamically allocator on top of those services later, if need be.
--
Meador Inge | meador_inge AT mentor.com
Mentor Embedded | http://www.mentor.com/embedded-software
Quoted 26 lines · Scott Wood
On Wed, 22 Dec 2010 23:58:09 -0600
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:msg1: mpic-msg@1400 { compatible = "fsl,mpic-v3.0-msg"; reg =<0x1400 0x200>; interrupts<176 2 178 2>; // We have message registers 0 and 2 for sending, // and 1 and 3 for receiving. // If absent, we own all message registers in this block. fsl,mpic-msg-send-mask =<0x5>; fsl,mpic-msg-receive-mask =<0xa>; doorbell-controller; // split into #doorbell-send-cells and #doorbell-receive-cells? #doorbell-cells =<1>; };some-amp-protocol-thingy {
send-doorbells =<&msg1 0>; // generate messages on MSGR0 receive-doorbells =<&msg1 0>; // receive messages on MSGR1
};
Quoted 7 lines
some-other-amp-protocol-thingy {
send-doorbells =<&msg1 1>; // generate messages on MSGR2 receive-doorbells =<&msg1 1>; // receive messages on MSGR3
};Doorbell capabilities such as passing a 32-bit message can be negotiated between the drivers for the doorbell controller and the doorbell client.
After thinking about it a little more, I like the idea of having a 'receive-mask' to further partition the message register blocks. This would also allow us to remove IRQs from the 'interrupts' property that are not being used on a given node. As for the 'send-mask', why would we want to block sending messages? It seems to me that it would be reasonable to allow a node to send a message to any other node.
As an example, consider a four core system. Then we might have something like (only relevant DTS bits shown):
Core 0:
mpic-msgr-block@1400 {
// Receives messages on registers 1 and 3.
interrupts = <0xb1 2 0xb3 2>;
receive-mask = <0xa>;
};
Core 1:
mpic-msgr-block@1400 {
// Receives messages on register 2.
interrupts = <0xb2 2>;
receive-mask = <0x4>;
};
Core 2:
mpic-msgr-block@1400 {
// Receives messages on register 0.
interrupts = <0xb0 2>;
receive-mask = <0x1>;
};
Core 3:
mpic-msgr-block@1400 {
// Receives no messages.
interrupts = <>;};
Then the API usage, for say core 0, might look something like:
/* Core 0 */ mpic_msgr *reg0 = mpic_get(0); mpic_msgr *reg1 = mpic_get(1); assert(mpic_msgr_get(100) == NULL); u32 value;
/* Send a message on register 0. */
assert(mpic_msgr_write(reg0, 12) == 0);
/* Send a message on register 1. */
assert(mpic_msgr_write(reg1, 12) == 0);
/* Attempt to read a message on register 0, but can't
since it is not owned. */
assert(mpic_msgr_read(reg0, &value) == -ENODEV);
/* Successfully read a message on register 1. */ assert(mpic_msgr_read(reg1, &value) == 0);
The API usage for other cores would look similar. As mentioned in another thread, this will provide us with the low-level building blocks and we can layer other protocols, such as the doorbell protocol, on top later (if needed).
Hollis, how do you feel about this?
Signature · 2 lines
Meador Inge | meador_inge AT mentor.com Mentor Embedded | http://www.mentor.com/embedded-software
Quoted 10 lines · On Wed, 5 Jan 2011 20:58:36 -0600 Meador Inge <[email protected]> wrote:
Quoted 9 lines · Scott Wood
On Wed, 22 Dec 2010 23:58:09 -0600
Perhaps a something like this, with "doorbell" being a new standard hw-independent service with its own binding:msg1: mpic-msg@1400 { compatible = "fsl,mpic-v3.0-msg"; reg =<0x1400 0x200>; interrupts<176 2 178 2>;
Quoted 5 lines
Quoted 5 lines
// We have message registers 0 and 2 for sending, // and 1 and 3 for receiving. // If absent, we own all message registers in this block. fsl,mpic-msg-send-mask =<0x5>; fsl,mpic-msg-receive-mask =<0xa>;
Alternatively, we could describe available ranges similarly to the existing MSI binding.
Quoted 6 lines
After thinking about it a little more, I like the idea of having a 'receive-mask' to further partition the message register blocks. This would also allow us to remove IRQs from the 'interrupts' property that are not being used on a given node. As for the 'send-mask', why would we want to block sending messages? It seems to me that it would be reasonable to allow a node to send a message to any other node.
The send-mask, like the receive-mask, is optional. If for your application it makes sense to give all partitions send access to all doorbells, then you can do that.
You might want to provide a send-mask if you are not specifying to the partition how to use the message registers, just splitting them up for their own internal use (especially if you have a larger multicore system where each partition has multiple CPUs).
Or, you may want to add a layer of robustness against one partition interfering with a message register that is only supposed to be used by another partition, even if there are instructions elsewhere about which message register to use for what purpose.
Plus, it provides symmetry between send and receive -- otherwise, you'd have a numberspace that is limited to your own resources on receive, but a global numberspace on send.
Quoted 18 lines
As an example, consider a four core system. Then we might have something like (only relevant DTS bits shown):
Core 0:
mpic-msgr-block@1400 { // Receives messages on registers 1 and 3. interrupts = <0xb1 2 0xb3 2>; receive-mask = <0xa>; }; Core 1: mpic-msgr-block@1400 { // Receives messages on register 2. interrupts = <0xb2 2>; receive-mask = <0x4>; }; Core 2: mpic-msgr-block@1400 { // Receives messages on register 0.
Quoted 8 lines
interrupts = <0xb0 2>;
receive-mask = <0x1>;
};
Core 3:
mpic-msgr-block@1400 {
// Receives no messages.
interrupts = <>;
};For core 3 I'd just leave out the node entirely. Note that the absence of a receive-mask indicates that all the registers are available (i.e. normal unpartitioned case), not none.
-Scott