2004-06-15 23:38:40 +02:00
|
|
|
/*
|
|
|
|
* OpenPIC emulation
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-06-15 23:38:40 +02:00
|
|
|
* Copyright (c) 2004 Jocelyn Mayer
|
2011-07-21 01:33:29 +02:00
|
|
|
* 2011 Alexander Graf
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-06-15 23:38:40 +02:00
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
*
|
|
|
|
* Based on OpenPic implementations:
|
2009-02-06 22:30:02 +01:00
|
|
|
* - Intel GW80314 I/O companion chip developer's manual
|
2004-06-15 23:38:40 +02:00
|
|
|
* - Motorola MPC8245 & MPC8540 user manuals.
|
|
|
|
* - Motorola MCP750 (aka Raven) programmer manual.
|
|
|
|
* - Motorola Harrier programmer manuel
|
|
|
|
*
|
|
|
|
* Serial interrupts, as implemented in Raven chipset are not supported yet.
|
2007-09-16 23:08:06 +02:00
|
|
|
*
|
2004-06-15 23:38:40 +02:00
|
|
|
*/
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/hw.h"
|
|
|
|
#include "hw/ppc/mac.h"
|
|
|
|
#include "hw/pci/pci.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/ppc/openpic.h"
|
2013-06-16 17:04:21 +02:00
|
|
|
#include "hw/ppc/ppc_e500.h"
|
2013-02-04 15:40:22 +01:00
|
|
|
#include "hw/sysbus.h"
|
|
|
|
#include "hw/pci/msi.h"
|
2012-12-21 17:15:48 +01:00
|
|
|
#include "qemu/bitops.h"
|
2014-04-28 15:08:17 +02:00
|
|
|
#include "qapi/qmp/qerror.h"
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2004-06-21 18:50:43 +02:00
|
|
|
//#define DEBUG_OPENPIC
|
2004-06-15 23:38:40 +02:00
|
|
|
|
|
|
|
#ifdef DEBUG_OPENPIC
|
2012-12-21 17:15:38 +01:00
|
|
|
static const int debug_openpic = 1;
|
2004-06-15 23:38:40 +02:00
|
|
|
#else
|
2012-12-21 17:15:38 +01:00
|
|
|
static const int debug_openpic = 0;
|
2004-06-15 23:38:40 +02:00
|
|
|
#endif
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
#define DPRINTF(fmt, ...) do { \
|
|
|
|
if (debug_openpic) { \
|
|
|
|
printf(fmt , ## __VA_ARGS__); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
#define MAX_CPU 32
|
2012-12-08 14:18:00 +01:00
|
|
|
#define MAX_MSI 8
|
2004-06-15 23:38:40 +02:00
|
|
|
#define VID 0x03 /* MPIC version ID */
|
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
/* OpenPIC capability flags */
|
2012-12-21 17:15:42 +01:00
|
|
|
#define OPENPIC_FLAG_IDR_CRIT (1 << 0)
|
2013-01-21 16:53:53 +01:00
|
|
|
#define OPENPIC_FLAG_ILR (2 << 0)
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
/* OpenPIC address map */
|
2012-12-07 17:15:15 +01:00
|
|
|
#define OPENPIC_GLB_REG_START 0x0
|
|
|
|
#define OPENPIC_GLB_REG_SIZE 0x10F0
|
|
|
|
#define OPENPIC_TMR_REG_START 0x10F0
|
|
|
|
#define OPENPIC_TMR_REG_SIZE 0x220
|
2012-12-08 14:18:00 +01:00
|
|
|
#define OPENPIC_MSI_REG_START 0x1600
|
|
|
|
#define OPENPIC_MSI_REG_SIZE 0x200
|
2013-01-21 16:53:53 +01:00
|
|
|
#define OPENPIC_SUMMARY_REG_START 0x3800
|
|
|
|
#define OPENPIC_SUMMARY_REG_SIZE 0x800
|
2012-12-07 17:15:15 +01:00
|
|
|
#define OPENPIC_SRC_REG_START 0x10000
|
2013-04-15 15:19:32 +02:00
|
|
|
#define OPENPIC_SRC_REG_SIZE (OPENPIC_MAX_SRC * 0x20)
|
2012-12-07 17:15:15 +01:00
|
|
|
#define OPENPIC_CPU_REG_START 0x20000
|
|
|
|
#define OPENPIC_CPU_REG_SIZE 0x100 + ((MAX_CPU - 1) * 0x1000)
|
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
/* Raven */
|
|
|
|
#define RAVEN_MAX_CPU 2
|
|
|
|
#define RAVEN_MAX_EXT 48
|
|
|
|
#define RAVEN_MAX_IRQ 64
|
2013-04-15 15:19:32 +02:00
|
|
|
#define RAVEN_MAX_TMR OPENPIC_MAX_TMR
|
|
|
|
#define RAVEN_MAX_IPI OPENPIC_MAX_IPI
|
2012-12-08 05:17:14 +01:00
|
|
|
|
|
|
|
/* Interrupt definitions */
|
|
|
|
#define RAVEN_FE_IRQ (RAVEN_MAX_EXT) /* Internal functional IRQ */
|
|
|
|
#define RAVEN_ERR_IRQ (RAVEN_MAX_EXT + 1) /* Error IRQ */
|
|
|
|
#define RAVEN_TMR_IRQ (RAVEN_MAX_EXT + 2) /* First timer IRQ */
|
|
|
|
#define RAVEN_IPI_IRQ (RAVEN_TMR_IRQ + RAVEN_MAX_TMR) /* First IPI IRQ */
|
|
|
|
/* First doorbell IRQ */
|
|
|
|
#define RAVEN_DBL_IRQ (RAVEN_IPI_IRQ + (RAVEN_MAX_CPU * RAVEN_MAX_IPI))
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
typedef struct FslMpicInfo {
|
|
|
|
int max_ext;
|
|
|
|
} FslMpicInfo;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static FslMpicInfo fsl_mpic_20 = {
|
|
|
|
.max_ext = 12,
|
|
|
|
};
|
2009-03-02 17:42:04 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static FslMpicInfo fsl_mpic_42 = {
|
|
|
|
.max_ext = 12,
|
|
|
|
};
|
2012-08-14 06:30:55 +02:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
#define FRR_NIRQ_SHIFT 16
|
|
|
|
#define FRR_NCPU_SHIFT 8
|
|
|
|
#define FRR_VID_SHIFT 0
|
2012-12-08 00:58:54 +01:00
|
|
|
|
|
|
|
#define VID_REVISION_1_2 2
|
2012-12-08 05:17:14 +01:00
|
|
|
#define VID_REVISION_1_3 3
|
2012-12-08 00:58:54 +01:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
#define VIR_GENERIC 0x00000000 /* Generic Vendor ID */
|
2012-12-08 00:58:54 +01:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
#define GCR_RESET 0x80000000
|
2013-01-04 11:21:04 +01:00
|
|
|
#define GCR_MODE_PASS 0x00000000
|
|
|
|
#define GCR_MODE_MIXED 0x20000000
|
|
|
|
#define GCR_MODE_PROXY 0x60000000
|
2012-12-13 17:11:59 +01:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
#define TBCR_CI 0x80000000 /* count inhibit */
|
|
|
|
#define TCCR_TOG 0x80000000 /* toggles when decrement to zero */
|
2012-12-08 00:58:54 +01:00
|
|
|
|
2012-12-08 01:49:52 +01:00
|
|
|
#define IDR_EP_SHIFT 31
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IDR_EP_MASK (1U << IDR_EP_SHIFT)
|
2012-12-08 01:49:52 +01:00
|
|
|
#define IDR_CI0_SHIFT 30
|
|
|
|
#define IDR_CI1_SHIFT 29
|
|
|
|
#define IDR_P1_SHIFT 1
|
|
|
|
#define IDR_P0_SHIFT 0
|
2009-03-02 17:42:04 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
#define ILR_INTTGT_MASK 0x000000ff
|
|
|
|
#define ILR_INTTGT_INT 0x00
|
|
|
|
#define ILR_INTTGT_CINT 0x01 /* critical */
|
|
|
|
#define ILR_INTTGT_MCP 0x02 /* machine check */
|
|
|
|
|
|
|
|
/* The currently supported INTTGT values happen to be the same as QEMU's
|
|
|
|
* openpic output codes, but don't depend on this. The output codes
|
|
|
|
* could change (unlikely, but...) or support could be added for
|
|
|
|
* more INTTGT values.
|
|
|
|
*/
|
|
|
|
static const int inttgt_output[][2] = {
|
|
|
|
{ ILR_INTTGT_INT, OPENPIC_OUTPUT_INT },
|
|
|
|
{ ILR_INTTGT_CINT, OPENPIC_OUTPUT_CINT },
|
|
|
|
{ ILR_INTTGT_MCP, OPENPIC_OUTPUT_MCK },
|
|
|
|
};
|
|
|
|
|
|
|
|
static int inttgt_to_output(int inttgt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(inttgt_output); i++) {
|
|
|
|
if (inttgt_output[i][0] == inttgt) {
|
|
|
|
return inttgt_output[i][1];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "%s: unsupported inttgt %d\n", __func__, inttgt);
|
|
|
|
return OPENPIC_OUTPUT_INT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int output_to_inttgt(int output)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(inttgt_output); i++) {
|
|
|
|
if (inttgt_output[i][1] == output) {
|
|
|
|
return inttgt_output[i][0];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
2012-12-08 14:18:00 +01:00
|
|
|
#define MSIIR_OFFSET 0x140
|
|
|
|
#define MSIIR_SRS_SHIFT 29
|
|
|
|
#define MSIIR_SRS_MASK (0x7 << MSIIR_SRS_SHIFT)
|
|
|
|
#define MSIIR_IBS_SHIFT 24
|
|
|
|
#define MSIIR_IBS_MASK (0x1f << MSIIR_IBS_SHIFT)
|
|
|
|
|
2011-07-21 01:33:29 +02:00
|
|
|
static int get_current_cpu(void)
|
|
|
|
{
|
2013-05-27 05:17:50 +02:00
|
|
|
if (!current_cpu) {
|
2012-12-13 17:12:02 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-05-27 05:17:50 +02:00
|
|
|
return current_cpu->cpu_index;
|
2011-07-21 01:33:29 +02:00
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint32_t openpic_cpu_read_internal(void *opaque, hwaddr addr,
|
2011-07-21 01:33:29 +02:00
|
|
|
int idx);
|
2012-10-23 12:30:10 +02:00
|
|
|
static void openpic_cpu_write_internal(void *opaque, hwaddr addr,
|
2011-07-21 01:33:29 +02:00
|
|
|
uint32_t val, int idx);
|
2014-05-22 06:46:52 +02:00
|
|
|
static void openpic_reset(DeviceState *d);
|
2011-07-21 01:33:29 +02:00
|
|
|
|
2013-01-03 14:25:37 +01:00
|
|
|
typedef enum IRQType {
|
|
|
|
IRQ_TYPE_NORMAL = 0,
|
|
|
|
IRQ_TYPE_FSLINT, /* FSL internal interrupt -- level only */
|
|
|
|
IRQ_TYPE_FSLSPECIAL, /* FSL timer/IPI interrupt, edge, no polarity */
|
|
|
|
} IRQType;
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
typedef struct IRQQueue {
|
2012-12-21 17:15:48 +01:00
|
|
|
/* Round up to the nearest 64 IRQs so that the queue length
|
|
|
|
* won't change when moving between 32 and 64 bit hosts.
|
|
|
|
*/
|
2013-04-15 15:19:32 +02:00
|
|
|
unsigned long queue[BITS_TO_LONGS((OPENPIC_MAX_IRQ + 63) & ~63)];
|
2004-06-15 23:38:40 +02:00
|
|
|
int next;
|
|
|
|
int priority;
|
2012-12-20 17:30:58 +01:00
|
|
|
} IRQQueue;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
typedef struct IRQSource {
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t ivpr; /* IRQ vector/priority register */
|
|
|
|
uint32_t idr; /* IRQ destination register */
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
uint32_t destmask; /* bitmap of CPU destinations */
|
2004-06-15 23:38:40 +02:00
|
|
|
int last_cpu;
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
int output; /* IRQ level, e.g. OPENPIC_OUTPUT_INT */
|
2004-06-21 18:50:43 +02:00
|
|
|
int pending; /* TRUE if IRQ is pending */
|
2013-01-03 14:25:37 +01:00
|
|
|
IRQType type;
|
|
|
|
bool level:1; /* level-triggered */
|
2012-12-21 17:15:45 +01:00
|
|
|
bool nomask:1; /* critical interrupts ignore mask on some FSL MPICs */
|
2012-12-20 17:30:58 +01:00
|
|
|
} IRQSource;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_MASK_SHIFT 31
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_MASK_MASK (1U << IVPR_MASK_SHIFT)
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_ACTIVITY_SHIFT 30
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_ACTIVITY_MASK (1U << IVPR_ACTIVITY_SHIFT)
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_MODE_SHIFT 29
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_MODE_MASK (1U << IVPR_MODE_SHIFT)
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_POLARITY_SHIFT 23
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_POLARITY_MASK (1U << IVPR_POLARITY_SHIFT)
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_SENSE_SHIFT 22
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_SENSE_MASK (1U << IVPR_SENSE_SHIFT)
|
2012-12-21 17:15:42 +01:00
|
|
|
|
2014-03-17 17:00:36 +01:00
|
|
|
#define IVPR_PRIORITY_MASK (0xFU << 16)
|
2012-12-21 17:15:42 +01:00
|
|
|
#define IVPR_PRIORITY(_ivprr_) ((int)(((_ivprr_) & IVPR_PRIORITY_MASK) >> 16))
|
|
|
|
#define IVPR_VECTOR(opp, _ivprr_) ((_ivprr_) & (opp)->vector_mask)
|
|
|
|
|
|
|
|
/* IDR[EP/CI] are only for FSL MPIC prior to v4.0 */
|
|
|
|
#define IDR_EP 0x80000000 /* external pin */
|
|
|
|
#define IDR_CI 0x40000000 /* critical interrupt */
|
2012-12-13 17:11:59 +01:00
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
typedef struct IRQDest {
|
2012-12-21 17:15:44 +01:00
|
|
|
int32_t ctpr; /* CPU current task priority */
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQQueue raised;
|
|
|
|
IRQQueue servicing;
|
2007-04-10 00:45:36 +02:00
|
|
|
qemu_irq *irqs;
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
/* Count of IRQ sources asserting on non-INT outputs */
|
|
|
|
uint32_t outputs_active[OPENPIC_OUTPUT_NB];
|
2012-12-20 17:30:58 +01:00
|
|
|
} IRQDest;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2013-06-18 03:58:07 +02:00
|
|
|
#define OPENPIC(obj) OBJECT_CHECK(OpenPICState, (obj), TYPE_OPENPIC)
|
|
|
|
|
2012-12-08 01:59:20 +01:00
|
|
|
typedef struct OpenPICState {
|
2013-06-18 03:58:07 +02:00
|
|
|
/*< private >*/
|
|
|
|
SysBusDevice parent_obj;
|
|
|
|
/*< public >*/
|
|
|
|
|
2011-08-08 15:09:17 +02:00
|
|
|
MemoryRegion mem;
|
2011-08-30 17:46:26 +02:00
|
|
|
|
2012-12-07 23:51:09 +01:00
|
|
|
/* Behavior control */
|
2013-01-21 16:53:53 +01:00
|
|
|
FslMpicInfo *fsl;
|
2012-12-08 05:17:14 +01:00
|
|
|
uint32_t model;
|
2012-12-07 23:51:09 +01:00
|
|
|
uint32_t flags;
|
2012-12-08 00:58:54 +01:00
|
|
|
uint32_t nb_irqs;
|
|
|
|
uint32_t vid;
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t vir; /* Vendor identification register */
|
2012-12-13 17:12:01 +01:00
|
|
|
uint32_t vector_mask;
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t tfrr_reset;
|
|
|
|
uint32_t ivpr_reset;
|
|
|
|
uint32_t idr_reset;
|
2012-12-08 13:51:50 +01:00
|
|
|
uint32_t brr1;
|
2013-01-04 11:21:04 +01:00
|
|
|
uint32_t mpic_mode_mask;
|
2012-12-07 23:51:09 +01:00
|
|
|
|
2011-08-30 17:46:26 +02:00
|
|
|
/* Sub-regions */
|
2013-01-21 16:53:53 +01:00
|
|
|
MemoryRegion sub_io_mem[6];
|
2011-08-30 17:46:26 +02:00
|
|
|
|
2004-06-15 23:38:40 +02:00
|
|
|
/* Global registers */
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t frr; /* Feature reporting register */
|
|
|
|
uint32_t gcr; /* Global configuration register */
|
|
|
|
uint32_t pir; /* Processor initialization register */
|
2004-06-15 23:38:40 +02:00
|
|
|
uint32_t spve; /* Spurious vector register */
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t tfrr; /* Timer frequency reporting register */
|
2004-06-15 23:38:40 +02:00
|
|
|
/* Source registers */
|
2013-04-15 15:19:32 +02:00
|
|
|
IRQSource src[OPENPIC_MAX_IRQ];
|
2004-06-15 23:38:40 +02:00
|
|
|
/* Local registers per output pin */
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQDest dst[MAX_CPU];
|
2012-12-08 05:17:14 +01:00
|
|
|
uint32_t nb_cpus;
|
2004-06-15 23:38:40 +02:00
|
|
|
/* Timer registers */
|
|
|
|
struct {
|
2012-12-21 17:15:42 +01:00
|
|
|
uint32_t tccr; /* Global timer current count register */
|
|
|
|
uint32_t tbcr; /* Global timer base count register */
|
2013-04-15 15:19:32 +02:00
|
|
|
} timers[OPENPIC_MAX_TMR];
|
2012-12-08 14:18:00 +01:00
|
|
|
/* Shared MSI registers */
|
|
|
|
struct {
|
|
|
|
uint32_t msir; /* Shared Message Signaled Interrupt Register */
|
|
|
|
} msi[MAX_MSI];
|
2012-12-08 05:17:14 +01:00
|
|
|
uint32_t max_irq;
|
|
|
|
uint32_t irq_ipi0;
|
|
|
|
uint32_t irq_tim0;
|
2012-12-08 14:18:00 +01:00
|
|
|
uint32_t irq_msi;
|
2012-12-08 01:59:20 +01:00
|
|
|
} OpenPICState;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static inline void IRQ_setbit(IRQQueue *q, int n_IRQ)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-21 17:15:48 +01:00
|
|
|
set_bit(n_IRQ, q->queue);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static inline void IRQ_resetbit(IRQQueue *q, int n_IRQ)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-21 17:15:48 +01:00
|
|
|
clear_bit(n_IRQ, q->queue);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static void IRQ_check(OpenPICState *opp, IRQQueue *q)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2013-01-03 14:25:38 +01:00
|
|
|
int irq = -1;
|
|
|
|
int next = -1;
|
|
|
|
int priority = -1;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
irq = find_next_bit(q->queue, opp->max_irq, irq + 1);
|
|
|
|
if (irq == opp->max_irq) {
|
|
|
|
break;
|
|
|
|
}
|
2012-12-13 12:48:14 +01:00
|
|
|
|
2013-01-03 14:25:38 +01:00
|
|
|
DPRINTF("IRQ_check: irq %d set ivpr_pr=%d pr=%d\n",
|
|
|
|
irq, IVPR_PRIORITY(opp->src[irq].ivpr), priority);
|
2012-12-13 12:48:14 +01:00
|
|
|
|
2013-01-03 14:25:38 +01:00
|
|
|
if (IVPR_PRIORITY(opp->src[irq].ivpr) > priority) {
|
|
|
|
next = irq;
|
|
|
|
priority = IVPR_PRIORITY(opp->src[irq].ivpr);
|
2009-12-19 15:59:29 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2012-12-13 12:48:14 +01:00
|
|
|
|
2004-06-15 23:38:40 +02:00
|
|
|
q->next = next;
|
|
|
|
q->priority = priority;
|
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static int IRQ_get_next(OpenPICState *opp, IRQQueue *q)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-21 17:15:46 +01:00
|
|
|
/* XXX: optimize */
|
|
|
|
IRQ_check(opp, q);
|
2004-06-15 23:38:40 +02:00
|
|
|
|
|
|
|
return q->next;
|
|
|
|
}
|
|
|
|
|
2013-01-03 14:25:40 +01:00
|
|
|
static void IRQ_local_pipe(OpenPICState *opp, int n_CPU, int n_IRQ,
|
|
|
|
bool active, bool was_active)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQDest *dst;
|
|
|
|
IRQSource *src;
|
2004-06-15 23:38:40 +02:00
|
|
|
int priority;
|
|
|
|
|
|
|
|
dst = &opp->dst[n_CPU];
|
|
|
|
src = &opp->src[n_IRQ];
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
|
2013-01-03 14:25:40 +01:00
|
|
|
DPRINTF("%s: IRQ %d active %d was %d\n",
|
|
|
|
__func__, n_IRQ, active, was_active);
|
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
if (src->output != OPENPIC_OUTPUT_INT) {
|
2013-01-03 14:25:40 +01:00
|
|
|
DPRINTF("%s: output %d irq %d active %d was %d count %d\n",
|
|
|
|
__func__, src->output, n_IRQ, active, was_active,
|
|
|
|
dst->outputs_active[src->output]);
|
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
/* On Freescale MPIC, critical interrupts ignore priority,
|
|
|
|
* IACK, EOI, etc. Before MPIC v4.1 they also ignore
|
|
|
|
* masking.
|
|
|
|
*/
|
2013-01-03 14:25:40 +01:00
|
|
|
if (active) {
|
|
|
|
if (!was_active && dst->outputs_active[src->output]++ == 0) {
|
|
|
|
DPRINTF("%s: Raise OpenPIC output %d cpu %d irq %d\n",
|
|
|
|
__func__, src->output, n_CPU, n_IRQ);
|
|
|
|
qemu_irq_raise(dst->irqs[src->output]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (was_active && --dst->outputs_active[src->output] == 0) {
|
|
|
|
DPRINTF("%s: Lower OpenPIC output %d cpu %d irq %d\n",
|
|
|
|
__func__, src->output, n_CPU, n_IRQ);
|
|
|
|
qemu_irq_lower(dst->irqs[src->output]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-19 15:59:29 +01:00
|
|
|
return;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
priority = IVPR_PRIORITY(src->ivpr);
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
/* Even if the interrupt doesn't have enough priority,
|
|
|
|
* it is still raised, in case ctpr is lowered later.
|
|
|
|
*/
|
|
|
|
if (active) {
|
|
|
|
IRQ_setbit(&dst->raised, n_IRQ);
|
|
|
|
} else {
|
|
|
|
IRQ_resetbit(&dst->raised, n_IRQ);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
2012-12-21 17:15:46 +01:00
|
|
|
IRQ_check(opp, &dst->raised);
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
if (active && priority <= dst->ctpr) {
|
|
|
|
DPRINTF("%s: IRQ %d priority %d too low for ctpr %d on CPU %d\n",
|
|
|
|
__func__, n_IRQ, priority, dst->ctpr, n_CPU);
|
|
|
|
active = 0;
|
2007-04-10 00:45:36 +02:00
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
if (active) {
|
|
|
|
if (IRQ_get_next(opp, &dst->servicing) >= 0 &&
|
|
|
|
priority <= dst->servicing.priority) {
|
|
|
|
DPRINTF("%s: IRQ %d is hidden by servicing IRQ %d on CPU %d\n",
|
|
|
|
__func__, n_IRQ, dst->servicing.next, n_CPU);
|
|
|
|
} else {
|
|
|
|
DPRINTF("%s: Raise OpenPIC INT output cpu %d irq %d/%d\n",
|
|
|
|
__func__, n_CPU, n_IRQ, dst->raised.next);
|
|
|
|
qemu_irq_raise(opp->dst[n_CPU].irqs[OPENPIC_OUTPUT_INT]);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
IRQ_get_next(opp, &dst->servicing);
|
|
|
|
if (dst->raised.priority > dst->ctpr &&
|
|
|
|
dst->raised.priority > dst->servicing.priority) {
|
|
|
|
DPRINTF("%s: IRQ %d inactive, IRQ %d prio %d above %d/%d, CPU %d\n",
|
|
|
|
__func__, n_IRQ, dst->raised.next, dst->raised.priority,
|
|
|
|
dst->ctpr, dst->servicing.priority, n_CPU);
|
|
|
|
/* IRQ line stays asserted */
|
|
|
|
} else {
|
|
|
|
DPRINTF("%s: IRQ %d inactive, current prio %d/%d, CPU %d\n",
|
|
|
|
__func__, n_IRQ, dst->ctpr, dst->servicing.priority, n_CPU);
|
|
|
|
qemu_irq_lower(opp->dst[n_CPU].irqs[OPENPIC_OUTPUT_INT]);
|
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-06-21 18:50:43 +02:00
|
|
|
/* update pic state because registers for n_IRQ have changed value */
|
2012-12-08 01:59:20 +01:00
|
|
|
static void openpic_update_irq(OpenPICState *opp, int n_IRQ)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQSource *src;
|
2013-01-03 14:25:40 +01:00
|
|
|
bool active, was_active;
|
2004-06-15 23:38:40 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
src = &opp->src[n_IRQ];
|
2013-01-03 14:25:40 +01:00
|
|
|
active = src->pending;
|
2004-06-21 18:50:43 +02:00
|
|
|
|
2012-12-21 17:15:45 +01:00
|
|
|
if ((src->ivpr & IVPR_MASK_MASK) && !src->nomask) {
|
2009-12-19 15:59:29 +01:00
|
|
|
/* Interrupt source is disabled */
|
2007-04-10 00:45:36 +02:00
|
|
|
DPRINTF("%s: IRQ %d is disabled\n", __func__, n_IRQ);
|
2013-01-03 14:25:40 +01:00
|
|
|
active = false;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
was_active = !!(src->ivpr & IVPR_ACTIVITY_MASK);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't have a similar check for already-active because
|
|
|
|
* ctpr may have changed and we need to withdraw the interrupt.
|
|
|
|
*/
|
|
|
|
if (!active && !was_active) {
|
|
|
|
DPRINTF("%s: IRQ %d is already inactive\n", __func__, n_IRQ);
|
2009-12-19 15:59:29 +01:00
|
|
|
return;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
if (active) {
|
|
|
|
src->ivpr |= IVPR_ACTIVITY_MASK;
|
|
|
|
} else {
|
|
|
|
src->ivpr &= ~IVPR_ACTIVITY_MASK;
|
2004-06-21 18:50:43 +02:00
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
2013-01-21 16:53:51 +01:00
|
|
|
if (src->destmask == 0) {
|
2009-12-19 15:59:29 +01:00
|
|
|
/* No target */
|
2007-04-10 00:45:36 +02:00
|
|
|
DPRINTF("%s: IRQ %d has no target\n", __func__, n_IRQ);
|
2009-12-19 15:59:29 +01:00
|
|
|
return;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2004-06-21 18:50:43 +02:00
|
|
|
|
2013-01-21 16:53:51 +01:00
|
|
|
if (src->destmask == (1 << src->last_cpu)) {
|
2007-04-10 00:45:36 +02:00
|
|
|
/* Only one CPU is allowed to receive this IRQ */
|
2013-01-03 14:25:40 +01:00
|
|
|
IRQ_local_pipe(opp, src->last_cpu, n_IRQ, active, was_active);
|
2012-12-21 17:15:42 +01:00
|
|
|
} else if (!(src->ivpr & IVPR_MODE_MASK)) {
|
2004-06-21 18:50:43 +02:00
|
|
|
/* Directed delivery mode */
|
|
|
|
for (i = 0; i < opp->nb_cpus; i++) {
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
if (src->destmask & (1 << i)) {
|
2013-01-03 14:25:40 +01:00
|
|
|
IRQ_local_pipe(opp, i, n_IRQ, active, was_active);
|
2012-12-08 01:49:52 +01:00
|
|
|
}
|
2004-06-21 18:50:43 +02:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
} else {
|
2004-06-21 18:50:43 +02:00
|
|
|
/* Distributed delivery mode */
|
2007-04-10 00:45:36 +02:00
|
|
|
for (i = src->last_cpu + 1; i != src->last_cpu; i++) {
|
2012-12-20 17:30:58 +01:00
|
|
|
if (i == opp->nb_cpus) {
|
2004-06-21 18:50:43 +02:00
|
|
|
i = 0;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
if (src->destmask & (1 << i)) {
|
2013-01-03 14:25:40 +01:00
|
|
|
IRQ_local_pipe(opp, i, n_IRQ, active, was_active);
|
2004-06-21 18:50:43 +02:00
|
|
|
src->last_cpu = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-07 20:14:41 +02:00
|
|
|
static void openpic_set_irq(void *opaque, int n_IRQ, int level)
|
2004-06-21 18:50:43 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQSource *src;
|
2004-06-21 18:50:43 +02:00
|
|
|
|
2013-04-15 15:19:32 +02:00
|
|
|
if (n_IRQ >= OPENPIC_MAX_IRQ) {
|
2012-12-21 17:15:50 +01:00
|
|
|
fprintf(stderr, "%s: IRQ %d out of range\n", __func__, n_IRQ);
|
|
|
|
abort();
|
|
|
|
}
|
2004-06-21 18:50:43 +02:00
|
|
|
|
|
|
|
src = &opp->src[n_IRQ];
|
2012-12-21 17:15:42 +01:00
|
|
|
DPRINTF("openpic: set irq %d = %d ivpr=0x%08x\n",
|
|
|
|
n_IRQ, level, src->ivpr);
|
2013-01-03 14:25:37 +01:00
|
|
|
if (src->level) {
|
2004-06-21 18:50:43 +02:00
|
|
|
/* level-sensitive irq */
|
|
|
|
src->pending = level;
|
2013-01-03 14:25:40 +01:00
|
|
|
openpic_update_irq(opp, n_IRQ);
|
2004-06-21 18:50:43 +02:00
|
|
|
} else {
|
|
|
|
/* edge-sensitive irq */
|
2012-12-20 17:30:58 +01:00
|
|
|
if (level) {
|
2004-06-21 18:50:43 +02:00
|
|
|
src->pending = 1;
|
2013-01-03 14:25:40 +01:00
|
|
|
openpic_update_irq(opp, n_IRQ);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (src->output != OPENPIC_OUTPUT_INT) {
|
|
|
|
/* Edge-triggered interrupts shouldn't be used
|
|
|
|
* with non-INT delivery, but just in case,
|
|
|
|
* try to make it do something sane rather than
|
|
|
|
* cause an interrupt storm. This is close to
|
|
|
|
* what you'd probably see happen in real hardware.
|
|
|
|
*/
|
|
|
|
src->pending = 0;
|
|
|
|
openpic_update_irq(opp, n_IRQ);
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
static inline uint32_t read_IRQreg_idr(OpenPICState *opp, int n_IRQ)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-21 17:15:42 +01:00
|
|
|
return opp->src[n_IRQ].idr;
|
2011-09-07 13:41:54 +02:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static inline uint32_t read_IRQreg_ilr(OpenPICState *opp, int n_IRQ)
|
|
|
|
{
|
|
|
|
if (opp->flags & OPENPIC_FLAG_ILR) {
|
|
|
|
return output_to_inttgt(opp->src[n_IRQ].output);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0xffffffff;
|
|
|
|
}
|
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
static inline uint32_t read_IRQreg_ivpr(OpenPICState *opp, int n_IRQ)
|
2011-09-07 13:41:54 +02:00
|
|
|
{
|
2012-12-21 17:15:42 +01:00
|
|
|
return opp->src[n_IRQ].ivpr;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
static inline void write_IRQreg_idr(OpenPICState *opp, int n_IRQ, uint32_t val)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
IRQSource *src = &opp->src[n_IRQ];
|
|
|
|
uint32_t normal_mask = (1UL << opp->nb_cpus) - 1;
|
|
|
|
uint32_t crit_mask = 0;
|
|
|
|
uint32_t mask = normal_mask;
|
|
|
|
int crit_shift = IDR_EP_SHIFT - opp->nb_cpus;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (opp->flags & OPENPIC_FLAG_IDR_CRIT) {
|
|
|
|
crit_mask = mask << crit_shift;
|
|
|
|
mask |= crit_mask | IDR_EP;
|
|
|
|
}
|
|
|
|
|
|
|
|
src->idr = val & mask;
|
|
|
|
DPRINTF("Set IDR %d to 0x%08x\n", n_IRQ, src->idr);
|
|
|
|
|
|
|
|
if (opp->flags & OPENPIC_FLAG_IDR_CRIT) {
|
|
|
|
if (src->idr & crit_mask) {
|
|
|
|
if (src->idr & normal_mask) {
|
|
|
|
DPRINTF("%s: IRQ configured for multiple output types, using "
|
|
|
|
"critical\n", __func__);
|
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
src->output = OPENPIC_OUTPUT_CINT;
|
2012-12-21 17:15:45 +01:00
|
|
|
src->nomask = true;
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
src->destmask = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < opp->nb_cpus; i++) {
|
|
|
|
int n_ci = IDR_CI0_SHIFT - i;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
if (src->idr & (1UL << n_ci)) {
|
|
|
|
src->destmask |= 1UL << i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
src->output = OPENPIC_OUTPUT_INT;
|
2012-12-21 17:15:45 +01:00
|
|
|
src->nomask = false;
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
src->destmask = src->idr & normal_mask;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
src->destmask = src->idr;
|
|
|
|
}
|
2011-09-07 13:47:22 +02:00
|
|
|
}
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static inline void write_IRQreg_ilr(OpenPICState *opp, int n_IRQ, uint32_t val)
|
|
|
|
{
|
|
|
|
if (opp->flags & OPENPIC_FLAG_ILR) {
|
|
|
|
IRQSource *src = &opp->src[n_IRQ];
|
|
|
|
|
|
|
|
src->output = inttgt_to_output(val & ILR_INTTGT_MASK);
|
|
|
|
DPRINTF("Set ILR %d to 0x%08x, output %d\n", n_IRQ, src->idr,
|
|
|
|
src->output);
|
|
|
|
|
|
|
|
/* TODO: on MPIC v4.0 only, set nomask for non-INT */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
static inline void write_IRQreg_ivpr(OpenPICState *opp, int n_IRQ, uint32_t val)
|
2011-09-07 13:47:22 +02:00
|
|
|
{
|
2013-01-03 14:25:37 +01:00
|
|
|
uint32_t mask;
|
|
|
|
|
|
|
|
/* NOTE when implementing newer FSL MPIC models: starting with v4.0,
|
|
|
|
* the polarity bit is read-only on internal interrupts.
|
|
|
|
*/
|
|
|
|
mask = IVPR_MASK_MASK | IVPR_PRIORITY_MASK | IVPR_SENSE_MASK |
|
|
|
|
IVPR_POLARITY_MASK | opp->vector_mask;
|
|
|
|
|
2011-09-07 13:47:22 +02:00
|
|
|
/* ACTIVITY bit is read-only */
|
2013-01-03 14:25:37 +01:00
|
|
|
opp->src[n_IRQ].ivpr =
|
|
|
|
(opp->src[n_IRQ].ivpr & IVPR_ACTIVITY_MASK) | (val & mask);
|
|
|
|
|
|
|
|
/* For FSL internal interrupts, The sense bit is reserved and zero,
|
|
|
|
* and the interrupt is always level-triggered. Timers and IPIs
|
|
|
|
* have no sense or polarity bits, and are edge-triggered.
|
|
|
|
*/
|
|
|
|
switch (opp->src[n_IRQ].type) {
|
|
|
|
case IRQ_TYPE_NORMAL:
|
|
|
|
opp->src[n_IRQ].level = !!(opp->src[n_IRQ].ivpr & IVPR_SENSE_MASK);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IRQ_TYPE_FSLINT:
|
|
|
|
opp->src[n_IRQ].ivpr &= ~IVPR_SENSE_MASK;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IRQ_TYPE_FSLSPECIAL:
|
|
|
|
opp->src[n_IRQ].ivpr &= ~(IVPR_POLARITY_MASK | IVPR_SENSE_MASK);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-09-07 13:47:22 +02:00
|
|
|
openpic_update_irq(opp, n_IRQ);
|
2012-12-21 17:15:42 +01:00
|
|
|
DPRINTF("Set IVPR %d to 0x%08x -> 0x%08x\n", n_IRQ, val,
|
|
|
|
opp->src[n_IRQ].ivpr);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
|
2013-01-07 20:13:52 +01:00
|
|
|
static void openpic_gcr_write(OpenPICState *opp, uint64_t val)
|
|
|
|
{
|
2013-01-17 11:32:21 +01:00
|
|
|
bool mpic_proxy = false;
|
2013-01-07 20:15:28 +01:00
|
|
|
|
2013-01-07 20:13:52 +01:00
|
|
|
if (val & GCR_RESET) {
|
2013-06-18 03:58:07 +02:00
|
|
|
openpic_reset(DEVICE(opp));
|
2013-01-07 20:15:28 +01:00
|
|
|
return;
|
|
|
|
}
|
2013-01-07 20:13:52 +01:00
|
|
|
|
2013-01-07 20:15:28 +01:00
|
|
|
opp->gcr &= ~opp->mpic_mode_mask;
|
|
|
|
opp->gcr |= val & opp->mpic_mode_mask;
|
2013-01-07 20:13:52 +01:00
|
|
|
|
2013-01-07 20:15:28 +01:00
|
|
|
/* Set external proxy mode */
|
|
|
|
if ((val & opp->mpic_mode_mask) == GCR_MODE_PROXY) {
|
2013-01-17 11:32:21 +01:00
|
|
|
mpic_proxy = true;
|
2013-01-07 20:13:52 +01:00
|
|
|
}
|
2013-01-17 11:32:21 +01:00
|
|
|
|
|
|
|
ppce500_set_mpic_proxy(mpic_proxy);
|
2013-01-07 20:13:52 +01:00
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static void openpic_gbl_write(void *opaque, hwaddr addr, uint64_t val,
|
|
|
|
unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQDest *dst;
|
2007-04-10 00:45:36 +02:00
|
|
|
int idx;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
|
|
|
|
__func__, addr, val);
|
2012-12-20 17:30:58 +01:00
|
|
|
if (addr & 0xF) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
switch (addr) {
|
2012-08-14 06:30:55 +02:00
|
|
|
case 0x00: /* Block Revision Register1 (BRR1) is Readonly */
|
|
|
|
break;
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x40:
|
|
|
|
case 0x50:
|
|
|
|
case 0x60:
|
|
|
|
case 0x70:
|
|
|
|
case 0x80:
|
|
|
|
case 0x90:
|
|
|
|
case 0xA0:
|
|
|
|
case 0xB0:
|
|
|
|
openpic_cpu_write_internal(opp, addr, val, get_current_cpu());
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1000: /* FRR */
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1020: /* GCR */
|
2013-01-07 20:13:52 +01:00
|
|
|
openpic_gcr_write(opp, val);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1080: /* VIR */
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1090: /* PIR */
|
2007-04-10 00:45:36 +02:00
|
|
|
for (idx = 0; idx < opp->nb_cpus; idx++) {
|
2012-12-21 17:15:42 +01:00
|
|
|
if ((val & (1 << idx)) && !(opp->pir & (1 << idx))) {
|
2007-04-10 00:45:36 +02:00
|
|
|
DPRINTF("Raise OpenPIC RESET output for CPU %d\n", idx);
|
|
|
|
dst = &opp->dst[idx];
|
|
|
|
qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_RESET]);
|
2012-12-21 17:15:42 +01:00
|
|
|
} else if (!(val & (1 << idx)) && (opp->pir & (1 << idx))) {
|
2007-04-10 00:45:36 +02:00
|
|
|
DPRINTF("Lower OpenPIC RESET output for CPU %d\n", idx);
|
|
|
|
dst = &opp->dst[idx];
|
|
|
|
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_RESET]);
|
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2012-12-21 17:15:42 +01:00
|
|
|
opp->pir = val;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x10A0: /* IPI_IVPR */
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x10B0:
|
|
|
|
case 0x10C0:
|
|
|
|
case 0x10D0:
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
|
|
|
int idx;
|
2011-07-21 01:33:29 +02:00
|
|
|
idx = (addr - 0x10A0) >> 4;
|
2012-12-21 17:15:42 +01:00
|
|
|
write_IRQreg_ivpr(opp, opp->irq_ipi0 + idx, val);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
break;
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x10E0: /* SPVE */
|
2012-12-13 17:12:01 +01:00
|
|
|
opp->spve = val & opp->vector_mask;
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static uint64_t openpic_gbl_read(void *opaque, hwaddr addr, unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2004-06-15 23:38:40 +02:00
|
|
|
uint32_t retval;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
|
2004-06-15 23:38:40 +02:00
|
|
|
retval = 0xFFFFFFFF;
|
2012-12-20 17:30:58 +01:00
|
|
|
if (addr & 0xF) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return retval;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
switch (addr) {
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1000: /* FRR */
|
|
|
|
retval = opp->frr;
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1020: /* GCR */
|
|
|
|
retval = opp->gcr;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1080: /* VIR */
|
|
|
|
retval = opp->vir;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x1090: /* PIR */
|
2004-06-15 23:38:40 +02:00
|
|
|
retval = 0x00000000;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-08-14 06:30:55 +02:00
|
|
|
case 0x00: /* Block Revision Register1 (BRR1) */
|
2012-12-13 17:12:03 +01:00
|
|
|
retval = opp->brr1;
|
|
|
|
break;
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x40:
|
|
|
|
case 0x50:
|
|
|
|
case 0x60:
|
|
|
|
case 0x70:
|
|
|
|
case 0x80:
|
|
|
|
case 0x90:
|
|
|
|
case 0xA0:
|
2004-06-15 23:38:40 +02:00
|
|
|
case 0xB0:
|
2011-07-21 01:33:29 +02:00
|
|
|
retval = openpic_cpu_read_internal(opp, addr, get_current_cpu());
|
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x10A0: /* IPI_IVPR */
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x10B0:
|
|
|
|
case 0x10C0:
|
|
|
|
case 0x10D0:
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
|
|
|
int idx;
|
2011-07-21 01:33:29 +02:00
|
|
|
idx = (addr - 0x10A0) >> 4;
|
2012-12-21 17:15:42 +01:00
|
|
|
retval = read_IRQreg_ivpr(opp, opp->irq_ipi0 + idx);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x10E0: /* SPVE */
|
2004-06-15 23:38:40 +02:00
|
|
|
retval = opp->spve;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: => 0x%08x\n", __func__, retval);
|
2004-06-15 23:38:40 +02:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-12-08 01:59:20 +01:00
|
|
|
static void openpic_tmr_write(void *opaque, hwaddr addr, uint64_t val,
|
2012-12-07 16:31:55 +01:00
|
|
|
unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2004-06-15 23:38:40 +02:00
|
|
|
int idx;
|
|
|
|
|
2013-01-21 16:53:52 +01:00
|
|
|
addr += 0x10f0;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
|
|
|
|
__func__, addr, val);
|
2012-12-20 17:30:58 +01:00
|
|
|
if (addr & 0xF) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2012-12-08 00:43:42 +01:00
|
|
|
|
2013-01-21 16:53:52 +01:00
|
|
|
if (addr == 0x10f0) {
|
2012-12-21 17:15:42 +01:00
|
|
|
/* TFRR */
|
|
|
|
opp->tfrr = val;
|
2012-12-08 00:43:42 +01:00
|
|
|
return;
|
|
|
|
}
|
2013-01-21 16:53:52 +01:00
|
|
|
|
|
|
|
idx = (addr >> 6) & 0x3;
|
|
|
|
addr = addr & 0x30;
|
|
|
|
|
2012-12-08 00:43:42 +01:00
|
|
|
switch (addr & 0x30) {
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x00: /* TCCR */
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x10: /* TBCR */
|
|
|
|
if ((opp->timers[idx].tccr & TCCR_TOG) != 0 &&
|
|
|
|
(val & TBCR_CI) == 0 &&
|
|
|
|
(opp->timers[idx].tbcr & TBCR_CI) != 0) {
|
|
|
|
opp->timers[idx].tccr &= ~TCCR_TOG;
|
2012-12-13 17:11:59 +01:00
|
|
|
}
|
2012-12-21 17:15:42 +01:00
|
|
|
opp->timers[idx].tbcr = val;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x20: /* TVPR */
|
|
|
|
write_IRQreg_ivpr(opp, opp->irq_tim0 + idx, val);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x30: /* TDR */
|
|
|
|
write_IRQreg_idr(opp, opp->irq_tim0 + idx, val);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-08 01:59:20 +01:00
|
|
|
static uint64_t openpic_tmr_read(void *opaque, hwaddr addr, unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2012-12-08 00:43:42 +01:00
|
|
|
uint32_t retval = -1;
|
2004-06-15 23:38:40 +02:00
|
|
|
int idx;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
|
2012-12-08 00:43:42 +01:00
|
|
|
if (addr & 0xF) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
idx = (addr >> 6) & 0x3;
|
|
|
|
if (addr == 0x0) {
|
2012-12-21 17:15:42 +01:00
|
|
|
/* TFRR */
|
|
|
|
retval = opp->tfrr;
|
2012-12-08 00:43:42 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
switch (addr & 0x30) {
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x00: /* TCCR */
|
|
|
|
retval = opp->timers[idx].tccr;
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x10: /* TBCR */
|
|
|
|
retval = opp->timers[idx].tbcr;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x20: /* TIPV */
|
|
|
|
retval = read_IRQreg_ivpr(opp, opp->irq_tim0 + idx);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-08 00:43:42 +01:00
|
|
|
case 0x30: /* TIDE (TIDR) */
|
2012-12-21 17:15:42 +01:00
|
|
|
retval = read_IRQreg_idr(opp, opp->irq_tim0 + idx);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2012-12-08 00:43:42 +01:00
|
|
|
|
|
|
|
out:
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: => 0x%08x\n", __func__, retval);
|
2004-06-15 23:38:40 +02:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static void openpic_src_write(void *opaque, hwaddr addr, uint64_t val,
|
|
|
|
unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2004-06-15 23:38:40 +02:00
|
|
|
int idx;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx " <= %08" PRIx64 "\n",
|
|
|
|
__func__, addr, val);
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
addr = addr & 0xffff;
|
2004-06-15 23:38:40 +02:00
|
|
|
idx = addr >> 5;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
switch (addr & 0x1f) {
|
|
|
|
case 0x00:
|
2012-12-21 17:15:42 +01:00
|
|
|
write_IRQreg_ivpr(opp, idx, val);
|
2013-01-21 16:53:53 +01:00
|
|
|
break;
|
|
|
|
case 0x10:
|
|
|
|
write_IRQreg_idr(opp, idx, val);
|
|
|
|
break;
|
|
|
|
case 0x18:
|
|
|
|
write_IRQreg_ilr(opp, idx, val);
|
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static uint64_t openpic_src_read(void *opaque, uint64_t addr, unsigned len)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2004-06-15 23:38:40 +02:00
|
|
|
uint32_t retval;
|
|
|
|
int idx;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
|
2004-06-15 23:38:40 +02:00
|
|
|
retval = 0xFFFFFFFF;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
addr = addr & 0xffff;
|
2004-06-15 23:38:40 +02:00
|
|
|
idx = addr >> 5;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
switch (addr & 0x1f) {
|
|
|
|
case 0x00:
|
2012-12-21 17:15:42 +01:00
|
|
|
retval = read_IRQreg_ivpr(opp, idx);
|
2013-01-21 16:53:53 +01:00
|
|
|
break;
|
|
|
|
case 0x10:
|
|
|
|
retval = read_IRQreg_idr(opp, idx);
|
|
|
|
break;
|
|
|
|
case 0x18:
|
|
|
|
retval = read_IRQreg_ilr(opp, idx);
|
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
DPRINTF("%s: => 0x%08x\n", __func__, retval);
|
2004-06-15 23:38:40 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-12-08 14:18:00 +01:00
|
|
|
static void openpic_msi_write(void *opaque, hwaddr addr, uint64_t val,
|
|
|
|
unsigned size)
|
|
|
|
{
|
|
|
|
OpenPICState *opp = opaque;
|
|
|
|
int idx = opp->irq_msi;
|
|
|
|
int srs, ibs;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx " <= 0x%08" PRIx64 "\n",
|
|
|
|
__func__, addr, val);
|
2012-12-08 14:18:00 +01:00
|
|
|
if (addr & 0xF) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (addr) {
|
|
|
|
case MSIIR_OFFSET:
|
|
|
|
srs = val >> MSIIR_SRS_SHIFT;
|
|
|
|
idx += srs;
|
|
|
|
ibs = (val & MSIIR_IBS_MASK) >> MSIIR_IBS_SHIFT;
|
|
|
|
opp->msi[srs].msir |= 1 << ibs;
|
|
|
|
openpic_set_irq(opp, idx, 1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* most registers are read-only, thus ignored */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t openpic_msi_read(void *opaque, hwaddr addr, unsigned size)
|
|
|
|
{
|
|
|
|
OpenPICState *opp = opaque;
|
|
|
|
uint64_t r = 0;
|
|
|
|
int i, srs;
|
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
|
2012-12-08 14:18:00 +01:00
|
|
|
if (addr & 0xF) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
srs = addr >> 4;
|
|
|
|
|
|
|
|
switch (addr) {
|
|
|
|
case 0x00:
|
|
|
|
case 0x10:
|
|
|
|
case 0x20:
|
|
|
|
case 0x30:
|
|
|
|
case 0x40:
|
|
|
|
case 0x50:
|
|
|
|
case 0x60:
|
|
|
|
case 0x70: /* MSIRs */
|
|
|
|
r = opp->msi[srs].msir;
|
|
|
|
/* Clear on read */
|
|
|
|
opp->msi[srs].msir = 0;
|
2012-12-21 17:15:39 +01:00
|
|
|
openpic_set_irq(opp, opp->irq_msi + srs, 0);
|
2012-12-08 14:18:00 +01:00
|
|
|
break;
|
|
|
|
case 0x120: /* MSISR */
|
|
|
|
for (i = 0; i < MAX_MSI; i++) {
|
|
|
|
r |= (opp->msi[i].msir ? 1 : 0) << i;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static uint64_t openpic_summary_read(void *opaque, hwaddr addr, unsigned size)
|
|
|
|
{
|
|
|
|
uint64_t r = 0;
|
|
|
|
|
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx "\n", __func__, addr);
|
|
|
|
|
|
|
|
/* TODO: EISR/EIMR */
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void openpic_summary_write(void *opaque, hwaddr addr, uint64_t val,
|
|
|
|
unsigned size)
|
|
|
|
{
|
|
|
|
DPRINTF("%s: addr %#" HWADDR_PRIx " <= 0x%08" PRIx64 "\n",
|
|
|
|
__func__, addr, val);
|
|
|
|
|
|
|
|
/* TODO: EISR/EIMR */
|
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static void openpic_cpu_write_internal(void *opaque, hwaddr addr,
|
2011-07-21 01:33:29 +02:00
|
|
|
uint32_t val, int idx)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQSource *src;
|
|
|
|
IRQDest *dst;
|
2011-07-21 01:33:29 +02:00
|
|
|
int s_IRQ, n_IRQ;
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: cpu %d addr %#" HWADDR_PRIx " <= 0x%08x\n", __func__, idx,
|
2011-07-21 01:33:29 +02:00
|
|
|
addr, val);
|
2012-12-13 17:12:02 +01:00
|
|
|
|
|
|
|
if (idx < 0) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return;
|
2012-12-13 17:12:02 +01:00
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
if (addr & 0xF) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
dst = &opp->dst[idx];
|
|
|
|
addr &= 0xFF0;
|
|
|
|
switch (addr) {
|
2011-07-21 01:33:29 +02:00
|
|
|
case 0x40: /* IPIDR */
|
2004-06-15 23:38:40 +02:00
|
|
|
case 0x50:
|
|
|
|
case 0x60:
|
|
|
|
case 0x70:
|
|
|
|
idx = (addr - 0x40) >> 4;
|
2011-07-21 01:36:44 +02:00
|
|
|
/* we use IDE as mask which CPUs to deliver the IPI to still. */
|
2013-01-21 16:53:51 +01:00
|
|
|
opp->src[opp->irq_ipi0 + idx].destmask |= val;
|
2009-03-02 17:42:04 +01:00
|
|
|
openpic_set_irq(opp, opp->irq_ipi0 + idx, 1);
|
|
|
|
openpic_set_irq(opp, opp->irq_ipi0 + idx, 0);
|
2004-06-15 23:38:40 +02:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x80: /* CTPR */
|
|
|
|
dst->ctpr = val & 0x0000000F;
|
2013-01-03 14:25:40 +01:00
|
|
|
|
|
|
|
DPRINTF("%s: set CPU %d ctpr to %d, raised %d servicing %d\n",
|
|
|
|
__func__, idx, dst->ctpr, dst->raised.priority,
|
|
|
|
dst->servicing.priority);
|
|
|
|
|
|
|
|
if (dst->raised.priority <= dst->ctpr) {
|
|
|
|
DPRINTF("%s: Lower OpenPIC INT output cpu %d due to ctpr\n",
|
|
|
|
__func__, idx);
|
|
|
|
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_INT]);
|
|
|
|
} else if (dst->raised.priority > dst->servicing.priority) {
|
|
|
|
DPRINTF("%s: Raise OpenPIC INT output cpu %d irq %d\n",
|
|
|
|
__func__, idx, dst->raised.next);
|
|
|
|
qemu_irq_raise(dst->irqs[OPENPIC_OUTPUT_INT]);
|
|
|
|
}
|
|
|
|
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
case 0x90: /* WHOAMI */
|
2009-12-19 15:59:29 +01:00
|
|
|
/* Read-only register */
|
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0xA0: /* IACK */
|
2009-12-19 15:59:29 +01:00
|
|
|
/* Read-only register */
|
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0xB0: /* EOI */
|
|
|
|
DPRINTF("EOI\n");
|
2009-12-19 15:59:29 +01:00
|
|
|
s_IRQ = IRQ_get_next(opp, &dst->servicing);
|
2012-12-21 17:15:50 +01:00
|
|
|
|
|
|
|
if (s_IRQ < 0) {
|
|
|
|
DPRINTF("%s: EOI with no interrupt in service\n", __func__);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-12-19 15:59:29 +01:00
|
|
|
IRQ_resetbit(&dst->servicing, s_IRQ);
|
|
|
|
/* Set up next servicing IRQ */
|
|
|
|
s_IRQ = IRQ_get_next(opp, &dst->servicing);
|
2007-04-10 00:45:36 +02:00
|
|
|
/* Check queued interrupts. */
|
|
|
|
n_IRQ = IRQ_get_next(opp, &dst->raised);
|
|
|
|
src = &opp->src[n_IRQ];
|
|
|
|
if (n_IRQ != -1 &&
|
|
|
|
(s_IRQ == -1 ||
|
2012-12-21 17:15:42 +01:00
|
|
|
IVPR_PRIORITY(src->ivpr) > dst->servicing.priority)) {
|
2007-04-10 00:45:36 +02:00
|
|
|
DPRINTF("Raise OpenPIC INT output cpu %d irq %d\n",
|
|
|
|
idx, n_IRQ);
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
qemu_irq_raise(opp->dst[idx].irqs[OPENPIC_OUTPUT_INT]);
|
2007-04-10 00:45:36 +02:00
|
|
|
}
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static void openpic_cpu_write(void *opaque, hwaddr addr, uint64_t val,
|
|
|
|
unsigned len)
|
2011-07-21 01:33:29 +02:00
|
|
|
{
|
|
|
|
openpic_cpu_write_internal(opaque, addr, val, (addr & 0x1f000) >> 12);
|
|
|
|
}
|
|
|
|
|
2013-01-03 14:25:39 +01:00
|
|
|
|
|
|
|
static uint32_t openpic_iack(OpenPICState *opp, IRQDest *dst, int cpu)
|
|
|
|
{
|
|
|
|
IRQSource *src;
|
|
|
|
int retval, irq;
|
|
|
|
|
|
|
|
DPRINTF("Lower OpenPIC INT output\n");
|
|
|
|
qemu_irq_lower(dst->irqs[OPENPIC_OUTPUT_INT]);
|
|
|
|
|
|
|
|
irq = IRQ_get_next(opp, &dst->raised);
|
|
|
|
DPRINTF("IACK: irq=%d\n", irq);
|
|
|
|
|
|
|
|
if (irq == -1) {
|
|
|
|
/* No more interrupt pending */
|
|
|
|
return opp->spve;
|
|
|
|
}
|
|
|
|
|
|
|
|
src = &opp->src[irq];
|
|
|
|
if (!(src->ivpr & IVPR_ACTIVITY_MASK) ||
|
|
|
|
!(IVPR_PRIORITY(src->ivpr) > dst->ctpr)) {
|
2013-01-03 14:25:40 +01:00
|
|
|
fprintf(stderr, "%s: bad raised IRQ %d ctpr %d ivpr 0x%08x\n",
|
|
|
|
__func__, irq, dst->ctpr, src->ivpr);
|
|
|
|
openpic_update_irq(opp, irq);
|
2013-01-03 14:25:39 +01:00
|
|
|
retval = opp->spve;
|
|
|
|
} else {
|
|
|
|
/* IRQ enter servicing state */
|
|
|
|
IRQ_setbit(&dst->servicing, irq);
|
|
|
|
retval = IVPR_VECTOR(opp, src->ivpr);
|
|
|
|
}
|
2013-01-03 14:25:40 +01:00
|
|
|
|
2013-01-03 14:25:39 +01:00
|
|
|
if (!src->level) {
|
|
|
|
/* edge-sensitive IRQ */
|
|
|
|
src->ivpr &= ~IVPR_ACTIVITY_MASK;
|
|
|
|
src->pending = 0;
|
2013-01-03 14:25:40 +01:00
|
|
|
IRQ_resetbit(&dst->raised, irq);
|
2013-01-03 14:25:39 +01:00
|
|
|
}
|
|
|
|
|
2013-04-15 15:19:32 +02:00
|
|
|
if ((irq >= opp->irq_ipi0) && (irq < (opp->irq_ipi0 + OPENPIC_MAX_IPI))) {
|
2013-01-21 16:53:51 +01:00
|
|
|
src->destmask &= ~(1 << cpu);
|
|
|
|
if (src->destmask && !src->level) {
|
2013-01-03 14:25:39 +01:00
|
|
|
/* trigger on CPUs that didn't know about it yet */
|
|
|
|
openpic_set_irq(opp, irq, 1);
|
|
|
|
openpic_set_irq(opp, irq, 0);
|
|
|
|
/* if all CPUs knew about it, set active bit again */
|
|
|
|
src->ivpr |= IVPR_ACTIVITY_MASK;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-10-23 12:30:10 +02:00
|
|
|
static uint32_t openpic_cpu_read_internal(void *opaque, hwaddr addr,
|
2011-07-21 01:33:29 +02:00
|
|
|
int idx)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = opaque;
|
2012-12-20 17:30:58 +01:00
|
|
|
IRQDest *dst;
|
2004-06-15 23:38:40 +02:00
|
|
|
uint32_t retval;
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: cpu %d addr %#" HWADDR_PRIx "\n", __func__, idx, addr);
|
2004-06-15 23:38:40 +02:00
|
|
|
retval = 0xFFFFFFFF;
|
2012-12-13 17:12:02 +01:00
|
|
|
|
|
|
|
if (idx < 0) {
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
if (addr & 0xF) {
|
2004-06-15 23:38:40 +02:00
|
|
|
return retval;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2004-06-15 23:38:40 +02:00
|
|
|
dst = &opp->dst[idx];
|
|
|
|
addr &= 0xFF0;
|
|
|
|
switch (addr) {
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0x80: /* CTPR */
|
|
|
|
retval = dst->ctpr;
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
case 0x90: /* WHOAMI */
|
2009-12-19 15:59:29 +01:00
|
|
|
retval = idx;
|
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0xA0: /* IACK */
|
2013-01-03 14:25:39 +01:00
|
|
|
retval = openpic_iack(opp, dst, idx);
|
2009-12-19 15:59:29 +01:00
|
|
|
break;
|
2012-12-21 17:15:42 +01:00
|
|
|
case 0xB0: /* EOI */
|
2009-12-19 15:59:29 +01:00
|
|
|
retval = 0;
|
|
|
|
break;
|
2004-06-15 23:38:40 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2012-12-21 17:15:38 +01:00
|
|
|
DPRINTF("%s: => 0x%08x\n", __func__, retval);
|
2004-06-15 23:38:40 +02:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2012-12-07 16:31:55 +01:00
|
|
|
static uint64_t openpic_cpu_read(void *opaque, hwaddr addr, unsigned len)
|
2011-07-21 01:33:29 +02:00
|
|
|
{
|
|
|
|
return openpic_cpu_read_internal(opaque, addr, (addr & 0x1f000) >> 12);
|
|
|
|
}
|
|
|
|
|
2012-12-08 01:04:48 +01:00
|
|
|
static const MemoryRegionOps openpic_glb_ops_le = {
|
2012-12-07 17:15:15 +01:00
|
|
|
.write = openpic_gbl_write,
|
|
|
|
.read = openpic_gbl_read,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-08 01:04:48 +01:00
|
|
|
static const MemoryRegionOps openpic_glb_ops_be = {
|
|
|
|
.write = openpic_gbl_write,
|
|
|
|
.read = openpic_gbl_read,
|
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const MemoryRegionOps openpic_tmr_ops_le = {
|
2012-12-08 01:59:20 +01:00
|
|
|
.write = openpic_tmr_write,
|
|
|
|
.read = openpic_tmr_read,
|
2012-12-07 17:15:15 +01:00
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-08 01:04:48 +01:00
|
|
|
static const MemoryRegionOps openpic_tmr_ops_be = {
|
2012-12-08 01:59:20 +01:00
|
|
|
.write = openpic_tmr_write,
|
|
|
|
.read = openpic_tmr_read,
|
2012-12-08 01:04:48 +01:00
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const MemoryRegionOps openpic_cpu_ops_le = {
|
2012-12-07 17:15:15 +01:00
|
|
|
.write = openpic_cpu_write,
|
|
|
|
.read = openpic_cpu_read,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
2004-06-15 23:38:40 +02:00
|
|
|
|
2012-12-08 01:04:48 +01:00
|
|
|
static const MemoryRegionOps openpic_cpu_ops_be = {
|
|
|
|
.write = openpic_cpu_write,
|
|
|
|
.read = openpic_cpu_read,
|
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static const MemoryRegionOps openpic_src_ops_le = {
|
2012-12-07 17:15:15 +01:00
|
|
|
.write = openpic_src_write,
|
|
|
|
.read = openpic_src_read,
|
2011-08-08 15:09:17 +02:00
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
2012-12-07 16:31:55 +01:00
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
2011-08-08 15:09:17 +02:00
|
|
|
};
|
|
|
|
|
2012-12-08 01:04:48 +01:00
|
|
|
static const MemoryRegionOps openpic_src_ops_be = {
|
|
|
|
.write = openpic_src_write,
|
|
|
|
.read = openpic_src_read,
|
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static const MemoryRegionOps openpic_msi_ops_be = {
|
2012-12-08 14:18:00 +01:00
|
|
|
.read = openpic_msi_read,
|
|
|
|
.write = openpic_msi_write,
|
2013-01-21 16:53:53 +01:00
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
2012-12-08 14:18:00 +01:00
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static const MemoryRegionOps openpic_summary_ops_be = {
|
|
|
|
.read = openpic_summary_read,
|
|
|
|
.write = openpic_summary_write,
|
2012-12-08 14:18:00 +01:00
|
|
|
.endianness = DEVICE_BIG_ENDIAN,
|
|
|
|
.impl = {
|
|
|
|
.min_access_size = 4,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static void openpic_save_IRQ_queue(QEMUFile* f, IRQQueue *q)
|
2009-02-06 22:30:02 +01:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
2012-12-21 17:15:48 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(q->queue); i++) {
|
|
|
|
/* Always put the lower half of a 64-bit long first, in case we
|
|
|
|
* restore on a 32-bit host. The least significant bits correspond
|
|
|
|
* to lower IRQ numbers in the bitmap.
|
|
|
|
*/
|
|
|
|
qemu_put_be32(f, (uint32_t)q->queue[i]);
|
|
|
|
#if LONG_MAX > 0x7FFFFFFF
|
|
|
|
qemu_put_be32(f, (uint32_t)(q->queue[i] >> 32));
|
|
|
|
#endif
|
|
|
|
}
|
2009-02-06 22:30:02 +01:00
|
|
|
|
|
|
|
qemu_put_sbe32s(f, &q->next);
|
|
|
|
qemu_put_sbe32s(f, &q->priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void openpic_save(QEMUFile* f, void *opaque)
|
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = (OpenPICState *)opaque;
|
2009-02-06 22:30:02 +01:00
|
|
|
unsigned int i;
|
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_put_be32s(f, &opp->gcr);
|
|
|
|
qemu_put_be32s(f, &opp->vir);
|
|
|
|
qemu_put_be32s(f, &opp->pir);
|
2009-02-06 22:30:02 +01:00
|
|
|
qemu_put_be32s(f, &opp->spve);
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_put_be32s(f, &opp->tfrr);
|
2009-02-06 22:30:02 +01:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
qemu_put_be32s(f, &opp->nb_cpus);
|
2009-03-02 17:42:04 +01:00
|
|
|
|
|
|
|
for (i = 0; i < opp->nb_cpus; i++) {
|
2012-12-21 17:15:44 +01:00
|
|
|
qemu_put_sbe32s(f, &opp->dst[i].ctpr);
|
2009-02-06 22:30:02 +01:00
|
|
|
openpic_save_IRQ_queue(f, &opp->dst[i].raised);
|
|
|
|
openpic_save_IRQ_queue(f, &opp->dst[i].servicing);
|
2013-01-03 14:25:40 +01:00
|
|
|
qemu_put_buffer(f, (uint8_t *)&opp->dst[i].outputs_active,
|
|
|
|
sizeof(opp->dst[i].outputs_active));
|
2009-02-06 22:30:02 +01:00
|
|
|
}
|
|
|
|
|
2013-04-15 15:19:32 +02:00
|
|
|
for (i = 0; i < OPENPIC_MAX_TMR; i++) {
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_put_be32s(f, &opp->timers[i].tccr);
|
|
|
|
qemu_put_be32s(f, &opp->timers[i].tbcr);
|
2009-02-06 22:30:02 +01:00
|
|
|
}
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
|
|
|
|
for (i = 0; i < opp->max_irq; i++) {
|
|
|
|
qemu_put_be32s(f, &opp->src[i].ivpr);
|
|
|
|
qemu_put_be32s(f, &opp->src[i].idr);
|
2013-01-21 16:53:51 +01:00
|
|
|
qemu_get_be32s(f, &opp->src[i].destmask);
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
qemu_put_sbe32s(f, &opp->src[i].last_cpu);
|
|
|
|
qemu_put_sbe32s(f, &opp->src[i].pending);
|
2009-02-06 22:30:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
static void openpic_load_IRQ_queue(QEMUFile* f, IRQQueue *q)
|
2009-02-06 22:30:02 +01:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
2012-12-21 17:15:48 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(q->queue); i++) {
|
|
|
|
unsigned long val;
|
|
|
|
|
|
|
|
val = qemu_get_be32(f);
|
|
|
|
#if LONG_MAX > 0x7FFFFFFF
|
|
|
|
val <<= 32;
|
|
|
|
val |= qemu_get_be32(f);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
q->queue[i] = val;
|
|
|
|
}
|
2009-02-06 22:30:02 +01:00
|
|
|
|
|
|
|
qemu_get_sbe32s(f, &q->next);
|
|
|
|
qemu_get_sbe32s(f, &q->priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int openpic_load(QEMUFile* f, void *opaque, int version_id)
|
|
|
|
{
|
2012-12-08 01:59:20 +01:00
|
|
|
OpenPICState *opp = (OpenPICState *)opaque;
|
2014-04-28 15:08:17 +02:00
|
|
|
unsigned int i, nb_cpus;
|
2009-02-06 22:30:02 +01:00
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
if (version_id != 1) {
|
2009-02-06 22:30:02 +01:00
|
|
|
return -EINVAL;
|
2012-12-20 17:30:58 +01:00
|
|
|
}
|
2009-02-06 22:30:02 +01:00
|
|
|
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_get_be32s(f, &opp->gcr);
|
|
|
|
qemu_get_be32s(f, &opp->vir);
|
|
|
|
qemu_get_be32s(f, &opp->pir);
|
2009-02-06 22:30:02 +01:00
|
|
|
qemu_get_be32s(f, &opp->spve);
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_get_be32s(f, &opp->tfrr);
|
2009-02-06 22:30:02 +01:00
|
|
|
|
2014-04-28 15:08:17 +02:00
|
|
|
qemu_get_be32s(f, &nb_cpus);
|
|
|
|
if (opp->nb_cpus != nb_cpus) {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
assert(nb_cpus > 0 && nb_cpus <= MAX_CPU);
|
2009-03-02 17:42:04 +01:00
|
|
|
|
|
|
|
for (i = 0; i < opp->nb_cpus; i++) {
|
2012-12-21 17:15:44 +01:00
|
|
|
qemu_get_sbe32s(f, &opp->dst[i].ctpr);
|
2009-02-06 22:30:02 +01:00
|
|
|
openpic_load_IRQ_queue(f, &opp->dst[i].raised);
|
|
|
|
openpic_load_IRQ_queue(f, &opp->dst[i].servicing);
|
2013-01-03 14:25:40 +01:00
|
|
|
qemu_get_buffer(f, (uint8_t *)&opp->dst[i].outputs_active,
|
|
|
|
sizeof(opp->dst[i].outputs_active));
|
2009-02-06 22:30:02 +01:00
|
|
|
}
|
|
|
|
|
2013-04-15 15:19:32 +02:00
|
|
|
for (i = 0; i < OPENPIC_MAX_TMR; i++) {
|
2012-12-21 17:15:42 +01:00
|
|
|
qemu_get_be32s(f, &opp->timers[i].tccr);
|
|
|
|
qemu_get_be32s(f, &opp->timers[i].tbcr);
|
2009-02-06 22:30:02 +01:00
|
|
|
}
|
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
for (i = 0; i < opp->max_irq; i++) {
|
|
|
|
uint32_t val;
|
2009-02-06 22:30:02 +01:00
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
val = qemu_get_be32(f);
|
|
|
|
write_IRQreg_idr(opp, i, val);
|
|
|
|
val = qemu_get_be32(f);
|
|
|
|
write_IRQreg_ivpr(opp, i, val);
|
2012-12-07 23:51:09 +01:00
|
|
|
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
qemu_get_be32s(f, &opp->src[i].ivpr);
|
|
|
|
qemu_get_be32s(f, &opp->src[i].idr);
|
2013-01-21 16:53:51 +01:00
|
|
|
qemu_get_be32s(f, &opp->src[i].destmask);
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
qemu_get_sbe32s(f, &opp->src[i].last_cpu);
|
|
|
|
qemu_get_sbe32s(f, &opp->src[i].pending);
|
2012-12-07 23:51:09 +01:00
|
|
|
}
|
openpic: rework critical interrupt support
Critical interrupts on FSL MPIC are not supposed to pay
attention to priority, IACK, EOI, etc. On the currently modeled
version it's not supposed to pay attention to the mask bit either.
Also reorganize to make it easier to implement newer FSL MPIC models,
which encode interrupt level information differently and support
mcheck as well as crit, and to reduce problems for later patches
in this set.
Still missing is the ability to lower the CINT signal to the core,
as IACK/EOI is not used. This will come with general IRQ-source-driven
lowering in the next patch.
New state is added which is not serialized, but instead is recomputed
in openpic_load() by calling the appropriate write_IRQreg function.
This should have the side effect of causing the IRQ outputs to be
raised appropriately on load, which was missing.
The serialization format is altered by swapping ivpr and idr (we'd like
IDR to be restored before we run the IVPR logic), and moving interrupts
to the end (so that other state has been restored by the time we run the
IDR/IVPR logic. Serialization for this driver is not yet in a state
where backwards compatibility is reasonable (assuming it works at all),
and the current serialization format was not built for extensibility.
Signed-off-by: Scott Wood <scottwood@freescale.com>
[agraf: fix for current code state]
Signed-off-by: Alexander Graf <agraf@suse.de>
2012-12-21 17:15:43 +01:00
|
|
|
|
|
|
|
return 0;
|
2009-03-02 17:42:04 +01:00
|
|
|
}
|
|
|
|
|
2014-05-22 06:46:52 +02:00
|
|
|
static void openpic_reset(DeviceState *d)
|
|
|
|
{
|
|
|
|
OpenPICState *opp = OPENPIC(d);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
opp->gcr = GCR_RESET;
|
|
|
|
/* Initialise controller registers */
|
|
|
|
opp->frr = ((opp->nb_irqs - 1) << FRR_NIRQ_SHIFT) |
|
|
|
|
((opp->nb_cpus - 1) << FRR_NCPU_SHIFT) |
|
|
|
|
(opp->vid << FRR_VID_SHIFT);
|
|
|
|
|
|
|
|
opp->pir = 0;
|
|
|
|
opp->spve = -1 & opp->vector_mask;
|
|
|
|
opp->tfrr = opp->tfrr_reset;
|
|
|
|
/* Initialise IRQ sources */
|
|
|
|
for (i = 0; i < opp->max_irq; i++) {
|
|
|
|
opp->src[i].ivpr = opp->ivpr_reset;
|
|
|
|
switch (opp->src[i].type) {
|
|
|
|
case IRQ_TYPE_NORMAL:
|
|
|
|
opp->src[i].level = !!(opp->ivpr_reset & IVPR_SENSE_MASK);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IRQ_TYPE_FSLINT:
|
|
|
|
opp->src[i].ivpr |= IVPR_POLARITY_MASK;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case IRQ_TYPE_FSLSPECIAL:
|
|
|
|
break;
|
|
|
|
}
|
2014-05-22 08:09:45 +02:00
|
|
|
|
|
|
|
write_IRQreg_idr(opp, i, opp->idr_reset);
|
2014-05-22 06:46:52 +02:00
|
|
|
}
|
|
|
|
/* Initialise IRQ destinations */
|
|
|
|
for (i = 0; i < MAX_CPU; i++) {
|
|
|
|
opp->dst[i].ctpr = 15;
|
|
|
|
memset(&opp->dst[i].raised, 0, sizeof(IRQQueue));
|
|
|
|
opp->dst[i].raised.next = -1;
|
|
|
|
memset(&opp->dst[i].servicing, 0, sizeof(IRQQueue));
|
|
|
|
opp->dst[i].servicing.next = -1;
|
|
|
|
}
|
|
|
|
/* Initialise timers */
|
|
|
|
for (i = 0; i < OPENPIC_MAX_TMR; i++) {
|
|
|
|
opp->timers[i].tccr = 0;
|
|
|
|
opp->timers[i].tbcr = TBCR_CI;
|
|
|
|
}
|
|
|
|
/* Go out of RESET state */
|
|
|
|
opp->gcr = 0;
|
|
|
|
}
|
|
|
|
|
2012-12-20 17:30:58 +01:00
|
|
|
typedef struct MemReg {
|
2012-12-08 05:17:14 +01:00
|
|
|
const char *name;
|
|
|
|
MemoryRegionOps const *ops;
|
|
|
|
hwaddr start_addr;
|
|
|
|
ram_addr_t size;
|
2012-12-20 17:30:58 +01:00
|
|
|
} MemReg;
|
2012-12-08 05:17:14 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
static void fsl_common_init(OpenPICState *opp)
|
|
|
|
{
|
|
|
|
int i;
|
2013-04-15 15:19:32 +02:00
|
|
|
int virq = OPENPIC_MAX_SRC;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
opp->vid = VID_REVISION_1_2;
|
|
|
|
opp->vir = VIR_GENERIC;
|
|
|
|
opp->vector_mask = 0xFFFF;
|
|
|
|
opp->tfrr_reset = 0;
|
|
|
|
opp->ivpr_reset = IVPR_MASK_MASK;
|
|
|
|
opp->idr_reset = 1 << 0;
|
2013-04-15 15:19:32 +02:00
|
|
|
opp->max_irq = OPENPIC_MAX_IRQ;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
opp->irq_ipi0 = virq;
|
2013-04-15 15:19:32 +02:00
|
|
|
virq += OPENPIC_MAX_IPI;
|
2013-01-21 16:53:53 +01:00
|
|
|
opp->irq_tim0 = virq;
|
2013-04-15 15:19:32 +02:00
|
|
|
virq += OPENPIC_MAX_TMR;
|
2013-01-21 16:53:53 +01:00
|
|
|
|
2013-04-15 15:19:32 +02:00
|
|
|
assert(virq <= OPENPIC_MAX_IRQ);
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
opp->irq_msi = 224;
|
|
|
|
|
|
|
|
msi_supported = true;
|
|
|
|
for (i = 0; i < opp->fsl->max_ext; i++) {
|
|
|
|
opp->src[i].level = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Internal interrupts, including message and MSI */
|
2013-04-15 15:19:32 +02:00
|
|
|
for (i = 16; i < OPENPIC_MAX_SRC; i++) {
|
2013-01-21 16:53:53 +01:00
|
|
|
opp->src[i].type = IRQ_TYPE_FSLINT;
|
|
|
|
opp->src[i].level = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* timers and IPIs */
|
2013-04-15 15:19:32 +02:00
|
|
|
for (i = OPENPIC_MAX_SRC; i < virq; i++) {
|
2013-01-21 16:53:53 +01:00
|
|
|
opp->src[i].type = IRQ_TYPE_FSLSPECIAL;
|
|
|
|
opp->src[i].level = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void map_list(OpenPICState *opp, const MemReg *list, int *count)
|
|
|
|
{
|
|
|
|
while (list->name) {
|
|
|
|
assert(*count < ARRAY_SIZE(opp->sub_io_mem));
|
|
|
|
|
2013-06-07 03:25:08 +02:00
|
|
|
memory_region_init_io(&opp->sub_io_mem[*count], OBJECT(opp), list->ops,
|
|
|
|
opp, list->name, list->size);
|
2013-01-21 16:53:53 +01:00
|
|
|
|
|
|
|
memory_region_add_subregion(&opp->mem, list->start_addr,
|
|
|
|
&opp->sub_io_mem[*count]);
|
|
|
|
|
|
|
|
(*count)++;
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-18 03:58:08 +02:00
|
|
|
static void openpic_init(Object *obj)
|
2004-06-15 23:38:40 +02:00
|
|
|
{
|
2013-06-18 03:58:08 +02:00
|
|
|
OpenPICState *opp = OPENPIC(obj);
|
|
|
|
|
2013-06-07 03:25:08 +02:00
|
|
|
memory_region_init(&opp->mem, obj, "openpic", 0x40000);
|
2013-06-18 03:58:08 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void openpic_realize(DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
SysBusDevice *d = SYS_BUS_DEVICE(dev);
|
2013-06-18 03:58:07 +02:00
|
|
|
OpenPICState *opp = OPENPIC(dev);
|
2012-12-08 05:17:14 +01:00
|
|
|
int i, j;
|
2013-01-21 16:53:53 +01:00
|
|
|
int list_count = 0;
|
|
|
|
static const MemReg list_le[] = {
|
|
|
|
{"glb", &openpic_glb_ops_le,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_GLB_REG_START, OPENPIC_GLB_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"tmr", &openpic_tmr_ops_le,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_TMR_REG_START, OPENPIC_TMR_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"src", &openpic_src_ops_le,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_SRC_REG_START, OPENPIC_SRC_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"cpu", &openpic_cpu_ops_le,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_CPU_REG_START, OPENPIC_CPU_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{NULL}
|
2012-12-07 17:15:15 +01:00
|
|
|
};
|
2013-01-21 16:53:53 +01:00
|
|
|
static const MemReg list_be[] = {
|
|
|
|
{"glb", &openpic_glb_ops_be,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_GLB_REG_START, OPENPIC_GLB_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"tmr", &openpic_tmr_ops_be,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_TMR_REG_START, OPENPIC_TMR_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"src", &openpic_src_ops_be,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_SRC_REG_START, OPENPIC_SRC_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{"cpu", &openpic_cpu_ops_be,
|
2012-12-08 14:18:00 +01:00
|
|
|
OPENPIC_CPU_REG_START, OPENPIC_CPU_REG_SIZE},
|
2013-01-21 16:53:53 +01:00
|
|
|
{NULL}
|
2012-12-08 05:17:14 +01:00
|
|
|
};
|
2013-01-21 16:53:53 +01:00
|
|
|
static const MemReg list_fsl[] = {
|
|
|
|
{"msi", &openpic_msi_ops_be,
|
|
|
|
OPENPIC_MSI_REG_START, OPENPIC_MSI_REG_SIZE},
|
|
|
|
{"summary", &openpic_summary_ops_be,
|
|
|
|
OPENPIC_SUMMARY_REG_START, OPENPIC_SUMMARY_REG_SIZE},
|
|
|
|
{NULL}
|
|
|
|
};
|
|
|
|
|
2014-04-28 15:08:17 +02:00
|
|
|
if (opp->nb_cpus > MAX_CPU) {
|
|
|
|
error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
|
|
|
|
TYPE_OPENPIC, "nb_cpus", (uint64_t)opp->nb_cpus,
|
|
|
|
(uint64_t)0, (uint64_t)MAX_CPU);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
switch (opp->model) {
|
|
|
|
case OPENPIC_MODEL_FSL_MPIC_20:
|
|
|
|
default:
|
2013-01-21 16:53:53 +01:00
|
|
|
opp->fsl = &fsl_mpic_20;
|
|
|
|
opp->brr1 = 0x00400200;
|
2012-12-21 17:15:42 +01:00
|
|
|
opp->flags |= OPENPIC_FLAG_IDR_CRIT;
|
2012-12-08 05:17:14 +01:00
|
|
|
opp->nb_irqs = 80;
|
2013-01-21 16:53:53 +01:00
|
|
|
opp->mpic_mode_mask = GCR_MODE_MIXED;
|
2013-01-04 11:21:04 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
fsl_common_init(opp);
|
|
|
|
map_list(opp, list_be, &list_count);
|
|
|
|
map_list(opp, list_fsl, &list_count);
|
2013-01-03 14:25:37 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
break;
|
2013-01-03 14:25:37 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
case OPENPIC_MODEL_FSL_MPIC_42:
|
|
|
|
opp->fsl = &fsl_mpic_42;
|
|
|
|
opp->brr1 = 0x00400402;
|
|
|
|
opp->flags |= OPENPIC_FLAG_ILR;
|
|
|
|
opp->nb_irqs = 196;
|
|
|
|
opp->mpic_mode_mask = GCR_MODE_PROXY;
|
2013-01-03 14:25:37 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
fsl_common_init(opp);
|
|
|
|
map_list(opp, list_be, &list_count);
|
|
|
|
map_list(opp, list_fsl, &list_count);
|
2013-01-03 14:25:37 +01:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
break;
|
2013-01-03 14:25:37 +01:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
case OPENPIC_MODEL_RAVEN:
|
|
|
|
opp->nb_irqs = RAVEN_MAX_EXT;
|
|
|
|
opp->vid = VID_REVISION_1_3;
|
2012-12-21 17:15:42 +01:00
|
|
|
opp->vir = VIR_GENERIC;
|
2012-12-13 17:12:01 +01:00
|
|
|
opp->vector_mask = 0xFF;
|
2012-12-21 17:15:42 +01:00
|
|
|
opp->tfrr_reset = 4160000;
|
|
|
|
opp->ivpr_reset = IVPR_MASK_MASK | IVPR_MODE_MASK;
|
|
|
|
opp->idr_reset = 0;
|
2012-12-08 05:17:14 +01:00
|
|
|
opp->max_irq = RAVEN_MAX_IRQ;
|
|
|
|
opp->irq_ipi0 = RAVEN_IPI_IRQ;
|
|
|
|
opp->irq_tim0 = RAVEN_TMR_IRQ;
|
2012-12-08 13:51:50 +01:00
|
|
|
opp->brr1 = -1;
|
2013-01-07 20:17:24 +01:00
|
|
|
opp->mpic_mode_mask = GCR_MODE_MIXED;
|
2012-12-08 05:17:14 +01:00
|
|
|
|
|
|
|
if (opp->nb_cpus != 1) {
|
2013-06-18 03:58:08 +02:00
|
|
|
error_setg(errp, "Only UP supported today");
|
|
|
|
return;
|
2012-12-08 05:17:14 +01:00
|
|
|
}
|
2012-12-07 17:15:15 +01:00
|
|
|
|
2013-01-21 16:53:53 +01:00
|
|
|
map_list(opp, list_le, &list_count);
|
|
|
|
break;
|
2012-12-07 17:15:15 +01:00
|
|
|
}
|
2007-09-17 10:09:54 +02:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
for (i = 0; i < opp->nb_cpus; i++) {
|
2014-08-15 10:15:10 +02:00
|
|
|
opp->dst[i].irqs = g_new0(qemu_irq, OPENPIC_OUTPUT_NB);
|
2012-12-08 05:17:14 +01:00
|
|
|
for (j = 0; j < OPENPIC_OUTPUT_NB; j++) {
|
2013-06-18 03:58:08 +02:00
|
|
|
sysbus_init_irq(d, &opp->dst[i].irqs[j]);
|
2012-12-08 05:17:14 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-18 03:58:08 +02:00
|
|
|
register_savevm(dev, "openpic", 0, 2,
|
2010-06-25 19:09:07 +02:00
|
|
|
openpic_save, openpic_load, opp);
|
2009-03-02 17:42:04 +01:00
|
|
|
|
2013-06-18 03:58:08 +02:00
|
|
|
sysbus_init_mmio(d, &opp->mem);
|
|
|
|
qdev_init_gpio_in(dev, openpic_set_irq, opp->max_irq);
|
2009-03-02 17:42:04 +01:00
|
|
|
}
|
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
static Property openpic_properties[] = {
|
|
|
|
DEFINE_PROP_UINT32("model", OpenPICState, model, OPENPIC_MODEL_FSL_MPIC_20),
|
|
|
|
DEFINE_PROP_UINT32("nb_cpus", OpenPICState, nb_cpus, 1),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
2011-08-30 17:46:26 +02:00
|
|
|
|
2013-06-18 03:58:08 +02:00
|
|
|
static void openpic_class_init(ObjectClass *oc, void *data)
|
2012-12-08 05:17:14 +01:00
|
|
|
{
|
2013-06-18 03:58:08 +02:00
|
|
|
DeviceClass *dc = DEVICE_CLASS(oc);
|
2009-03-02 17:42:04 +01:00
|
|
|
|
2013-06-18 03:58:08 +02:00
|
|
|
dc->realize = openpic_realize;
|
2012-12-08 05:17:14 +01:00
|
|
|
dc->props = openpic_properties;
|
|
|
|
dc->reset = openpic_reset;
|
|
|
|
}
|
2011-08-30 17:46:26 +02:00
|
|
|
|
2013-01-10 16:19:07 +01:00
|
|
|
static const TypeInfo openpic_info = {
|
2013-06-18 03:58:07 +02:00
|
|
|
.name = TYPE_OPENPIC,
|
2012-12-08 05:17:14 +01:00
|
|
|
.parent = TYPE_SYS_BUS_DEVICE,
|
|
|
|
.instance_size = sizeof(OpenPICState),
|
2013-06-18 03:58:08 +02:00
|
|
|
.instance_init = openpic_init,
|
2012-12-08 05:17:14 +01:00
|
|
|
.class_init = openpic_class_init,
|
|
|
|
};
|
2009-03-02 17:42:04 +01:00
|
|
|
|
2012-12-08 05:17:14 +01:00
|
|
|
static void openpic_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&openpic_info);
|
2004-06-15 23:38:40 +02:00
|
|
|
}
|
2012-12-08 05:17:14 +01:00
|
|
|
|
|
|
|
type_init(openpic_register_types)
|