Merge branch 'master' of github.com:openrisc/mor1kx into multicore

Conflicts:
	rtl/verilog/mor1kx_lsu_cappuccino.v
cappuccino/lsu: delay store_buffer_atomic one clock cycle

This way it is in sync with the rest of the signals that are
used from the store buffer.
cappuccino/ctrl: do not copy FO from esr on rfe

The FO (fixed one) bit should always be set to one,
allowing it to be altered through esr is not allowed.
Merge branch 'master' of github.com:openrisc/mor1kx into multicore
dcache: define snoop_hit in corner cases

When snooping is not enabled, define the snoop hit to be low. When the
cache is not enabled it should also be static low.
cappuccino/lsu: break atomic link when snoop occurs at the same time as load

This fixes a corner case where the snoop occurs at the exact
time as the load.
cappuccino/lsu: only mask snooped own bus accesses

The assumption that all bus accesses are to snooped devices
(i.e. memory) is not necessary true.
This masks out only the snooped bus accesses that are our own.

In the long run, this masking shouldn't really be in mor1kx,
rather in the snoop unit (outside of mor1kx), and snoop_en_i
should only be asserted when the snoop is valid for this core.
dcache: minor whitespace fixes
dcache: change OPTION_DCACHE_SNOOP checks from "ENABLED" to "NONE"

Common practice in mor1kx is to compare OPTION_* parameters
against "NONE", this changes this particular parameter to that
practice too.
dcache: remove check for dc_enable_i to to snoop_hit

The cache might be just temporarily disabled, so in order
to keep it coherent when it is re-enabled,
snooped accesses need to still be checked during this condition.
cappuccino/lsu: abort cache refill on snoop hit

Even though the assumption that the bus accesses from the refill
and the snoop are excelusive, there is a possibility that a
refill have been initiated at the same time as the snoop bus
access is going on.
This doesn't cause problems as long as the refill happens
to to the way that is being snooped, but if the snoop occurs to
an opposite way, the refill logic has saved the the old
tag data for that way and will write it back once the refill
has finished.

This avoids the issue by aborting refills when there's
a snoop hit, and prevents refills to be started at the
same instant as the snoop access and the snoop hit is handled.

This can be improved upon in several ways, either by only
aborting/preventing the accesses that are related to the
refill or as an even cleaner solution by splitting the tags
into seperate memories, so the tag saving mechanism can be
removed.

The overhead of aborting all refills on snoop-hits is however
rather small, since the refill would anyway be stalling waiting
for the snooped access to finish, so for now it will suffice as
a solution.