sgsbbc.c revision 03831d35f7499c87d51205817c93e9a8d42c4bae
/*
* 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
* 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.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* PCI SBBC Device Driver that provides interfaces into
* EPLD and IO-SRAM
*
*/
#include <sys/serengeti.h>
#include <sys/sgsbbc_priv.h>
#include <sys/sgsbbc_iosram_priv.h>
#include <sys/sgsbbc_mailbox_priv.h>
#ifdef DEBUG
/* debug flag */
uint_t sgsbbc_debug = 0;
#endif /* DEBUG */
/* driver entry point fn definitions */
/*
* SBBC soft state hook
*/
static void *sbbcp;
/*
* Chosen IOSRAM
*/
/*
* define new iosram's sbbc and liked list of sbbc.
*/
/*
* At attach time, check if the device is the 'chosen' node
* if it is, set up the IOSRAM Solaris<->SC Comm tunnel
* Its like 'Highlander' - there can be only one !
*/
static int master_chosen = FALSE;
/*
* Local variable to save intr_in_enabled when the driver is suspended
*/
static uint32_t intr_in_enabled;
/*
* Local declarations
*/
static void sbbc_chosen_init(sbbc_softstate_t *);
static void sbbc_add_instance(sbbc_softstate_t *);
static void sbbc_remove_instance(sbbc_softstate_t *);
static int sbbc_find_dip(dev_info_t *, void *);
static void sbbc_unmap_regs(sbbc_softstate_t *);
/*
* ops stuff.
*/
static struct cb_ops sbbc_cb_ops = {
nodev, /* cb_open */
nodev, /* cb_close */
nodev, /* cb_strategy */
nodev, /* cb_print */
nodev, /* cb_dump */
nodev, /* cb_read */
nodev, /* cb_write */
nodev, /* cb_ioctl */
nodev, /* cb_devmap */
nodev, /* cb_mmap */
nodev, /* cb_segmap */
nochpoll, /* cb_chpoll */
ddi_prop_op, /* cb_prop_op */
NULL, /* cb_stream */
};
/*
* Declare ops vectors for auto configuration.
*/
DEVO_REV, /* devo_rev */
0, /* devo_refcnt */
ddi_getinfo_1to1, /* devo_getinfo */
nulldev, /* devo_identify */
nulldev, /* devo_probe */
sbbc_attach, /* devo_attach */
sbbc_detach, /* devo_detach */
nodev, /* devo_reset */
&sbbc_cb_ops, /* devo_cb_ops */
nulldev /* devo_power */
};
/*
* Loadable module support.
*/
extern struct mod_ops mod_driverops;
&mod_driverops, /* type of module - driver */
"PCI SBBC %I%",
&sbbc_ops,
};
static struct modlinkage modlinkage = {
(void *)&modldrv,
};
int
_init(void)
{
int error;
sizeof (sbbc_softstate_t), 1)) != 0)
return (error);
return (error);
}
/*
* Initialise the global 'chosen' IOSRAM mutex
*/
/*
* Initialise the iosram driver
*/
iosram_init();
/*
* Initialize the mailbox
*/
return (error);
}
int
_fini(void)
{
int error;
/*
* remove the mailbox
*/
/*
* remove the iosram driver
*/
iosram_fini();
return (error);
}
int
{
}
static int
{
int instance;
int len;
#ifdef DEBUG
char name[8];
#endif /* DEBUG */
switch (cmd) {
case DDI_ATTACH:
return (DDI_FAILURE);
/*
* Set the dip in the soft state
* And get interrupt cookies and initialize the
* per instance mutex.
*/
/*
* Verify that an 'interrupts' property exists for
* this device. If not, this instance will be ignored.
*/
DDI_PROP_DONTPASS, "interrupts",
&len) != DDI_PROP_SUCCESS) {
"SBBC instance %d\n", instance);
return (DDI_FAILURE);
}
/*
* Add this instance to the sbbc chosen iosram list
* so that it can be used for tunnel switch.
*/
/*
* If this is the chosen IOSRAM and there is no master IOSRAM
* yet, then let's set this instance as the master.
* if there is a master alreay due to the previous tunnel switch
* then keep as is even though this is the chosen.
*/
if (sgsbbc_iosram_is_chosen(softsp)) {
/* Do 'chosen' init only */
}
#ifdef DEBUG
return (DDI_FAILURE);
}
#endif /* DEBUG */
return (DDI_SUCCESS);
case DDI_RESUME:
return (DDI_FAILURE);
/*
* Enable Interrupts now, turn on both INT#A lines
*/
pci_intr_enable_reg = (uint32_t *)
/*
* Reset intr_in_enabled to the original value
* so the SC can send us interrupt.
*/
0, (caddr_t)&intr_in_enabled,
sizeof (intr_in_enabled))) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static int
{
int instance;
int rc = DDI_SUCCESS;
return (DDI_FAILURE);
switch (cmd) {
case DDI_DETACH:
/* only tunnel switch the instance with iosram chosen */
"tunnel switch failed\n");
return (DDI_FAILURE);
}
}
/* Adjust linked list */
return (DDI_SUCCESS);
case DDI_SUSPEND:
uint32_t tmp_intr_enabled = 0;
/*
* Disable Interrupts now, turn OFF both INT#A lines
*/
pci_intr_enable_reg = (uint32_t *)
pci_intr_enable_reg, 0);
/*
* Set intr_in_enabled to 0 so the SC won't send
* us interrupt.
*/
0, (caddr_t)&intr_in_enabled,
sizeof (intr_in_enabled));
if (rc) {
return (DDI_FAILURE);
}
0, (caddr_t)&tmp_intr_enabled,
sizeof (tmp_intr_enabled));
if (rc) {
return (DDI_FAILURE);
}
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
static void
{
/*
* XXXX
* ddi_get_iblock_cookie() here because we need
* to initialise the mutex regardless of whether
* or not this SBBC will eventually
* register an interrupt handler
*/
}
static int
{
char *node_name;
char status[OBP_MAXPROPNAME];
/*
* Need to find a node named "bootbus-controller" that is neither
* disabled nor failed. If a node is not ok, there will be an
* OBP status property. Therefore, we will look for a node
* without the status property.
*/
return (DDI_WALK_TERMINATE);
}
}
return (DDI_WALK_CONTINUE);
}
/*
* SBBC Interrupt Handler
*
* Check the SBBC Port Interrupt Status
* register to verify that its our interrupt.
* If yes, clear the register.
*
* Then read the 'interrupt reason' field from SRAM,
* this triggers the appropriate soft_intr handler
*/
{
volatile uint32_t port_int_status;
volatile uint32_t intr_reason;
int i, intr_mask;
struct tunnel_key tunnel_key;
return (DDI_INTR_UNCLAIMED);
}
return (DDI_INTR_UNCLAIMED);
}
/*
* Normally if port_int_status is 0, we assume it is not
* our interrupt. However, we don't want to miss the
* ones that come in during tunnel switch. Therefore,
* we always check the interrupt reason bits in IOSRAM
* to be sure.
*/
/*
* Generate a softint for each interrupt
* bit set in the intr_in_reason field in SRAM
* that has a corresponding bit set in the
* intr_in_enabled field in SRAM
*/
if (iosram_read(SBBC_SC_INTR_ENABLED_KEY, 0,
goto intr_handler_exit;
}
for (i = 0; i < SBBC_MAX_INTRS; i++) {
intr_mask = (1 << i);
if (intr_reason & intr_mask) {
(intr->sbbc_intr_id != 0)) {
/*
* XXXX
* The model we agree with a handler
* is that they run until they have
* exhausted all work. To avoid
* triggering them again, they pass
* a state flag and lock when registering.
* We check the flag, if they are idle,
* we trigger.
* The interrupt handler should so
* intr_func()
* mutex_enter(sbbc_intr_lock);
* sbbc_intr_state = RUNNING;
* mutex_exit(sbbc_intr_lock);
* ..........
* ..........
* ..........
* mutex_enter(sbbc_intr_lock);
* sbbc_intr_state = IDLE;
* mutex_exit(sbbc_intr_lock);
*
* XXXX
*/
if (*(intr->sbbc_intr_state) ==
intr->sbbc_intr_id);
} else {
/*
* The handler is running
*/
}
intr_reason &= ~intr_mask;
/*
* Clear the corresponding reason bit in SRAM
*
* Since there is no interlocking between
* Solaris and the SC when writing to SRAM,
* it is possible for the SC to set another
* bit in the interrupt reason field while
* we are handling the current interrupt.
* To minimize the window in which an
* additional bit can be set, reading
* and writing the interrupt reason
* in SRAM must be as close as possible.
*/
intr_in_reason) & ~intr_mask);
}
}
if (intr_reason == 0) /* No more interrupts to be processed */
break;
}
/*
* Clear the Interrupt Status Register (RW1C)
*/
return (DDI_INTR_CLAIMED);
}
/*
* If we don't already have a master SBBC selected,
* get the <sbbc> property from the /chosen node. If
* the pathname matches, this is the master SBBC and
*/
static void
{
char master_sbbc[MAXNAMELEN];
char pn[MAXNAMELEN];
if (master_chosen != FALSE) {
/*
* We've got one already
*/
return;
}
/*
* Get /chosen node info. prom interface will handle errors.
*/
dnode = prom_chosennode();
/*
* Look for the "iosram" property on the chosen node with a prom
* interface as ddi_find_devinfo() couldn't be used (calls
* ddi_walk_devs() that creates one extra lock on the device tree).
*/
/*
* No I/O Board SBBC set up as console, what to do ?
*/
}
/*
* SRAM TOC Offset defaults to 0
*/
}
/*
* get the full OBP pathname of this node
*/
sizeof (master_sbbc)) < 0) {
nodeid);
}
/*
* map in the SBBC regs
*/
}
/*
* Only the 'chosen' node is used for iosram_read()/_write()
*
*/
"comm. tunnel \n");
}
/*
* Verify that an 'interrupts' property
* exists for this device
*/
DDI_PROP_DONTPASS, "interrupts",
&len) != DDI_PROP_SUCCESS) {
"'chosen' SBBC \n");
}
/*
* add the interrupt handler
* NB
* should this be a high-level interrupt ?
* NB
*/
"'chosen' SBBC \n");
}
/*
* Create the mailbox
*/
if (sbbc_mbox_create(softsp) != 0) {
}
}
}
/*
* sbbc_add_instance
* Must be called to hold chosen_lock.
*/
static void
{
#ifdef DEBUG
struct sbbc_softstate *sp;
#endif
#if defined(DEBUG)
/* Verify that this instance is not in the list yet */
}
#endif
/*
* Add this instance to the front of the list.
*/
if (sgsbbc_instances != NULL) {
}
}
static void
{
struct sbbc_softstate *sp;
}
}
if (sgsbbc_instances == softsp) {
}
break;
}
}
}
/*
* Generate an SBBC interrupt to the SC
* Called from iosram_send_intr()
*
* send_intr == 0, check if EPLD register clear
* send_intr == 1, send the interrupt
*/
int
{
volatile uchar_t epld_status;
return (ENXIO);
/*
* Check the L1 EPLD Interrupt register. If the
* interrupt bit is set, theres an interrupt outstanding
* (we assume) so return (EBUSY).
*/
if (epld_status & INTERRUPT_ON)
return (EBUSY);
(epld_status | INTERRUPT_ON));
return (0);
}
/*
* Map SBBC Internal registers
*
* The call to function should be protected by
* chosen_lock or master_iosram->iosram_lock
* to make sure a tunnel switch will not occur
* in a middle of mapping.
*/
int
{
struct ddi_device_acc_attr attr;
/*
* Map in register set 1, Common Device Regs
* SBCC offset 0x0
*/
return (DDI_FAILURE);
}
/*
* Map in using register set 1, EPLD
* SBCC offset 0xe000
*/
return (DDI_FAILURE);
}
/*
* Set up pointers for registers
*/
return (DDI_SUCCESS);
}
/*
* Unmap SBBC Internal registers
*/
static void
{
return;
}
}
return;
}
/*
* This is here to allow the IOSRAM driver get the softstate
* for a chosen node when doing a tunnel switch. Just enables
* us to avoid exporting the sbbcp softstate hook
*/
{
}
/*
* Add interrupt handlers
*/
int
{
int rc = DDI_SUCCESS;
/*
* map in the SBBC interrupts
* Note that the iblock_cookie was initialised
* in the 'attach' routine
*/
" interrupt handler\n");
rc = DDI_FAILURE;
}
return (rc);
}
void
{
/*
* Enable Interrupts now, turn on both INT#A lines
*/
}
void
{
/*
* Disable Interrupts now, turn off both INT#A lines
*/
}