serengeti/sys/sbdp_priv.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _SBDP_PRIV_H
#define _SBDP_PRIV_H

#pragma ident   "%Z%%M% %I% %E% SMI"

#ifdef  __cplusplus
extern "C" {
#endif

#include <sys/sbd.h>
#include <sys/sbdp_mbox.h>
#include <sys/conf.h>
#include <sys/ddi_impldefs.h>
#include <sys/serengeti.h>

#ifdef DEBUG
#define SBDPDBG_STATE   0x00000001
#define SBDPDBG_QR  0x00000002
#define SBDPDBG_CPU 0x00000004
#define SBDPDBG_MEM 0x00000008
#define SBDPDBG_IO  0x00000010
#define SBDPDBG_MBOX    0x00000020
#define SBDPDBG_ERR 0x00000040
#define SBDPDBG_MISC    0x00000080
#define SBDPDBG_FUNC    0x00000100

extern uint_t sbdp_debug;

#define SBDP_DBG_ALL    if (sbdp_debug)             prom_printf
#define SBDP_DBG_STATE  if (sbdp_debug & SBDPDBG_STATE)     prom_printf
#define SBDP_DBG_QR if (sbdp_debug & SBDPDBG_QR)        prom_printf
#define SBDP_DBG_CPU    if (sbdp_debug & SBDPDBG_CPU)       prom_printf
#define SBDP_DBG_MEM    if (sbdp_debug & SBDPDBG_MEM)       prom_printf
#define SBDP_DBG_IO if (sbdp_debug & SBDPDBG_IO)        prom_printf
#define SBDP_DBG_MBOX   if (sbdp_debug & SBDPDBG_MBOX)      prom_printf
#define SBDP_DBG_ERR    if (sbdp_debug & SBDPDBG_ERR)       prom_printf
#define SBDP_DBG_MISC   if (sbdp_debug & SBDPDBG_MISC)      prom_printf
#define SBDP_DBG_FUNC   if (sbdp_debug & SBDPDBG_FUNC)      prom_printf

#else /* DEBUG */

#define SBDP_DBG_ALL
#define SBDP_DBG_STATE
#define SBDP_DBG_QR
#define SBDP_DBG_CPU
#define SBDP_DBG_MEM
#define SBDP_DBG_IO
#define SBDP_DBG_MBOX
#define SBDP_DBG_ERR
#define SBDP_DBG_MISC
#define SBDP_DBG_FUNC
#endif /* DEBUG */

#define PORTID_BAD  -1
#define OBP_PORTID  "portid"
#define SBDP_MAX_BOARDS  plat_max_boards()
#define SBDP_MAX_MEM_NODES_PER_BOARD    4
#define SBDP_MAX_NODES  32
#define SBDP_MAX_WNODES 16

/*
 * CPU present macros
 */
#define SBDP_SET_CPU_PRESENT(bdp, unit)\
            ((bdp)->cpus_present |= (1 << (unit)))

#define SBDP_IS_CPU_PRESENT(bdp, unit)\
            (((bdp)->cpus_present & (1 << (unit))) != 0)

/*
 * CPU reset macros
 */
#define SBDP_SET_CPU_IN_RESET(bdp, unit)\
            ((bdp)->cpus_in_reset |= (1 << (unit)))
#define SBDP_UNSET_CPU_IN_RESET(bdp, unit)\
            ((bdp)->cpus_in_reset &= ~(1 << (unit)))
#define SBDP_IS_CPU_IN_RESET(bdp, unit)\
            (((bdp)->cpus_in_reset & (1 << (unit))) != 0)
#define SBDP_SET_ALL_CPUS_IN_RESET(bdp)\
            ((bdp)->cpus_in_reset |= 0xf)
#define SBDP_UNSET_ALL_CPUS_IN_RESET(bdp)\
            ((bdp)->cpus_in_reset = 0x0)
#define SBDP_ALL_CPUS   -1

/*
 * These definitions come from the SC. Should the SC change them
 * then we need to changed them
 */
#define SBDP_DIAG_OFF       0x00
#define SBDP_DIAG_INIT      0x07
#define SBDP_DIAG_QUICK     0x10
#define SBDP_DIAG_MIN       0x20
#define SBDP_DIAG_DEFAULT   0x40
#define SBDP_DIAG_MEM1      0x60
#define SBDP_DIAG_MEM2      0x7f
#define SBDP_DIAG_NVCI      0xffff  /* Use stored value in nvci */

int     *slices;

#define SBDP_INIT_PLATOPTS  (uint_t)-1
#define SBDP_PLATFORM_OPTS(s_platopts)  ((s_platopts) = SBDP_INIT_PLATOPTS, \
        SBD_SET_PLATOPTS(SBD_CMD_TEST, (s_platopts)), \
        SBD_SET_PLATOPTS(SBD_CMD_PASSTHRU, (s_platopts)))

typedef struct sbdp_bank {
    int         id;
    ushort_t        valid;
    ushort_t        uk;
    uint_t          um;
    uchar_t         lk;
    uchar_t         lm;
    struct sbdp_bank    *bd_next;   /* in the board */
    struct sbdp_bank    *seg_next;  /* in the segment */
} sbdp_bank_t;

typedef struct sbdp_segs {
    int         id;
    int         intlv;  /* interleave for this segment */
    uint64_t        base;   /* base address for this segment */
    uint64_t        size;   /* size of this segment */
    int         nbanks; /* number of banks in this segment */
    sbdp_bank_t     *banks; /* pointer to the banks of this seg */
    struct sbdp_segs    *next;
} sbdp_seg_t;

typedef struct {
    int     bd;
    int     wnode;
    uint64_t    bpa;    /* base physical addr for this board */
    int     nnum;   /* number of nodes */
    struct memlist  *ml;    /* memlist for this board */
    pnode_t     nodes[SBDP_MAX_MEM_NODES_PER_BOARD];
    kmutex_t    bd_mutex; /* mutex for this board */
    show_board_t    *bd_sc; /* info obtained from the SC */
    int     valid_cp; /* Is this a valid copy of show_board */
    sbdp_bank_t *banks; /* Banks for this board */
    int     cpus_in_reset;
    int     cpus_present;
} sbdp_bd_t;

typedef struct sbdp_wnode {
    int         wnode;  /* wildcat node */
    int         nbds;   /* number of bds for this node */
    sbdp_bd_t       *bds;   /* pointer to the list of bds */
    struct sbdp_wnode   *next;  /* ptr to nex wnode */
    struct sbdp_wnode   *prev;  /* ptr to prev node */
} sbdp_wnode_t;

typedef struct {
    uint_t  regspec_addr_hi;
    uint_t  regspec_addr_lo;
    uint_t  regspec_size_hi;
    uint_t  regspec_size_lo;
} regspace_t;

/*
 * Suspend states used internally by sbdp_suspend and
 * sbdp_resume
 */
typedef enum sbd_suspend_state {
    SBDP_SRSTATE_BEGIN = 0,
    SBDP_SRSTATE_USER,
    SBDP_SRSTATE_DRIVER,
    SBDP_SRSTATE_FULL
} suspend_state_t;

/*
 * specific suspend/resume interface handle
 */
typedef struct {
    sbd_error_t     sep;
    dev_info_t      *sr_failed_dip;
    suspend_state_t     sr_suspend_state;
    uint_t          sr_flags;
    uint_t          sh_ndi;
} sbdp_sr_handle_t;

typedef struct sbdp_shutdown {
    uint64_t    estack;
    uint64_t    flushaddr;
    uint32_t    size;
    uint32_t    linesize;
    uint64_t    physaddr;
} sbdp_shutdown_t;

extern int plat_max_boards();

typedef struct {
    int     node;       /* wildcat node */
    int     board;
    pnode_t     nodes[SBDP_MAX_NODES];
    int     num_of_nodes;
    int     flags;
    int     error;
    dev_info_t  *top_node;
    char        *errstr;
} attach_pkt_t;

extern uint64_t *sbdp_valp;

sbdp_sr_handle_t *sbdp_get_sr_handle(void);
void sbdp_release_sr_handle(sbdp_sr_handle_t *);
int sbdp_suspend(sbdp_sr_handle_t *);
void sbdp_resume(sbdp_sr_handle_t *);
void sbdp_set_err(sbd_error_t *ep, int ecode, char *rsc);
int sbdp_is_node_bad(pnode_t);
void sbdp_walk_prom_tree(pnode_t, int(*)(pnode_t, void *, uint_t), void *);
int sbdp_detach_bd(int node, int board, sbd_error_t *sep);
void sbdp_attach_bd(int, int);
int sbdp_get_bd_and_wnode_num(pnode_t, int *, int *);
void sbdp_update_bd_info(sbdp_bd_t *);
sbdp_bd_t *sbdp_get_bd_info(int, int);
int sbdp_make_bd_mem_contigous(int);
sbd_cond_t sbdp_get_comp_status(pnode_t);
void sbdp_init_bd_banks(sbdp_bd_t *);
void sbdp_swap_list_of_banks(sbdp_bd_t *, sbdp_bd_t *);
void sbdp_fini_bd_banks(sbdp_bd_t *);
void sbdp_print_bd_banks(sbdp_bd_t *);
void sbdp_add_new_bd_info(int, int);
void sbdp_cleanup_bd(int, int);
void sbdp_cpu_in_reset(int, int, int, int);
int sbdp_is_cpu_in_reset(int, int, int);
int sbdp_set_cpu_present(int, int, int);
int sbdp_is_cpu_present(int, int, int);
int sbdp_swap_slices(int, int);
#ifdef DEBUG
void sbdp_print_all_segs(void);
int sbdp_passthru_test_quiesce(sbdp_handle_t *hp, void *);
#endif
int sbdp_select_top_nodes(pnode_t, void *, uint_t);
pnode_t sbdp_find_nearby_cpu_by_portid(pnode_t, processorid_t);
int sbdp_board_non_panther_cpus(int, int);

#ifdef  __cplusplus
}
#endif

#endif  /* _SBDP_PRIV_H */