/*
*
* skd.c: Solaris 11/10 Driver for sTec, Inc. S112x PCIe SSD card
*
* Solaris driver is based on the Linux driver authored by:
*
* Authors/Alphabetical: Dragan Stancevic <dstancevic@stec-inc.com>
* Gordon Waidhofer <gwaidhofer@stec-inc.com>
* John Hamilton <jhamilton@stec-inc.com>
*/
/*
* This file and its contents are supplied under the terms of the
* Common Development and Distribution License ("CDDL"), version 1.0.
* You may only use this file in accordance with the terms of version
* 1.0 of the CDDL.
*
* A full copy of the text of the CDDL should have accompanied this
* source. A copy of the CDDL is also available via the Internet at
* http://www.illumos.org/license/CDDL.
*/
/*
* Copyright 2013 STEC, Inc. All rights reserved.
* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
*/
#include <sys/types.h>
#include <sys/stream.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/file.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/cred.h>
#include <sys/modctl.h>
#include <sys/debug.h>
#include <sys/modctl.h>
#include <sys/list.h>
#include <sys/sysmacros.h>
#include <sys/errno.h>
#include <sys/pcie.h>
#include <sys/pci.h>
#include <sys/ddi.h>
#include <sys/dditypes.h>
#include <sys/sunddi.h>
#include <sys/atomic.h>
#include <sys/mutex.h>
#include <sys/param.h>
#include <sys/devops.h>
#include <sys/blkdev.h>
#include <sys/queue.h>
#include <sys/scsi/impl/inquiry.h>
#include "skd_s1120.h"
#include "skd.h"
int skd_dbg_level = 0;
void *skd_state = NULL;
int skd_disable_msi = 0;
int skd_disable_msix = 0;
/* Initialized in _init() and tunable, see _init(). */
clock_t skd_timer_ticks;
/* I/O DMA attributes structures. */
static ddi_dma_attr_t skd_64bit_io_dma_attr = {
DMA_ATTR_V0, /* dma_attr_version */
SKD_DMA_LOW_ADDRESS, /* low DMA address range */
SKD_DMA_HIGH_64BIT_ADDRESS, /* high DMA address range */
SKD_DMA_XFER_COUNTER, /* DMA counter register */
SKD_DMA_ADDRESS_ALIGNMENT, /* DMA address alignment */
SKD_DMA_BURSTSIZES, /* DMA burstsizes */
SKD_DMA_MIN_XFER_SIZE, /* min effective DMA size */
SKD_DMA_MAX_XFER_SIZE, /* max DMA xfer size */
SKD_DMA_SEGMENT_BOUNDARY, /* segment boundary */
SKD_DMA_SG_LIST_LENGTH, /* s/g list length */
SKD_DMA_GRANULARITY, /* granularity of device */
SKD_DMA_XFER_FLAGS /* DMA transfer flags */
};
int skd_isr_type = -1;
#define SKD_MAX_QUEUE_DEPTH 255
#define SKD_MAX_QUEUE_DEPTH_DEFAULT 64
int skd_max_queue_depth = SKD_MAX_QUEUE_DEPTH_DEFAULT;
#define SKD_MAX_REQ_PER_MSG 14
#define SKD_MAX_REQ_PER_MSG_DEFAULT 1
int skd_max_req_per_msg = SKD_MAX_REQ_PER_MSG_DEFAULT;
#define SKD_MAX_N_SG_PER_REQ 4096
int skd_sgs_per_request = SKD_N_SG_PER_REQ_DEFAULT;
static int skd_sys_quiesce_dev(dev_info_t *);
static int skd_quiesce_dev(skd_device_t *);
static int skd_list_skmsg(skd_device_t *, int);
static int skd_list_skreq(skd_device_t *, int);
static int skd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int skd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int skd_format_internal_skspcl(struct skd_device *skdev);
static void skd_start(skd_device_t *);
static void skd_destroy_mutex(skd_device_t *skdev);
static void skd_enable_interrupts(struct skd_device *);
static void skd_request_fn_not_online(skd_device_t *skdev);
static void skd_send_internal_skspcl(struct skd_device *,
struct skd_special_context *, uint8_t);
static void skd_queue(skd_device_t *, skd_buf_private_t *);
static void *skd_alloc_dma_mem(skd_device_t *, dma_mem_t *, uint8_t);
static void skd_release_intr(skd_device_t *skdev);
static void skd_isr_fwstate(struct skd_device *skdev);
static void skd_isr_msg_from_dev(struct skd_device *skdev);
static void skd_soft_reset(struct skd_device *skdev);
static void skd_refresh_device_data(struct skd_device *skdev);
static void skd_update_props(skd_device_t *, dev_info_t *);
static void skd_end_request_abnormal(struct skd_device *, skd_buf_private_t *,
int, int);
static char *skd_pci_info(struct skd_device *skdev, char *str, size_t len);
static skd_buf_private_t *skd_get_queued_pbuf(skd_device_t *);
static void skd_bd_driveinfo(void *arg, bd_drive_t *drive);
static int skd_bd_mediainfo(void *arg, bd_media_t *media);
static int skd_bd_read(void *arg, bd_xfer_t *xfer);
static int skd_bd_write(void *arg, bd_xfer_t *xfer);
static int skd_devid_init(void *arg, dev_info_t *, ddi_devid_t *);
static bd_ops_t skd_bd_ops = {
BD_OPS_VERSION_0,
skd_bd_driveinfo,
skd_bd_mediainfo,
skd_devid_init,
NULL, /* sync_cache */
skd_bd_read,
skd_bd_write,
};
static ddi_device_acc_attr_t dev_acc_attr = {
DDI_DEVICE_ATTR_V0,
DDI_STRUCTURE_LE_ACC,
DDI_STRICTORDER_ACC
};
/*
* Solaris module loading/unloading structures
*/
struct dev_ops skd_dev_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt */
ddi_no_info, /* getinfo */
nulldev, /* identify */
nulldev, /* probe */
skd_attach, /* attach */
skd_detach, /* detach */
nodev, /* reset */
NULL, /* char/block ops */
NULL, /* bus operations */
NULL, /* power management */
skd_sys_quiesce_dev /* quiesce */
};
static struct modldrv modldrv = {
&mod_driverops, /* type of module: driver */
"sTec skd v" DRV_VER_COMPL, /* name of module */
&skd_dev_ops /* driver dev_ops */
};
static struct modlinkage modlinkage = {
MODREV_1,
&modldrv,
NULL
};
/*
* sTec-required wrapper for debug printing.
*/
/*PRINTFLIKE2*/
static inline void
Dcmn_err(int lvl, const char *fmt, ...)
{
va_list ap;
if (skd_dbg_level == 0)
return;
va_start(ap, fmt);
vcmn_err(lvl, fmt, ap);
va_end(ap);
}
/*
* Solaris module loading/unloading routines
*/
/*
*
* Name: _init, performs initial installation
*
* Inputs: None.
*
* Returns: Returns the value returned by the ddi_softstate_init function
* on a failure to create the device state structure or the result
* of the module install routines.
*
*/
int
_init(void)
{
int rval = 0;
int tgts = 0;
tgts |= 0x02;
tgts |= 0x08; /* In #ifdef NEXENTA block from original sTec drop. */
/*
* drv_usectohz() is a function, so can't initialize it at
* instantiation.
*/
skd_timer_ticks = drv_usectohz(1000000);
Dcmn_err(CE_NOTE,
"<# Installing skd Driver dbg-lvl=%d %s %x>",
skd_dbg_level, DRV_BUILD_ID, tgts);
rval = ddi_soft_state_init(&skd_state, sizeof (skd_device_t), 0);
if (rval != DDI_SUCCESS)
return (rval);
bd_mod_init(&skd_dev_ops);
rval = mod_install(&modlinkage);
if (rval != DDI_SUCCESS) {
ddi_soft_state_fini(&skd_state);
bd_mod_fini(&skd_dev_ops);
}
return (rval);
}
/*
*
* Name: _info, returns information about loadable module.
*
* Inputs: modinfo, pointer to module information structure.
*
* Returns: Value returned by mod_info().
*
*/
int
_info(struct modinfo *modinfop)
{
return (mod_info(&modlinkage, modinfop));
}
/*
* _fini Prepares a module for unloading. It is called when the system
* wants to unload a module. If the module determines that it can
* be unloaded, then _fini() returns the value returned by
* mod_remove(). Upon successful return from _fini() no other
* routine in the module will be called before _init() is called.
*
* Inputs: None.
*
* Returns: DDI_SUCCESS or DDI_FAILURE.
*
*/
int
_fini(void)
{
int rval;
rval = mod_remove(&modlinkage);
if (rval == DDI_SUCCESS) {
ddi_soft_state_fini(&skd_state);
bd_mod_fini(&skd_dev_ops);
}
return (rval);
}
/*
* Solaris Register read/write routines
*/
/*
*
* Name: skd_reg_write64, writes a 64-bit value to specified address
*
* Inputs: skdev - device state structure.
* val - 64-bit value to be written.
* offset - offset from PCI base address.
*
* Returns: Nothing.
*
*/
/*
* Local vars are to keep lint silent. Any compiler worth its weight will
* optimize it all right out...
*/
static inline void
skd_reg_write64(struct skd_device *skdev, uint64_t val, uint32_t offset)
{
uint64_t *addr;
ASSERT((offset & 0x7) == 0);
/* LINTED */
addr = (uint64_t *)(skdev->dev_iobase + offset);
ddi_put64(skdev->dev_handle, addr, val);
}
/*
*
* Name: skd_reg_read32, reads a 32-bit value to specified address
*
* Inputs: skdev - device state structure.
* offset - offset from PCI base address.
*
* Returns: val, 32-bit value read from specified PCI address.
*
*/
static inline uint32_t
skd_reg_read32(struct skd_device *skdev, uint32_t offset)
{
uint32_t *addr;
ASSERT((offset & 0x3) == 0);
/* LINTED */
addr = (uint32_t *)(skdev->dev_iobase + offset);
return (ddi_get32(skdev->dev_handle, addr));
}
/*
*
* Name: skd_reg_write32, writes a 32-bit value to specified address
*
* Inputs: skdev - device state structure.
* val - value to be written.
* offset - offset from PCI base address.
*
* Returns: Nothing.
*
*/
static inline void
skd_reg_write32(struct skd_device *skdev, uint32_t val, uint32_t offset)
{
uint32_t *addr;
ASSERT((offset & 0x3) == 0);
/* LINTED */
addr = (uint32_t *)(skdev->dev_iobase + offset);
ddi_put32(skdev->dev_handle, addr, val);
}
/*
* Solaris skd routines
*/
/*
*
* Name: skd_name, generates the name of the driver.
*
* Inputs: skdev - device state structure
*
* Returns: char pointer to generated driver name.
*
*/
static const char *
skd_name(struct skd_device *skdev)
{
(void) snprintf(skdev->id_str, sizeof (skdev->id_str), "%s:", DRV_NAME);
return (skdev->id_str);
}
/*
*
* Name: skd_pci_find_capability, searches the PCI capability
* list for the specified capability.
*
* Inputs: skdev - device state structure.
* cap - capability sought.
*
* Returns: Returns position where capability was found.
* If not found, returns zero.
*
*/
static int
skd_pci_find_capability(struct skd_device *skdev, int cap)
{
uint16_t status;
uint8_t pos, id, hdr;
int ttl = 48;
status = pci_config_get16(skdev->pci_handle, PCI_CONF_STAT);
if (!(status & PCI_STAT_CAP))
return (0);
hdr = pci_config_get8(skdev->pci_handle, PCI_CONF_HEADER);
if ((hdr & PCI_HEADER_TYPE_M) != 0)
return (0);
pos = pci_config_get8(skdev->pci_handle, PCI_CONF_CAP_PTR);
while (ttl-- && pos >= 0x40) {
pos &= ~3;
id = pci_config_get8(skdev->pci_handle, pos+PCI_CAP_ID);
if (id == 0xff)
break;
if (id == cap)
return (pos);
pos = pci_config_get8(skdev->pci_handle, pos+PCI_CAP_NEXT_PTR);
}
return (0);
}
/*
*
* Name: skd_io_done, called to conclude an I/O operation.
*
* Inputs: skdev - device state structure.
* pbuf - I/O request
* error - contain error value.
* mode - debug only.
*
* Returns: Nothing.
*
*/
static void
skd_io_done(skd_device_t *skdev, skd_buf_private_t *pbuf,
int error, int mode)
{
bd_xfer_t *xfer;
ASSERT(pbuf != NULL);
xfer = pbuf->x_xfer;
switch (mode) {
case SKD_IODONE_WIOC:
skdev->iodone_wioc++;
break;
case SKD_IODONE_WNIOC:
skdev->iodone_wnioc++;
break;
case SKD_IODONE_WDEBUG:
skdev->iodone_wdebug++;
break;
default:
skdev->iodone_unknown++;
}
if (error) {
skdev->ios_errors++;
cmn_err(CE_WARN,
"!%s:skd_io_done:ERR=%d %lld-%ld %s", skdev->name,
error, xfer->x_blkno, xfer->x_nblks,
(pbuf->dir & B_READ) ? "Read" : "Write");
}
kmem_free(pbuf, sizeof (skd_buf_private_t));
bd_xfer_done(xfer, error);
}
/*
* QUIESCE DEVICE
*/
/*
*
* Name: skd_sys_quiesce_dev, quiets the device
*
* Inputs: dip - dev info strucuture
*
* Returns: Zero.
*
*/
static int
skd_sys_quiesce_dev(dev_info_t *dip)
{
skd_device_t *skdev;
skdev = ddi_get_soft_state(skd_state, ddi_get_instance(dip));
/* make sure Dcmn_err() doesn't actually print anything */
skd_dbg_level = 0;
skd_disable_interrupts(skdev);
skd_soft_reset(skdev);
return (0);
}
/*
*
* Name: skd_quiesce_dev, quiets the device, but doesn't really do much.
*
* Inputs: skdev - Device state.
*
* Returns: -EINVAL if device is not in proper state otherwise
* returns zero.
*
*/
static int
skd_quiesce_dev(skd_device_t *skdev)
{
int rc = 0;
if (skd_dbg_level)
Dcmn_err(CE_NOTE, "skd_quiece_dev:");
switch (skdev->state) {
case SKD_DRVR_STATE_BUSY:
case SKD_DRVR_STATE_BUSY_IMMINENT:
Dcmn_err(CE_NOTE, "%s: stopping queue", skdev->name);
break;
case SKD_DRVR_STATE_ONLINE:
case SKD_DRVR_STATE_STOPPING:
case SKD_DRVR_STATE_SYNCING:
case SKD_DRVR_STATE_PAUSING:
case SKD_DRVR_STATE_PAUSED:
case SKD_DRVR_STATE_STARTING:
case SKD_DRVR_STATE_RESTARTING:
case SKD_DRVR_STATE_RESUMING:
default:
rc = -EINVAL;
cmn_err(CE_NOTE, "state [%d] not implemented", skdev->state);
}
return (rc);
}
/*
* UNQUIESCE DEVICE:
* Note: Assumes lock is held to protect device state.
*/
/*
*
* Name: skd_unquiesce_dev, awkens the device
*
* Inputs: skdev - Device state.
*
* Returns: -EINVAL if device is not in proper state otherwise
* returns zero.
*
*/
static int
skd_unquiesce_dev(struct skd_device *skdev)
{
Dcmn_err(CE_NOTE, "skd_unquiece_dev:");
skd_log_skdev(skdev, "unquiesce");
if (skdev->state == SKD_DRVR_STATE_ONLINE) {
Dcmn_err(CE_NOTE, "**** device already ONLINE");
return (0);
}
if (skdev->drive_state != FIT_SR_DRIVE_ONLINE) {
/*
* If there has been an state change to other than
* ONLINE, we will rely on controller state change
* to come back online and restart the queue.
* The BUSY state means that driver is ready to
* continue normal processing but waiting for controller
* to become available.
*/
skdev->state = SKD_DRVR_STATE_BUSY;
Dcmn_err(CE_NOTE, "drive BUSY state\n");
return (0);
}
/*
* Drive just come online, driver is either in startup,
* paused performing a task, or bust waiting for hardware.
*/
switch (skdev->state) {
case SKD_DRVR_STATE_PAUSED:
case SKD_DRVR_STATE_BUSY:
case SKD_DRVR_STATE_BUSY_IMMINENT:
case SKD_DRVR_STATE_BUSY_ERASE:
case SKD_DRVR_STATE_STARTING:
case SKD_DRVR_STATE_RESTARTING:
case SKD_DRVR_STATE_FAULT:
case SKD_DRVR_STATE_IDLE:
case SKD_DRVR_STATE_LOAD:
skdev->state = SKD_DRVR_STATE_ONLINE;
Dcmn_err(CE_NOTE, "%s: sTec s1120 ONLINE", skdev->name);
Dcmn_err(CE_NOTE, "%s: Starting request queue", skdev->name);
Dcmn_err(CE_NOTE,
"%s: queue depth limit=%d hard=%d soft=%d lowat=%d",
skdev->name,
skdev->queue_depth_limit,
skdev->hard_queue_depth_limit,
skdev->soft_queue_depth_limit,
skdev->queue_depth_lowat);
skdev->gendisk_on = 1;
cv_signal(&skdev->cv_waitq);
break;
case SKD_DRVR_STATE_DISAPPEARED:
default:
cmn_err(CE_NOTE, "**** driver state %d, not implemented \n",
skdev->state);
return (-EBUSY);
}
return (0);
}
/*
* READ/WRITE REQUESTS
*/
/*
*
* Name: skd_blkdev_preop_sg_list, builds the S/G list from info
* passed in by the blkdev driver.
*
* Inputs: skdev - device state structure.
* skreq - request structure.
* sg_byte_count - data transfer byte count.
*
* Returns: Nothing.
*
*/
/*ARGSUSED*/
static void
skd_blkdev_preop_sg_list(struct skd_device *skdev,
struct skd_request_context *skreq, uint32_t *sg_byte_count)
{
bd_xfer_t *xfer;
skd_buf_private_t *pbuf;
int i, bcount = 0;
uint_t n_sg;
*sg_byte_count = 0;
ASSERT(skreq->sg_data_dir == SKD_DATA_DIR_HOST_TO_CARD ||
skreq->sg_data_dir == SKD_DATA_DIR_CARD_TO_HOST);
pbuf = skreq->pbuf;
ASSERT(pbuf != NULL);
xfer = pbuf->x_xfer;
n_sg = xfer->x_ndmac;
ASSERT(n_sg <= skdev->sgs_per_request);
skreq->n_sg = n_sg;
skreq->io_dma_handle = xfer->x_dmah;
skreq->total_sg_bcount = 0;
for (i = 0; i < n_sg; i++) {
ddi_dma_cookie_t *cookiep = &xfer->x_dmac;
struct fit_sg_descriptor *sgd;
uint32_t cnt = (uint32_t)cookiep->dmac_size;
bcount += cnt;
sgd = &skreq->sksg_list[i];
sgd->control = FIT_SGD_CONTROL_NOT_LAST;
sgd->byte_count = cnt;
sgd->host_side_addr = cookiep->dmac_laddress;
sgd->dev_side_addr = 0; /* not used */
*sg_byte_count += cnt;
skreq->total_sg_bcount += cnt;
if ((i + 1) != n_sg)
ddi_dma_nextcookie(skreq->io_dma_handle, &xfer->x_dmac);
}
skreq->sksg_list[n_sg - 1].next_desc_ptr = 0LL;
skreq->sksg_list[n_sg - 1].control = FIT_SGD_CONTROL_LAST;
(void) ddi_dma_sync(skreq->sksg_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORDEV);
}
/*
*
* Name: skd_blkdev_postop_sg_list, deallocates DMA
*
* Inputs: skdev - device state structure.
* skreq - skreq data structure.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_blkdev_postop_sg_list(struct skd_device *skdev,
struct skd_request_context *skreq)
{
/*
* restore the next ptr for next IO request so we
* don't have to set it every time.
*/
skreq->sksg_list[skreq->n_sg - 1].next_desc_ptr =
skreq->sksg_dma_address.cookies->dmac_laddress +
((skreq->n_sg) * sizeof (struct fit_sg_descriptor));
}
/*
*
* Name: skd_start, initiates an I/O.
*
* Inputs: skdev - device state structure.
*
* Returns: EAGAIN if devicfe is not ONLINE.
* On error, if the caller is the blkdev driver, return
* the error value. Otherwise, return zero.
*
*/
/* Upstream common source with other platforms. */
static void
skd_start(skd_device_t *skdev)
{
struct skd_fitmsg_context *skmsg = NULL;
struct fit_msg_hdr *fmh = NULL;
struct skd_request_context *skreq = NULL;
struct waitqueue *waitq = &skdev->waitqueue;
struct skd_scsi_request *scsi_req;
skd_buf_private_t *pbuf = NULL;
int bcount;
uint32_t lba;
uint32_t count;
uint32_t timo_slot;
void *cmd_ptr;
uint32_t sg_byte_count = 0;
/*
* Stop conditions:
* - There are no more native requests
* - There are already the maximum number of requests is progress
* - There are no more skd_request_context entries
* - There are no more FIT msg buffers
*/
for (;;) {
/* Are too many requests already in progress? */
if (skdev->queue_depth_busy >= skdev->queue_depth_limit) {
Dcmn_err(CE_NOTE, "qdepth %d, limit %d\n",
skdev->queue_depth_busy,
skdev->queue_depth_limit);
break;
}
WAITQ_LOCK(skdev);
if (SIMPLEQ_EMPTY(waitq)) {
WAITQ_UNLOCK(skdev);
break;
}
/* Is a skd_request_context available? */
skreq = skdev->skreq_free_list;
if (skreq == NULL) {
WAITQ_UNLOCK(skdev);
break;
}
ASSERT(skreq->state == SKD_REQ_STATE_IDLE);
ASSERT((skreq->id & SKD_ID_INCR) == 0);
skdev->skreq_free_list = skreq->next;
skreq->state = SKD_REQ_STATE_BUSY;
skreq->id += SKD_ID_INCR;
/* Start a new FIT msg if there is none in progress. */
if (skmsg == NULL) {
/* Are there any FIT msg buffers available? */
skmsg = skdev->skmsg_free_list;
if (skmsg == NULL) {
WAITQ_UNLOCK(skdev);
break;
}
ASSERT(skmsg->state == SKD_MSG_STATE_IDLE);
ASSERT((skmsg->id & SKD_ID_INCR) == 0);
skdev->skmsg_free_list = skmsg->next;
skmsg->state = SKD_MSG_STATE_BUSY;
skmsg->id += SKD_ID_INCR;
/* Initialize the FIT msg header */
fmh = (struct fit_msg_hdr *)skmsg->msg_buf64;
bzero(fmh, sizeof (*fmh)); /* Too expensive */
fmh->protocol_id = FIT_PROTOCOL_ID_SOFIT;
skmsg->length = sizeof (struct fit_msg_hdr);
}
/*
* At this point we are committed to either start or reject
* the native request. Note that a FIT msg may have just been
* started but contains no SoFIT requests yet.
* Now - dequeue pbuf.
*/
pbuf = skd_get_queued_pbuf(skdev);
WAITQ_UNLOCK(skdev);
skreq->pbuf = pbuf;
lba = pbuf->x_xfer->x_blkno;
count = pbuf->x_xfer->x_nblks;
skreq->did_complete = 0;
skreq->fitmsg_id = skmsg->id;
Dcmn_err(CE_NOTE,
"pbuf=%p lba=%u(0x%x) count=%u(0x%x) dir=%x\n",
(void *)pbuf, lba, lba, count, count, pbuf->dir);
/*
* Transcode the request.
*/
cmd_ptr = &skmsg->msg_buf[skmsg->length];
bzero(cmd_ptr, 32); /* This is too expensive */
scsi_req = cmd_ptr;
scsi_req->hdr.tag = skreq->id;
scsi_req->hdr.sg_list_dma_address =
cpu_to_be64(skreq->sksg_dma_address.cookies->dmac_laddress);
scsi_req->cdb[1] = 0;
scsi_req->cdb[2] = (lba & 0xff000000) >> 24;
scsi_req->cdb[3] = (lba & 0xff0000) >> 16;
scsi_req->cdb[4] = (lba & 0xff00) >> 8;
scsi_req->cdb[5] = (lba & 0xff);
scsi_req->cdb[6] = 0;
scsi_req->cdb[7] = (count & 0xff00) >> 8;
scsi_req->cdb[8] = count & 0xff;
scsi_req->cdb[9] = 0;
if (pbuf->dir & B_READ) {
scsi_req->cdb[0] = 0x28;
skreq->sg_data_dir = SKD_DATA_DIR_CARD_TO_HOST;
} else {
scsi_req->cdb[0] = 0x2a;
skreq->sg_data_dir = SKD_DATA_DIR_HOST_TO_CARD;
}
skd_blkdev_preop_sg_list(skdev, skreq, &sg_byte_count);
scsi_req->hdr.sg_list_len_bytes = cpu_to_be32(sg_byte_count);
bcount = (sg_byte_count + 511) / 512;
scsi_req->cdb[7] = (bcount & 0xff00) >> 8;
scsi_req->cdb[8] = bcount & 0xff;
Dcmn_err(CE_NOTE,
"skd_start: pbuf=%p skreq->id=%x opc=%x ====>>>>>",
(void *)pbuf, skreq->id, *scsi_req->cdb);
skmsg->length += sizeof (struct skd_scsi_request);
fmh->num_protocol_cmds_coalesced++;
/*
* Update the active request counts.
* Capture the timeout timestamp.
*/
skreq->timeout_stamp = skdev->timeout_stamp;
timo_slot = skreq->timeout_stamp & SKD_TIMEOUT_SLOT_MASK;
atomic_inc_32(&skdev->timeout_slot[timo_slot]);
atomic_inc_32(&skdev->queue_depth_busy);
Dcmn_err(CE_NOTE, "req=0x%x busy=%d timo_slot=%d",
skreq->id, skdev->queue_depth_busy, timo_slot);
/*
* If the FIT msg buffer is full send it.
*/
if (skmsg->length >= SKD_N_FITMSG_BYTES ||
fmh->num_protocol_cmds_coalesced >= skd_max_req_per_msg) {
atomic_inc_64(&skdev->active_cmds);
pbuf->skreq = skreq;
skdev->fitmsg_sent1++;
skd_send_fitmsg(skdev, skmsg);
skmsg = NULL;
fmh = NULL;
}
}
/*
* Is a FIT msg in progress? If it is empty put the buffer back
* on the free list. If it is non-empty send what we got.
* This minimizes latency when there are fewer requests than
* what fits in a FIT msg.
*/
if (skmsg != NULL) {
ASSERT(skmsg->length > sizeof (struct fit_msg_hdr));
Dcmn_err(CE_NOTE, "sending msg=%p, len %d",
(void *)skmsg, skmsg->length);
skdev->active_cmds++;
skdev->fitmsg_sent2++;
skd_send_fitmsg(skdev, skmsg);
}
}
/*
*
* Name: skd_end_request
*
* Inputs: skdev - device state structure.
* skreq - request structure.
* error - I/O error value.
*
* Returns: Nothing.
*
*/
static void
skd_end_request(struct skd_device *skdev,
struct skd_request_context *skreq, int error)
{
skdev->ios_completed++;
skd_io_done(skdev, skreq->pbuf, error, SKD_IODONE_WIOC);
skreq->pbuf = NULL;
skreq->did_complete = 1;
}
/*
*
* Name: skd_end_request_abnormal
*
* Inputs: skdev - device state structure.
* pbuf - I/O request.
* error - I/O error value.
* mode - debug
*
* Returns: Nothing.
*
*/
static void
skd_end_request_abnormal(skd_device_t *skdev, skd_buf_private_t *pbuf,
int error, int mode)
{
skd_io_done(skdev, pbuf, error, mode);
}
/*
*
* Name: skd_request_fn_not_online, handles the condition
* of the device not being online.
*
* Inputs: skdev - device state structure.
*
* Returns: nothing (void).
*
*/
static void
skd_request_fn_not_online(skd_device_t *skdev)
{
int error;
skd_buf_private_t *pbuf;
ASSERT(skdev->state != SKD_DRVR_STATE_ONLINE);
skd_log_skdev(skdev, "req_not_online");
switch (skdev->state) {
case SKD_DRVR_STATE_PAUSING:
case SKD_DRVR_STATE_PAUSED:
case SKD_DRVR_STATE_STARTING:
case SKD_DRVR_STATE_RESTARTING:
case SKD_DRVR_STATE_WAIT_BOOT:
/*
* In case of starting, we haven't started the queue,
* so we can't get here... but requests are
* possibly hanging out waiting for us because we
* reported the dev/skd/0 already. They'll wait
* forever if connect doesn't complete.
* What to do??? delay dev/skd/0 ??
*/
case SKD_DRVR_STATE_BUSY:
case SKD_DRVR_STATE_BUSY_IMMINENT:
case SKD_DRVR_STATE_BUSY_ERASE:
case SKD_DRVR_STATE_DRAINING_TIMEOUT:
return;
case SKD_DRVR_STATE_BUSY_SANITIZE:
case SKD_DRVR_STATE_STOPPING:
case SKD_DRVR_STATE_SYNCING:
case SKD_DRVR_STATE_FAULT:
case SKD_DRVR_STATE_DISAPPEARED:
default:
error = -EIO;
break;
}
/*
* If we get here, terminate all pending block requeusts
* with EIO and any scsi pass thru with appropriate sense
*/
ASSERT(WAITQ_LOCK_HELD(skdev));
if (SIMPLEQ_EMPTY(&skdev->waitqueue))
return;
while ((pbuf = skd_get_queued_pbuf(skdev)))
skd_end_request_abnormal(skdev, pbuf, error, SKD_IODONE_WNIOC);
cv_signal(&skdev->cv_waitq);
}
/*
* TIMER
*/
static void skd_timer_tick_not_online(struct skd_device *skdev);
/*
*
* Name: skd_timer_tick, monitors requests for timeouts.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_timer_tick(skd_device_t *skdev)
{
uint32_t timo_slot;
skdev->timer_active = 1;
if (skdev->state != SKD_DRVR_STATE_ONLINE) {
skd_timer_tick_not_online(skdev);
goto timer_func_out;
}
skdev->timeout_stamp++;
timo_slot = skdev->timeout_stamp & SKD_TIMEOUT_SLOT_MASK;
/*
* All requests that happened during the previous use of
* this slot should be done by now. The previous use was
* over 7 seconds ago.
*/
if (skdev->timeout_slot[timo_slot] == 0) {
goto timer_func_out;
}
/* Something is overdue */
Dcmn_err(CE_NOTE, "found %d timeouts, draining busy=%d",
skdev->timeout_slot[timo_slot],
skdev->queue_depth_busy);
skdev->timer_countdown = SKD_TIMER_SECONDS(3);
skdev->state = SKD_DRVR_STATE_DRAINING_TIMEOUT;
skdev->timo_slot = timo_slot;
timer_func_out:
skdev->timer_active = 0;
}
/*
*
* Name: skd_timer_tick_not_online, handles various device
* state transitions.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_timer_tick_not_online(struct skd_device *skdev)
{
Dcmn_err(CE_NOTE, "skd_skd_timer_tick_not_online: state=%d tmo=%d",
skdev->state, skdev->timer_countdown);
ASSERT(skdev->state != SKD_DRVR_STATE_ONLINE);
switch (skdev->state) {
case SKD_DRVR_STATE_IDLE:
case SKD_DRVR_STATE_LOAD:
break;
case SKD_DRVR_STATE_BUSY_SANITIZE:
cmn_err(CE_WARN, "!drive busy sanitize[%x], driver[%x]\n",
skdev->drive_state, skdev->state);
break;
case SKD_DRVR_STATE_BUSY:
case SKD_DRVR_STATE_BUSY_IMMINENT:
case SKD_DRVR_STATE_BUSY_ERASE:
Dcmn_err(CE_NOTE, "busy[%x], countdown=%d\n",
skdev->state, skdev->timer_countdown);
if (skdev->timer_countdown > 0) {
skdev->timer_countdown--;
return;
}
cmn_err(CE_WARN, "!busy[%x], timedout=%d, restarting device.",
skdev->state, skdev->timer_countdown);
skd_restart_device(skdev);
break;
case SKD_DRVR_STATE_WAIT_BOOT:
case SKD_DRVR_STATE_STARTING:
if (skdev->timer_countdown > 0) {
skdev->timer_countdown--;
return;
}
/*
* For now, we fault the drive. Could attempt resets to
* revcover at some point.
*/
skdev->state = SKD_DRVR_STATE_FAULT;
cmn_err(CE_WARN, "!(%s): DriveFault Connect Timeout (%x)",
skd_name(skdev), skdev->drive_state);
/* start the queue so we can respond with error to requests */
skd_start(skdev);
/* wakeup anyone waiting for startup complete */
skdev->gendisk_on = -1;
cv_signal(&skdev->cv_waitq);
break;
case SKD_DRVR_STATE_PAUSING:
case SKD_DRVR_STATE_PAUSED:
break;
case SKD_DRVR_STATE_DRAINING_TIMEOUT:
cmn_err(CE_WARN,
"!%s: draining busy [%d] tick[%d] qdb[%d] tmls[%d]\n",
skdev->name,
skdev->timo_slot,
skdev->timer_countdown,
skdev->queue_depth_busy,
skdev->timeout_slot[skdev->timo_slot]);
/* if the slot has cleared we can let the I/O continue */
if (skdev->timeout_slot[skdev->timo_slot] == 0) {
Dcmn_err(CE_NOTE, "Slot drained, starting queue.");
skdev->state = SKD_DRVR_STATE_ONLINE;
skd_start(skdev);
return;
}
if (skdev->timer_countdown > 0) {
skdev->timer_countdown--;
return;
}
skd_restart_device(skdev);
break;
case SKD_DRVR_STATE_RESTARTING:
if (skdev->timer_countdown > 0) {
skdev->timer_countdown--;
return;
}
/*
* For now, we fault the drive. Could attempt resets to
* revcover at some point.
*/
skdev->state = SKD_DRVR_STATE_FAULT;
cmn_err(CE_WARN, "!(%s): DriveFault Reconnect Timeout (%x)\n",
skd_name(skdev), skdev->drive_state);
/*
* Recovering does two things:
* 1. completes IO with error
* 2. reclaims dma resources
* When is it safe to recover requests?
* - if the drive state is faulted
* - if the state is still soft reset after out timeout
* - if the drive registers are dead (state = FF)
*/
if ((skdev->drive_state == FIT_SR_DRIVE_SOFT_RESET) ||
(skdev->drive_state == FIT_SR_DRIVE_FAULT) ||
(skdev->drive_state == FIT_SR_DRIVE_STATE_MASK)) {
/*
* It never came out of soft reset. Try to
* recover the requests and then let them
* fail. This is to mitigate hung processes.
*
* Acquire the interrupt lock since these lists are
* manipulated by interrupt handlers.
*/
ASSERT(!WAITQ_LOCK_HELD(skdev));
INTR_LOCK(skdev);
skd_recover_requests(skdev);
INTR_UNLOCK(skdev);
}
/* start the queue so we can respond with error to requests */
skd_start(skdev);
/* wakeup anyone waiting for startup complete */
skdev->gendisk_on = -1;
cv_signal(&skdev->cv_waitq);
break;
case SKD_DRVR_STATE_RESUMING:
case SKD_DRVR_STATE_STOPPING:
case SKD_DRVR_STATE_SYNCING:
case SKD_DRVR_STATE_FAULT:
case SKD_DRVR_STATE_DISAPPEARED:
default:
break;
}
}
/*
*
* Name: skd_timer, kicks off the timer processing.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_timer(void *arg)
{
skd_device_t *skdev = (skd_device_t *)arg;
/* Someone set us to 0, don't bother rescheduling. */
ADAPTER_STATE_LOCK(skdev);
if (skdev->skd_timer_timeout_id != 0) {
ADAPTER_STATE_UNLOCK(skdev);
/* Pardon the drop-and-then-acquire logic here. */
skd_timer_tick(skdev);
ADAPTER_STATE_LOCK(skdev);
/* Restart timer, if not being stopped. */
if (skdev->skd_timer_timeout_id != 0) {
skdev->skd_timer_timeout_id =
timeout(skd_timer, arg, skd_timer_ticks);
}
}
ADAPTER_STATE_UNLOCK(skdev);
}
/*
*
* Name: skd_start_timer, kicks off the 1-second timer.
*
* Inputs: skdev - device state structure.
*
* Returns: Zero.
*
*/
static void
skd_start_timer(struct skd_device *skdev)
{
/* Start one second driver timer. */
ADAPTER_STATE_LOCK(skdev);
ASSERT(skdev->skd_timer_timeout_id == 0);
/*
* Do first "timeout tick" right away, but not in this
* thread.
*/
skdev->skd_timer_timeout_id = timeout(skd_timer, skdev, 1);
ADAPTER_STATE_UNLOCK(skdev);
}
/*
* INTERNAL REQUESTS -- generated by driver itself
*/
/*
*
* Name: skd_format_internal_skspcl, setups the internal
* FIT request message.
*
* Inputs: skdev - device state structure.
*
* Returns: One.
*
*/
static int
skd_format_internal_skspcl(struct skd_device *skdev)
{
struct skd_special_context *skspcl = &skdev->internal_skspcl;
struct fit_sg_descriptor *sgd = &skspcl->req.sksg_list[0];
struct fit_msg_hdr *fmh;
uint64_t dma_address;
struct skd_scsi_request *scsi;
fmh = (struct fit_msg_hdr *)&skspcl->msg_buf64[0];
fmh->protocol_id = FIT_PROTOCOL_ID_SOFIT;
fmh->num_protocol_cmds_coalesced = 1;
/* Instead of 64-bytes in, use 8-(64-bit-words) for linted alignment. */
scsi = (struct skd_scsi_request *)&skspcl->msg_buf64[8];
bzero(scsi, sizeof (*scsi));
dma_address = skspcl->req.sksg_dma_address.cookies->_dmu._dmac_ll;
scsi->hdr.sg_list_dma_address = cpu_to_be64(dma_address);
sgd->control = FIT_SGD_CONTROL_LAST;
sgd->byte_count = 0;
sgd->host_side_addr = skspcl->db_dma_address.cookies->_dmu._dmac_ll;
sgd->dev_side_addr = 0; /* not used */
sgd->next_desc_ptr = 0LL;
return (1);
}
/*
*
* Name: skd_send_internal_skspcl, send internal requests to
* the hardware.
*
* Inputs: skdev - device state structure.
* skspcl - request structure
* opcode - just what it says
*
* Returns: Nothing.
*
*/
void
skd_send_internal_skspcl(struct skd_device *skdev,
struct skd_special_context *skspcl, uint8_t opcode)
{
struct fit_sg_descriptor *sgd = &skspcl->req.sksg_list[0];
struct skd_scsi_request *scsi;
if (SKD_REQ_STATE_IDLE != skspcl->req.state) {
/*
* A refresh is already in progress.
* Just wait for it to finish.
*/
return;
}
ASSERT(0 == (skspcl->req.id & SKD_ID_INCR));
skspcl->req.state = SKD_REQ_STATE_BUSY;
skspcl->req.id += SKD_ID_INCR;
/* Instead of 64-bytes in, use 8-(64-bit-words) for linted alignment. */
scsi = (struct skd_scsi_request *)&skspcl->msg_buf64[8];
scsi->hdr.tag = skspcl->req.id;
Dcmn_err(CE_NOTE, "internal skspcl: opcode=%x req.id=%x ==========>",
opcode, skspcl->req.id);
switch (opcode) {
case TEST_UNIT_READY:
scsi->cdb[0] = TEST_UNIT_READY;
scsi->cdb[1] = 0x00;
scsi->cdb[2] = 0x00;
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x00;
scsi->cdb[5] = 0x00;
sgd->byte_count = 0;
scsi->hdr.sg_list_len_bytes = 0;
break;
case READ_CAPACITY_EXT:
scsi->cdb[0] = READ_CAPACITY_EXT;
scsi->cdb[1] = 0x10;
scsi->cdb[2] = 0x00;
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x00;
scsi->cdb[5] = 0x00;
scsi->cdb[6] = 0x00;
scsi->cdb[7] = 0x00;
scsi->cdb[8] = 0x00;
scsi->cdb[9] = 0x00;
scsi->cdb[10] = 0x00;
scsi->cdb[11] = 0x00;
scsi->cdb[12] = 0x00;
scsi->cdb[13] = 0x20;
scsi->cdb[14] = 0x00;
scsi->cdb[15] = 0x00;
sgd->byte_count = SKD_N_READ_CAP_EXT_BYTES;
scsi->hdr.sg_list_len_bytes = cpu_to_be32(sgd->byte_count);
break;
case 0x28:
(void) memset(skspcl->data_buf, 0x65, SKD_N_INTERNAL_BYTES);
scsi->cdb[0] = 0x28;
scsi->cdb[1] = 0x00;
scsi->cdb[2] = 0x00;
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x00;
scsi->cdb[5] = 0x00;
scsi->cdb[6] = 0x00;
scsi->cdb[7] = 0x00;
scsi->cdb[8] = 0x01;
scsi->cdb[9] = 0x00;
sgd->byte_count = SKD_N_INTERNAL_BYTES;
scsi->hdr.sg_list_len_bytes = cpu_to_be32(SKD_N_INTERNAL_BYTES);
break;
case INQUIRY:
scsi->cdb[0] = INQUIRY;
scsi->cdb[1] = 0x01; /* evpd */
scsi->cdb[2] = 0x80; /* serial number page */
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x10;
scsi->cdb[5] = 0x00;
sgd->byte_count = 16; /* SKD_N_INQ_BYTES */;
scsi->hdr.sg_list_len_bytes = cpu_to_be32(sgd->byte_count);
break;
case INQUIRY2:
scsi->cdb[0] = INQUIRY;
scsi->cdb[1] = 0x00;
scsi->cdb[2] = 0x00; /* serial number page */
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x24;
scsi->cdb[5] = 0x00;
sgd->byte_count = 36; /* SKD_N_INQ_BYTES */;
scsi->hdr.sg_list_len_bytes = cpu_to_be32(sgd->byte_count);
break;
case SYNCHRONIZE_CACHE:
scsi->cdb[0] = SYNCHRONIZE_CACHE;
scsi->cdb[1] = 0x00;
scsi->cdb[2] = 0x00;
scsi->cdb[3] = 0x00;
scsi->cdb[4] = 0x00;
scsi->cdb[5] = 0x00;
scsi->cdb[6] = 0x00;
scsi->cdb[7] = 0x00;
scsi->cdb[8] = 0x00;
scsi->cdb[9] = 0x00;
sgd->byte_count = 0;
scsi->hdr.sg_list_len_bytes = 0;
break;
default:
ASSERT("Don't know what to send");
return;
}
skd_send_special_fitmsg(skdev, skspcl);
}
/*
*
* Name: skd_refresh_device_data, sends a TUR command.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_refresh_device_data(struct skd_device *skdev)
{
struct skd_special_context *skspcl = &skdev->internal_skspcl;
Dcmn_err(CE_NOTE, "refresh_device_data: state=%d", skdev->state);
skd_send_internal_skspcl(skdev, skspcl, TEST_UNIT_READY);
}
/*
*
* Name: skd_complete_internal, handles the completion of
* driver-initiated I/O requests.
*
* Inputs: skdev - device state structure.
* skcomp - completion structure.
* skerr - error structure.
* skspcl - request structure.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_complete_internal(struct skd_device *skdev,
volatile struct fit_completion_entry_v1 *skcomp,
volatile struct fit_comp_error_info *skerr,
struct skd_special_context *skspcl)
{
uint8_t *buf = skspcl->data_buf;
uint8_t status = 2;
/* Instead of 64-bytes in, use 8-(64-bit-words) for linted alignment. */
struct skd_scsi_request *scsi =
(struct skd_scsi_request *)&skspcl->msg_buf64[8];
ASSERT(skspcl == &skdev->internal_skspcl);
(void) ddi_dma_sync(skspcl->db_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORKERNEL);
(void) ddi_dma_sync(skspcl->mb_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORKERNEL);
Dcmn_err(CE_NOTE, "complete internal %x", scsi->cdb[0]);
skspcl->req.completion = *skcomp;
skspcl->req.state = SKD_REQ_STATE_IDLE;
skspcl->req.id += SKD_ID_INCR;
status = skspcl->req.completion.status;
Dcmn_err(CE_NOTE, "<<<<====== complete_internal: opc=%x", *scsi->cdb);
switch (scsi->cdb[0]) {
case TEST_UNIT_READY:
if (SAM_STAT_GOOD == status) {
skd_send_internal_skspcl(skdev, skspcl,
READ_CAPACITY_EXT);
} else {
if (skdev->state == SKD_DRVR_STATE_STOPPING) {
cmn_err(CE_WARN,
"!%s: TUR failed, don't send anymore"
"state 0x%x", skdev->name, skdev->state);
return;
}
Dcmn_err(CE_NOTE, "%s: TUR failed, retry skerr",
skdev->name);
skd_send_internal_skspcl(skdev, skspcl, 0x00);
}
break;
case READ_CAPACITY_EXT: {
uint64_t cap, Nblocks;
uint64_t xbuf[1];
skdev->read_cap_is_valid = 0;
if (SAM_STAT_GOOD == status) {
bcopy(buf, xbuf, 8);
cap = be64_to_cpu(*xbuf);
skdev->read_cap_last_lba = cap;
skdev->read_cap_blocksize =
(buf[8] << 24) | (buf[9] << 16) |
(buf[10] << 8) | buf[11];
cap *= skdev->read_cap_blocksize;
Dcmn_err(CE_NOTE, " Last LBA: %" PRIu64 " (0x%" PRIx64
"), blk sz: %d, Capacity: %" PRIu64 "GB\n",
skdev->read_cap_last_lba,
skdev->read_cap_last_lba,
skdev->read_cap_blocksize,
cap >> 30ULL);
Nblocks = skdev->read_cap_last_lba + 1;
skdev->Nblocks = Nblocks;
skdev->read_cap_is_valid = 1;
skd_send_internal_skspcl(skdev, skspcl, INQUIRY2);
} else {
Dcmn_err(CE_NOTE, "**** READCAP failed, retry TUR");
skd_send_internal_skspcl(skdev, skspcl,
TEST_UNIT_READY);
}
break;
}
case INQUIRY:
skdev->inquiry_is_valid = 0;
if (SAM_STAT_GOOD == status) {
skdev->inquiry_is_valid = 1;
if (scsi->cdb[1] == 0x1) {
bcopy(&buf[4], skdev->inq_serial_num, 12);
skdev->inq_serial_num[12] = '\0';
} else {
char *tmp = skdev->inq_vendor_id;
bcopy(&buf[8], tmp, 8);
tmp[8] = '\0';
tmp = skdev->inq_product_id;
bcopy(&buf[16], tmp, 16);
tmp[16] = '\0';
tmp = skdev->inq_product_rev;
bcopy(&buf[32], tmp, 4);
tmp[4] = '\0';
}
}
if (skdev->state != SKD_DRVR_STATE_ONLINE)
if (skd_unquiesce_dev(skdev) < 0)
cmn_err(CE_NOTE, "** failed, to ONLINE device");
break;
case SYNCHRONIZE_CACHE:
skdev->sync_done = (SAM_STAT_GOOD == status) ? 1 : -1;
cv_signal(&skdev->cv_waitq);
break;
default:
ASSERT("we didn't send this");
}
}
/*
* FIT MESSAGES
*/
/*
*
* Name: skd_send_fitmsg, send a FIT message to the hardware.
*
* Inputs: skdev - device state structure.
* skmsg - FIT message structure.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_send_fitmsg(struct skd_device *skdev,
struct skd_fitmsg_context *skmsg)
{
uint64_t qcmd;
struct fit_msg_hdr *fmh;
Dcmn_err(CE_NOTE, "msgbuf's DMA addr: 0x%" PRIx64 ", qdepth_busy=%d",
skmsg->mb_dma_address.cookies->dmac_laddress,
skdev->queue_depth_busy);
Dcmn_err(CE_NOTE, "msg_buf 0x%p, offset %x", (void *)skmsg->msg_buf,
skmsg->offset);
qcmd = skmsg->mb_dma_address.cookies->dmac_laddress;
qcmd |= FIT_QCMD_QID_NORMAL;
fmh = (struct fit_msg_hdr *)skmsg->msg_buf64;
skmsg->outstanding = fmh->num_protocol_cmds_coalesced;
if (skdev->dbg_level > 1) {
uint8_t *bp = skmsg->msg_buf;
int i;
for (i = 0; i < skmsg->length; i += 8) {
Dcmn_err(CE_NOTE, " msg[%2d] %02x %02x %02x %02x "
"%02x %02x %02x %02x",
i, bp[i + 0], bp[i + 1], bp[i + 2],
bp[i + 3], bp[i + 4], bp[i + 5],
bp[i + 6], bp[i + 7]);
if (i == 0) i = 64 - 8;
}
}
(void) ddi_dma_sync(skmsg->mb_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORDEV);
ASSERT(skmsg->length > sizeof (struct fit_msg_hdr));
if (skmsg->length > 256) {
qcmd |= FIT_QCMD_MSGSIZE_512;
} else if (skmsg->length > 128) {
qcmd |= FIT_QCMD_MSGSIZE_256;
} else if (skmsg->length > 64) {
qcmd |= FIT_QCMD_MSGSIZE_128;
}
skdev->ios_started++;
SKD_WRITEQ(skdev, qcmd, FIT_Q_COMMAND);
}
/*
*
* Name: skd_send_special_fitmsg, send a special FIT message
* to the hardware used driver-originated I/O requests.
*
* Inputs: skdev - device state structure.
* skspcl - skspcl structure.
*
* Returns: Nothing.
*
*/
static void
skd_send_special_fitmsg(struct skd_device *skdev,
struct skd_special_context *skspcl)
{
uint64_t qcmd;
Dcmn_err(CE_NOTE, "send_special_fitmsg: pt 1");
if (skdev->dbg_level > 1) {
uint8_t *bp = skspcl->msg_buf;
int i;
for (i = 0; i < SKD_N_SPECIAL_FITMSG_BYTES; i += 8) {
cmn_err(CE_NOTE,
" spcl[%2d] %02x %02x %02x %02x "
"%02x %02x %02x %02x\n", i,
bp[i + 0], bp[i + 1], bp[i + 2], bp[i + 3],
bp[i + 4], bp[i + 5], bp[i + 6], bp[i + 7]);
if (i == 0) i = 64 - 8;
}
for (i = 0; i < skspcl->req.n_sg; i++) {
struct fit_sg_descriptor *sgd =
&skspcl->req.sksg_list[i];
cmn_err(CE_NOTE, " sg[%d] count=%u ctrl=0x%x "
"addr=0x%" PRIx64 " next=0x%" PRIx64,
i, sgd->byte_count, sgd->control,
sgd->host_side_addr, sgd->next_desc_ptr);
}
}
(void) ddi_dma_sync(skspcl->mb_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORDEV);
(void) ddi_dma_sync(skspcl->db_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORDEV);
/*
* Special FIT msgs are always 128 bytes: a 64-byte FIT hdr
* and one 64-byte SSDI command.
*/
qcmd = skspcl->mb_dma_address.cookies->dmac_laddress;
qcmd |= FIT_QCMD_QID_NORMAL + FIT_QCMD_MSGSIZE_128;
SKD_WRITEQ(skdev, qcmd, FIT_Q_COMMAND);
}
/*
* COMPLETION QUEUE
*/
static void skd_complete_other(struct skd_device *skdev,
volatile struct fit_completion_entry_v1 *skcomp,
volatile struct fit_comp_error_info *skerr);
struct sns_info {
uint8_t type;
uint8_t stat;
uint8_t key;
uint8_t asc;
uint8_t ascq;
uint8_t mask;
enum skd_check_status_action action;
};
static struct sns_info skd_chkstat_table[] = {
/* Good */
{0x70, 0x02, RECOVERED_ERROR, 0, 0, 0x1c, SKD_CHECK_STATUS_REPORT_GOOD},
/* Smart alerts */
{0x70, 0x02, NO_SENSE, 0x0B, 0x00, 0x1E, /* warnings */
SKD_CHECK_STATUS_REPORT_SMART_ALERT},
{0x70, 0x02, NO_SENSE, 0x5D, 0x00, 0x1E, /* thresholds */
SKD_CHECK_STATUS_REPORT_SMART_ALERT},
{0x70, 0x02, RECOVERED_ERROR, 0x0B, 0x01, 0x1F, /* temp over trigger */
SKD_CHECK_STATUS_REPORT_SMART_ALERT},
/* Retry (with limits) */
{0x70, 0x02, ABORTED_COMMAND, 0, 0, 0x1C, /* DMA errors */
SKD_CHECK_STATUS_REQUEUE_REQUEST},
{0x70, 0x02, UNIT_ATTENTION, 0x0B, 0x00, 0x1E, /* warnings */
SKD_CHECK_STATUS_REQUEUE_REQUEST},
{0x70, 0x02, UNIT_ATTENTION, 0x5D, 0x00, 0x1E, /* thresholds */
SKD_CHECK_STATUS_REQUEUE_REQUEST},
{0x70, 0x02, UNIT_ATTENTION, 0x80, 0x30, 0x1F, /* backup power */
SKD_CHECK_STATUS_REQUEUE_REQUEST},
/* Busy (or about to be) */
{0x70, 0x02, UNIT_ATTENTION, 0x3f, 0x01, 0x1F, /* fw changed */
SKD_CHECK_STATUS_BUSY_IMMINENT},
};
/*
*
* Name: skd_check_status, checks the return status from a
* completed I/O request.
*
* Inputs: skdev - device state structure.
* cmp_status - SCSI status byte.
* skerr - the error data structure.
*
* Returns: Depending on the error condition, return the action
* to be taken as specified in the skd_chkstat_table.
* If no corresponding value is found in the table
* return SKD_CHECK_STATUS_REPORT_GOOD is no error otherwise
* return SKD_CHECK_STATUS_REPORT_ERROR.
*
*/
static enum skd_check_status_action
skd_check_status(struct skd_device *skdev, uint8_t cmp_status,
volatile struct fit_comp_error_info *skerr)
{
/*
* Look up status and sense data to decide how to handle the error
* from the device.
* mask says which fields must match e.g., mask=0x18 means check
* type and stat, ignore key, asc, ascq.
*/
int i, n;
Dcmn_err(CE_NOTE, "(%s): key/asc/ascq %02x/%02x/%02x",
skd_name(skdev), skerr->key, skerr->code, skerr->qual);
Dcmn_err(CE_NOTE, "stat: t=%02x stat=%02x k=%02x c=%02x q=%02x",
skerr->type, cmp_status, skerr->key, skerr->code, skerr->qual);
/* Does the info match an entry in the good category? */
n = sizeof (skd_chkstat_table) / sizeof (skd_chkstat_table[0]);
for (i = 0; i < n; i++) {
struct sns_info *sns = &skd_chkstat_table[i];
if (sns->mask & 0x10)
if (skerr->type != sns->type) continue;
if (sns->mask & 0x08)
if (cmp_status != sns->stat) continue;
if (sns->mask & 0x04)
if (skerr->key != sns->key) continue;
if (sns->mask & 0x02)
if (skerr->code != sns->asc) continue;
if (sns->mask & 0x01)
if (skerr->qual != sns->ascq) continue;
if (sns->action == SKD_CHECK_STATUS_REPORT_SMART_ALERT) {
cmn_err(CE_WARN, "!(%s):SMART Alert: sense key/asc/ascq"
" %02x/%02x/%02x",
skd_name(skdev), skerr->key,
skerr->code, skerr->qual);
}
Dcmn_err(CE_NOTE, "skd_check_status: returning %x",
sns->action);
return (sns->action);
}
/*
* No other match, so nonzero status means error,
* zero status means good
*/
if (cmp_status) {
cmn_err(CE_WARN,
"!%s: status check: qdepth=%d skmfl=%p (%d) skrfl=%p (%d)",
skdev->name,
skdev->queue_depth_busy,
(void *)skdev->skmsg_free_list, skd_list_skmsg(skdev, 0),
(void *)skdev->skreq_free_list, skd_list_skreq(skdev, 0));
cmn_err(CE_WARN, "!%s: t=%02x stat=%02x k=%02x c=%02x q=%02x",
skdev->name, skerr->type, cmp_status, skerr->key,
skerr->code, skerr->qual);
return (SKD_CHECK_STATUS_REPORT_ERROR);
}
Dcmn_err(CE_NOTE, "status check good default");
return (SKD_CHECK_STATUS_REPORT_GOOD);
}
/*
*
* Name: skd_isr_completion_posted, handles I/O completions.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_isr_completion_posted(struct skd_device *skdev)
{
volatile struct fit_completion_entry_v1 *skcmp = NULL;
volatile struct fit_comp_error_info *skerr;
struct skd_fitmsg_context *skmsg;
struct skd_request_context *skreq;
skd_buf_private_t *pbuf;
uint16_t req_id;
uint32_t req_slot;
uint32_t timo_slot;
uint32_t msg_slot;
uint16_t cmp_cntxt = 0;
uint8_t cmp_status = 0;
uint8_t cmp_cycle = 0;
uint32_t cmp_bytes = 0;
(void) ddi_dma_sync(skdev->cq_dma_address.dma_handle, 0, 0,
DDI_DMA_SYNC_FORKERNEL);
for (;;) {
ASSERT(skdev->skcomp_ix < SKD_N_COMPLETION_ENTRY);
WAITQ_LOCK(skdev);
skcmp = &skdev->skcomp_table[skdev->skcomp_ix];
cmp_cycle = skcmp->cycle;
cmp_cntxt = skcmp->tag;
cmp_status = skcmp->status;
cmp_bytes = be32_to_cpu(skcmp->num_returned_bytes);
skerr = &skdev->skerr_table[skdev->skcomp_ix];
Dcmn_err(CE_NOTE,
"cycle=%d ix=%d got cycle=%d cmdctxt=0x%x stat=%d "
"qdepth_busy=%d rbytes=0x%x proto=%d",
skdev->skcomp_cycle, skdev->skcomp_ix,
cmp_cycle, cmp_cntxt, cmp_status,
skdev->queue_depth_busy, cmp_bytes, skdev->proto_ver);
if (cmp_cycle != skdev->skcomp_cycle) {
Dcmn_err(CE_NOTE, "%s:end of completions", skdev->name);
WAITQ_UNLOCK(skdev);
break;
}
skdev->n_req++;
/*
* Update the completion queue head index and possibly
* the completion cycle count.
*/
skdev->skcomp_ix++;
if (skdev->skcomp_ix >= SKD_N_COMPLETION_ENTRY) {
skdev->skcomp_ix = 0;
skdev->skcomp_cycle++; /* 8-bit wrap-around */
}
/*
* The command context is a unique 32-bit ID. The low order
* bits help locate the request. The request is usually a
* r/w request (see skd_start() above) or a special request.
*/
req_id = cmp_cntxt;
req_slot = req_id & SKD_ID_SLOT_AND_TABLE_MASK;
Dcmn_err(CE_NOTE,
"<<<< completion_posted 1: req_id=%x req_slot=%x",
req_id, req_slot);
/* Is this other than a r/w request? */
if (req_slot >= skdev->num_req_context) {
/*
* This is not a completion for a r/w request.
*/
skd_complete_other(skdev, skcmp, skerr);
WAITQ_UNLOCK(skdev);
continue;
}
skreq = &skdev->skreq_table[req_slot];
/*
* Make sure the request ID for the slot matches.
*/
ASSERT(skreq->id == req_id);
if (SKD_REQ_STATE_ABORTED == skreq->state) {
Dcmn_err(CE_NOTE, "reclaim req %p id=%04x\n",
(void *)skreq, skreq->id);
/*
* a previously timed out command can
* now be cleaned up
*/
msg_slot = skreq->fitmsg_id & SKD_ID_SLOT_MASK;
ASSERT(msg_slot < skdev->num_fitmsg_context);
skmsg = &skdev->skmsg_table[msg_slot];
if (skmsg->id == skreq->fitmsg_id) {
ASSERT(skmsg->outstanding > 0);
skmsg->outstanding--;
if (skmsg->outstanding == 0) {
ASSERT(SKD_MSG_STATE_BUSY ==
skmsg->state);
skmsg->state = SKD_MSG_STATE_IDLE;
skmsg->id += SKD_ID_INCR;
skmsg->next = skdev->skmsg_free_list;
skdev->skmsg_free_list = skmsg;
}
}
/*
* Reclaim the skd_request_context
*/
skreq->state = SKD_REQ_STATE_IDLE;
skreq->id += SKD_ID_INCR;
skreq->next = skdev->skreq_free_list;
skdev->skreq_free_list = skreq;
WAITQ_UNLOCK(skdev);
continue;
}
skreq->completion.status = cmp_status;
pbuf = skreq->pbuf;
ASSERT(pbuf != NULL);
Dcmn_err(CE_NOTE, "<<<< completion_posted 2: pbuf=%p "
"req_id=%x req_slot=%x", (void *)pbuf, req_id, req_slot);
if (cmp_status && skdev->disks_initialized) {
cmn_err(CE_WARN, "!%s: "
"I/O err: pbuf=%p blkno=%lld (%llx) nbklks=%ld ",
skdev->name, (void *)pbuf, pbuf->x_xfer->x_blkno,
pbuf->x_xfer->x_blkno, pbuf->x_xfer->x_nblks);
}
ASSERT(skdev->active_cmds);
atomic_dec_64(&skdev->active_cmds);
if (SAM_STAT_GOOD == cmp_status) {
/* Release DMA resources for the request. */
if (pbuf->x_xfer->x_nblks != 0)
skd_blkdev_postop_sg_list(skdev, skreq);
WAITQ_UNLOCK(skdev);
skd_end_request(skdev, skreq, 0);
WAITQ_LOCK(skdev);
} else {
switch (skd_check_status(skdev, cmp_status, skerr)) {
case SKD_CHECK_STATUS_REPORT_GOOD:
case SKD_CHECK_STATUS_REPORT_SMART_ALERT:
WAITQ_UNLOCK(skdev);
skd_end_request(skdev, skreq, 0);
WAITQ_LOCK(skdev);
break;
case SKD_CHECK_STATUS_BUSY_IMMINENT:
skd_log_skreq(skdev, skreq, "retry(busy)");
skd_queue(skdev, pbuf);
skdev->state = SKD_DRVR_STATE_BUSY_IMMINENT;
skdev->timer_countdown = SKD_TIMER_MINUTES(20);
(void) skd_quiesce_dev(skdev);
break;
/* FALLTHRU */
case SKD_CHECK_STATUS_REPORT_ERROR:
/* fall thru to report error */
default:
/*
* Save the entire completion
* and error entries for
* later error interpretation.
*/
skreq->completion = *skcmp;
skreq->err_info = *skerr;
WAITQ_UNLOCK(skdev);
skd_end_request(skdev, skreq, -EIO);
WAITQ_LOCK(skdev);
break;
}
}
/*
* Reclaim the FIT msg buffer if this is
* the first of the requests it carried to
* be completed. The FIT msg buffer used to
* send this request cannot be reused until
* we are sure the s1120 card has copied
* it to its memory. The FIT msg might have
* contained several requests. As soon as
* any of them are completed we know that
* the entire FIT msg was transferred.
* Only the first completed request will
* match the FIT msg buffer id. The FIT
* msg buffer id is immediately updated.
* When subsequent requests complete the FIT
* msg buffer id won't match, so we know
* quite cheaply that it is already done.
*/
msg_slot = skreq->fitmsg_id & SKD_ID_SLOT_MASK;
ASSERT(msg_slot < skdev->num_fitmsg_context);
skmsg = &skdev->skmsg_table[msg_slot];
if (skmsg->id == skreq->fitmsg_id) {
ASSERT(SKD_MSG_STATE_BUSY == skmsg->state);
skmsg->state = SKD_MSG_STATE_IDLE;
skmsg->id += SKD_ID_INCR;
skmsg->next = skdev->skmsg_free_list;
skdev->skmsg_free_list = skmsg;
}
/*
* Decrease the number of active requests.
* This also decrements the count in the
* timeout slot.
*/
timo_slot = skreq->timeout_stamp & SKD_TIMEOUT_SLOT_MASK;
ASSERT(skdev->timeout_slot[timo_slot] > 0);
ASSERT(skdev->queue_depth_busy > 0);
atomic_dec_32(&skdev->timeout_slot[timo_slot]);
atomic_dec_32(&skdev->queue_depth_busy);
/*
* Reclaim the skd_request_context
*/
skreq->state = SKD_REQ_STATE_IDLE;
skreq->id += SKD_ID_INCR;
skreq->next = skdev->skreq_free_list;
skdev->skreq_free_list = skreq;
WAITQ_UNLOCK(skdev);
/*
* make sure the lock is held by caller.
*/
if ((skdev->state == SKD_DRVR_STATE_PAUSING) &&
(0 == skdev->queue_depth_busy)) {
skdev->state = SKD_DRVR_STATE_PAUSED;
cv_signal(&skdev->cv_waitq);
}
} /* for(;;) */
}
/*
*
* Name: skd_complete_other, handle the completion of a
* non-r/w request.
*
* Inputs: skdev - device state structure.
* skcomp - FIT completion structure.
* skerr - error structure.
*
* Returns: Nothing.
*
*/
static void
skd_complete_other(struct skd_device *skdev,
volatile struct fit_completion_entry_v1 *skcomp,
volatile struct fit_comp_error_info *skerr)
{
uint32_t req_id = 0;
uint32_t req_table;
uint32_t req_slot;
struct skd_special_context *skspcl;
req_id = skcomp->tag;
req_table = req_id & SKD_ID_TABLE_MASK;
req_slot = req_id & SKD_ID_SLOT_MASK;
Dcmn_err(CE_NOTE, "complete_other: table=0x%x id=0x%x slot=%d",
req_table, req_id, req_slot);
/*
* Based on the request id, determine how to dispatch this completion.
* This swich/case is finding the good cases and forwarding the
* completion entry. Errors are reported below the switch.
*/
ASSERT(req_table == SKD_ID_INTERNAL);
ASSERT(req_slot == 0);
skspcl = &skdev->internal_skspcl;
ASSERT(skspcl->req.id == req_id);
ASSERT(skspcl->req.state == SKD_REQ_STATE_BUSY);
Dcmn_err(CE_NOTE, "<<<<== complete_other: ID_INTERNAL");
skd_complete_internal(skdev, skcomp, skerr, skspcl);
}
/*
*
* Name: skd_reset_skcomp, does what it says, resetting completion
* tables.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_reset_skcomp(struct skd_device *skdev)
{
uint32_t nbytes;
nbytes = sizeof (struct fit_completion_entry_v1) *
SKD_N_COMPLETION_ENTRY;
nbytes += sizeof (struct fit_comp_error_info) * SKD_N_COMPLETION_ENTRY;
if (skdev->skcomp_table)
bzero(skdev->skcomp_table, nbytes);
skdev->skcomp_ix = 0;
skdev->skcomp_cycle = 1;
}
/*
* INTERRUPTS
*/
/*
*
* Name: skd_isr_aif, handles the device interrupts.
*
* Inputs: arg - skdev device state structure.
* intvec - not referenced
*
* Returns: DDI_INTR_CLAIMED if interrupt is handled otherwise
* return DDI_INTR_UNCLAIMED.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static uint_t
skd_isr_aif(caddr_t arg, caddr_t intvec)
{
uint32_t intstat;
uint32_t ack;
int rc = DDI_INTR_UNCLAIMED;
struct skd_device *skdev;
skdev = (skd_device_t *)(uintptr_t)arg;
ASSERT(skdev != NULL);
skdev->intr_cntr++;
Dcmn_err(CE_NOTE, "skd_isr_aif: intr=%" PRId64 "\n", skdev->intr_cntr);
for (;;) {
ASSERT(!WAITQ_LOCK_HELD(skdev));
INTR_LOCK(skdev);
intstat = SKD_READL(skdev, FIT_INT_STATUS_HOST);
ack = FIT_INT_DEF_MASK;
ack &= intstat;
Dcmn_err(CE_NOTE, "intstat=0x%x ack=0x%x", intstat, ack);
/*
* As long as there is an int pending on device, keep
* running loop. When none, get out, but if we've never
* done any processing, call completion handler?
*/
if (ack == 0) {
/*
* No interrupts on device, but run the completion
* processor anyway?
*/
if (rc == DDI_INTR_UNCLAIMED &&
skdev->state == SKD_DRVR_STATE_ONLINE) {
Dcmn_err(CE_NOTE,
"1: Want isr_comp_posted call");
skd_isr_completion_posted(skdev);
}
INTR_UNLOCK(skdev);
break;
}
rc = DDI_INTR_CLAIMED;
SKD_WRITEL(skdev, ack, FIT_INT_STATUS_HOST);
if ((skdev->state != SKD_DRVR_STATE_LOAD) &&
(skdev->state != SKD_DRVR_STATE_STOPPING)) {
if (intstat & FIT_ISH_COMPLETION_POSTED) {
Dcmn_err(CE_NOTE,
"2: Want isr_comp_posted call");
skd_isr_completion_posted(skdev);
}
if (intstat & FIT_ISH_FW_STATE_CHANGE) {
Dcmn_err(CE_NOTE, "isr: fwstate change");
skd_isr_fwstate(skdev);
if (skdev->state == SKD_DRVR_STATE_FAULT ||
skdev->state ==
SKD_DRVR_STATE_DISAPPEARED) {
INTR_UNLOCK(skdev);
return (rc);
}
}
if (intstat & FIT_ISH_MSG_FROM_DEV) {
Dcmn_err(CE_NOTE, "isr: msg_from_dev change");
skd_isr_msg_from_dev(skdev);
}
}
INTR_UNLOCK(skdev);
}
if (!SIMPLEQ_EMPTY(&skdev->waitqueue))
skd_start(skdev);
return (rc);
}
/*
*
* Name: skd_drive_fault, set the drive state to DRV_STATE_FAULT.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_drive_fault(struct skd_device *skdev)
{
skdev->state = SKD_DRVR_STATE_FAULT;
cmn_err(CE_WARN, "!(%s): Drive FAULT\n",
skd_name(skdev));
}
/*
*
* Name: skd_drive_disappeared, set the drive state to DISAPPEARED..
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_drive_disappeared(struct skd_device *skdev)
{
skdev->state = SKD_DRVR_STATE_DISAPPEARED;
cmn_err(CE_WARN, "!(%s): Drive DISAPPEARED\n",
skd_name(skdev));
}
/*
*
* Name: skd_isr_fwstate, handles the various device states.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_isr_fwstate(struct skd_device *skdev)
{
uint32_t sense;
uint32_t state;
int prev_driver_state;
uint32_t mtd;
prev_driver_state = skdev->state;
sense = SKD_READL(skdev, FIT_STATUS);
state = sense & FIT_SR_DRIVE_STATE_MASK;
Dcmn_err(CE_NOTE, "s1120 state %s(%d)=>%s(%d)",
skd_drive_state_to_str(skdev->drive_state), skdev->drive_state,
skd_drive_state_to_str(state), state);
skdev->drive_state = state;
switch (skdev->drive_state) {
case FIT_SR_DRIVE_INIT:
if (skdev->state == SKD_DRVR_STATE_PROTOCOL_MISMATCH) {
skd_disable_interrupts(skdev);
break;
}
if (skdev->state == SKD_DRVR_STATE_RESTARTING) {
skd_recover_requests(skdev);
}
if (skdev->state == SKD_DRVR_STATE_WAIT_BOOT) {
skdev->timer_countdown =
SKD_TIMER_SECONDS(SKD_STARTING_TO);
skdev->state = SKD_DRVR_STATE_STARTING;
skd_soft_reset(skdev);
break;
}
mtd = FIT_MXD_CONS(FIT_MTD_FITFW_INIT, 0, 0);
SKD_WRITEL(skdev, mtd, FIT_MSG_TO_DEVICE);
skdev->last_mtd = mtd;
break;
case FIT_SR_DRIVE_ONLINE:
skdev->queue_depth_limit = skdev->soft_queue_depth_limit;
if (skdev->queue_depth_limit > skdev->hard_queue_depth_limit) {
skdev->queue_depth_limit =
skdev->hard_queue_depth_limit;
}
skdev->queue_depth_lowat = skdev->queue_depth_limit * 2 / 3 + 1;
if (skdev->queue_depth_lowat < 1)
skdev->queue_depth_lowat = 1;
Dcmn_err(CE_NOTE,
"%s queue depth limit=%d hard=%d soft=%d lowat=%d",
DRV_NAME,
skdev->queue_depth_limit,
skdev->hard_queue_depth_limit,
skdev->soft_queue_depth_limit,
skdev->queue_depth_lowat);
skd_refresh_device_data(skdev);
break;
case FIT_SR_DRIVE_BUSY:
skdev->state = SKD_DRVR_STATE_BUSY;
skdev->timer_countdown = SKD_TIMER_MINUTES(20);
(void) skd_quiesce_dev(skdev);
break;
case FIT_SR_DRIVE_BUSY_SANITIZE:
skdev->state = SKD_DRVR_STATE_BUSY_SANITIZE;
skd_start(skdev);
break;
case FIT_SR_DRIVE_BUSY_ERASE:
skdev->state = SKD_DRVR_STATE_BUSY_ERASE;
skdev->timer_countdown = SKD_TIMER_MINUTES(20);
break;
case FIT_SR_DRIVE_OFFLINE:
skdev->state = SKD_DRVR_STATE_IDLE;
break;
case FIT_SR_DRIVE_SOFT_RESET:
skdev->state = SKD_DRVR_STATE_RESTARTING;
switch (skdev->state) {
case SKD_DRVR_STATE_STARTING:
case SKD_DRVR_STATE_RESTARTING:
break;
default:
skdev->state = SKD_DRVR_STATE_RESTARTING;
break;
}
break;
case FIT_SR_DRIVE_FW_BOOTING:
Dcmn_err(CE_NOTE,
"ISR FIT_SR_DRIVE_FW_BOOTING %s", skdev->name);
skdev->state = SKD_DRVR_STATE_WAIT_BOOT;
skdev->timer_countdown = SKD_TIMER_SECONDS(SKD_WAIT_BOOT_TO);
break;
case FIT_SR_DRIVE_DEGRADED:
case FIT_SR_PCIE_LINK_DOWN:
case FIT_SR_DRIVE_NEED_FW_DOWNLOAD:
break;
case FIT_SR_DRIVE_FAULT:
skd_drive_fault(skdev);
skd_recover_requests(skdev);
skd_start(skdev);
break;
case 0xFF:
skd_drive_disappeared(skdev);
skd_recover_requests(skdev);
skd_start(skdev);
break;
default:
/*
* Uknown FW State. Wait for a state we recognize.
*/
break;
}
Dcmn_err(CE_NOTE, "Driver state %s(%d)=>%s(%d)",
skd_skdev_state_to_str(prev_driver_state), prev_driver_state,
skd_skdev_state_to_str(skdev->state), skdev->state);
}
/*
*
* Name: skd_recover_requests, attempts to recover requests.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_recover_requests(struct skd_device *skdev)
{
int i;
ASSERT(INTR_LOCK_HELD(skdev));
for (i = 0; i < skdev->num_req_context; i++) {
struct skd_request_context *skreq = &skdev->skreq_table[i];
if (skreq->state == SKD_REQ_STATE_BUSY) {
skd_log_skreq(skdev, skreq, "requeue");
ASSERT(0 != (skreq->id & SKD_ID_INCR));
ASSERT(skreq->pbuf != NULL);
/* Release DMA resources for the request. */
skd_blkdev_postop_sg_list(skdev, skreq);
skd_end_request(skdev, skreq, EAGAIN);
skreq->pbuf = NULL;
skreq->state = SKD_REQ_STATE_IDLE;
skreq->id += SKD_ID_INCR;
}
if (i > 0) {
skreq[-1].next = skreq;
}
skreq->next = NULL;
}
WAITQ_LOCK(skdev);
skdev->skreq_free_list = skdev->skreq_table;
WAITQ_UNLOCK(skdev);
for (i = 0; i < skdev->num_fitmsg_context; i++) {
struct skd_fitmsg_context *skmsg = &skdev->skmsg_table[i];
if (skmsg->state == SKD_MSG_STATE_BUSY) {
skd_log_skmsg(skdev, skmsg, "salvaged");
ASSERT((skmsg->id & SKD_ID_INCR) != 0);
skmsg->state = SKD_MSG_STATE_IDLE;
skmsg->id &= ~SKD_ID_INCR;
}
if (i > 0) {
skmsg[-1].next = skmsg;
}
skmsg->next = NULL;
}
WAITQ_LOCK(skdev);
skdev->skmsg_free_list = skdev->skmsg_table;
WAITQ_UNLOCK(skdev);
for (i = 0; i < SKD_N_TIMEOUT_SLOT; i++) {
skdev->timeout_slot[i] = 0;
}
skdev->queue_depth_busy = 0;
}
/*
*
* Name: skd_isr_msg_from_dev, handles a message from the device.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_isr_msg_from_dev(struct skd_device *skdev)
{
uint32_t mfd;
uint32_t mtd;
Dcmn_err(CE_NOTE, "skd_isr_msg_from_dev:");
mfd = SKD_READL(skdev, FIT_MSG_FROM_DEVICE);
Dcmn_err(CE_NOTE, "mfd=0x%x last_mtd=0x%x\n", mfd, skdev->last_mtd);
/*
* ignore any mtd that is an ack for something we didn't send
*/
if (FIT_MXD_TYPE(mfd) != FIT_MXD_TYPE(skdev->last_mtd)) {
return;
}
switch (FIT_MXD_TYPE(mfd)) {
case FIT_MTD_FITFW_INIT:
skdev->proto_ver = FIT_PROTOCOL_MAJOR_VER(mfd);
if (skdev->proto_ver != FIT_PROTOCOL_VERSION_1) {
cmn_err(CE_WARN, "!(%s): protocol mismatch\n",
skdev->name);
cmn_err(CE_WARN, "!(%s): got=%d support=%d\n",
skdev->name, skdev->proto_ver,
FIT_PROTOCOL_VERSION_1);
cmn_err(CE_WARN, "!(%s): please upgrade driver\n",
skdev->name);
skdev->state = SKD_DRVR_STATE_PROTOCOL_MISMATCH;
skd_soft_reset(skdev);
break;
}
mtd = FIT_MXD_CONS(FIT_MTD_GET_CMDQ_DEPTH, 0, 0);
SKD_WRITEL(skdev, mtd, FIT_MSG_TO_DEVICE);
skdev->last_mtd = mtd;
break;
case FIT_MTD_GET_CMDQ_DEPTH:
skdev->hard_queue_depth_limit = FIT_MXD_DATA(mfd);
mtd = FIT_MXD_CONS(FIT_MTD_SET_COMPQ_DEPTH, 0,
SKD_N_COMPLETION_ENTRY);
SKD_WRITEL(skdev, mtd, FIT_MSG_TO_DEVICE);
skdev->last_mtd = mtd;
break;
case FIT_MTD_SET_COMPQ_DEPTH:
SKD_WRITEQ(skdev, skdev->cq_dma_address.cookies->dmac_laddress,
FIT_MSG_TO_DEVICE_ARG);
mtd = FIT_MXD_CONS(FIT_MTD_SET_COMPQ_ADDR, 0, 0);
SKD_WRITEL(skdev, mtd, FIT_MSG_TO_DEVICE);
skdev->last_mtd = mtd;
break;
case FIT_MTD_SET_COMPQ_ADDR:
skd_reset_skcomp(skdev);
mtd = FIT_MXD_CONS(FIT_MTD_ARM_QUEUE, 0, 0);
SKD_WRITEL(skdev, mtd, FIT_MSG_TO_DEVICE);
skdev->last_mtd = mtd;
break;
case FIT_MTD_ARM_QUEUE:
skdev->last_mtd = 0;
/*
* State should be, or soon will be, FIT_SR_DRIVE_ONLINE.
*/
break;
default:
break;
}
}
/*
*
* Name: skd_disable_interrupts, issues command to disable
* device interrupts.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_disable_interrupts(struct skd_device *skdev)
{
uint32_t sense;
Dcmn_err(CE_NOTE, "skd_disable_interrupts:");
sense = SKD_READL(skdev, FIT_CONTROL);
sense &= ~FIT_CR_ENABLE_INTERRUPTS;
SKD_WRITEL(skdev, sense, FIT_CONTROL);
Dcmn_err(CE_NOTE, "sense 0x%x", sense);
/*
* Note that the 1s is written. A 1-bit means
* disable, a 0 means enable.
*/
SKD_WRITEL(skdev, ~0, FIT_INT_MASK_HOST);
}
/*
*
* Name: skd_enable_interrupts, issues command to enable
* device interrupts.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_enable_interrupts(struct skd_device *skdev)
{
uint32_t val;
Dcmn_err(CE_NOTE, "skd_enable_interrupts:");
/* unmask interrupts first */
val = FIT_ISH_FW_STATE_CHANGE +
FIT_ISH_COMPLETION_POSTED +
FIT_ISH_MSG_FROM_DEV;
/*
* Note that the compliment of mask is written. A 1-bit means
* disable, a 0 means enable.
*/
SKD_WRITEL(skdev, ~val, FIT_INT_MASK_HOST);
Dcmn_err(CE_NOTE, "interrupt mask=0x%x", ~val);
val = SKD_READL(skdev, FIT_CONTROL);
val |= FIT_CR_ENABLE_INTERRUPTS;
Dcmn_err(CE_NOTE, "control=0x%x", val);
SKD_WRITEL(skdev, val, FIT_CONTROL);
}
/*
*
* Name: skd_soft_reset, issues a soft reset to the hardware.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_soft_reset(struct skd_device *skdev)
{
uint32_t val;
Dcmn_err(CE_NOTE, "skd_soft_reset:");
val = SKD_READL(skdev, FIT_CONTROL);
val |= (FIT_CR_SOFT_RESET);
Dcmn_err(CE_NOTE, "soft_reset: control=0x%x", val);
SKD_WRITEL(skdev, val, FIT_CONTROL);
}
/*
*
* Name: skd_start_device, gets the device going.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_start_device(struct skd_device *skdev)
{
uint32_t state;
int delay_action = 0;
Dcmn_err(CE_NOTE, "skd_start_device:");
/* ack all ghost interrupts */
SKD_WRITEL(skdev, FIT_INT_DEF_MASK, FIT_INT_STATUS_HOST);
state = SKD_READL(skdev, FIT_STATUS);
Dcmn_err(CE_NOTE, "initial status=0x%x", state);
state &= FIT_SR_DRIVE_STATE_MASK;
skdev->drive_state = state;
skdev->last_mtd = 0;
skdev->state = SKD_DRVR_STATE_STARTING;
skdev->timer_countdown = SKD_TIMER_SECONDS(SKD_STARTING_TO);
skd_enable_interrupts(skdev);
switch (skdev->drive_state) {
case FIT_SR_DRIVE_OFFLINE:
Dcmn_err(CE_NOTE, "(%s): Drive offline...",
skd_name(skdev));
break;
case FIT_SR_DRIVE_FW_BOOTING:
Dcmn_err(CE_NOTE, "FIT_SR_DRIVE_FW_BOOTING %s\n", skdev->name);
skdev->state = SKD_DRVR_STATE_WAIT_BOOT;
skdev->timer_countdown = SKD_TIMER_SECONDS(SKD_WAIT_BOOT_TO);
break;
case FIT_SR_DRIVE_BUSY_SANITIZE:
Dcmn_err(CE_NOTE, "(%s): Start: BUSY_SANITIZE\n",
skd_name(skdev));
skdev->state = SKD_DRVR_STATE_BUSY_SANITIZE;
skdev->timer_countdown = SKD_TIMER_SECONDS(60);
break;
case FIT_SR_DRIVE_BUSY_ERASE:
Dcmn_err(CE_NOTE, "(%s): Start: BUSY_ERASE\n",
skd_name(skdev));
skdev->state = SKD_DRVR_STATE_BUSY_ERASE;
skdev->timer_countdown = SKD_TIMER_SECONDS(60);
break;
case FIT_SR_DRIVE_INIT:
case FIT_SR_DRIVE_ONLINE:
skd_soft_reset(skdev);
break;
case FIT_SR_DRIVE_BUSY:
Dcmn_err(CE_NOTE, "(%s): Drive Busy...\n",
skd_name(skdev));
skdev->state = SKD_DRVR_STATE_BUSY;
skdev->timer_countdown = SKD_TIMER_SECONDS(60);
break;
case FIT_SR_DRIVE_SOFT_RESET:
Dcmn_err(CE_NOTE, "(%s) drive soft reset in prog\n",
skd_name(skdev));
break;
case FIT_SR_DRIVE_FAULT:
/*
* Fault state is bad...soft reset won't do it...
* Hard reset, maybe, but does it work on device?
* For now, just fault so the system doesn't hang.
*/
skd_drive_fault(skdev);
delay_action = 1;
break;
case 0xFF:
skd_drive_disappeared(skdev);
delay_action = 1;
break;
default:
Dcmn_err(CE_NOTE, "(%s) Start: unknown state %x\n",
skd_name(skdev), skdev->drive_state);
break;
}
state = SKD_READL(skdev, FIT_CONTROL);
Dcmn_err(CE_NOTE, "FIT Control Status=0x%x\n", state);
state = SKD_READL(skdev, FIT_INT_STATUS_HOST);
Dcmn_err(CE_NOTE, "Intr Status=0x%x\n", state);
state = SKD_READL(skdev, FIT_INT_MASK_HOST);
Dcmn_err(CE_NOTE, "Intr Mask=0x%x\n", state);
state = SKD_READL(skdev, FIT_MSG_FROM_DEVICE);
Dcmn_err(CE_NOTE, "Msg from Dev=0x%x\n", state);
state = SKD_READL(skdev, FIT_HW_VERSION);
Dcmn_err(CE_NOTE, "HW version=0x%x\n", state);
if (delay_action) {
/* start the queue so we can respond with error to requests */
Dcmn_err(CE_NOTE, "Starting %s queue\n", skdev->name);
skd_start(skdev);
skdev->gendisk_on = -1;
cv_signal(&skdev->cv_waitq);
}
}
/*
*
* Name: skd_restart_device, restart the hardware.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_restart_device(struct skd_device *skdev)
{
uint32_t state;
Dcmn_err(CE_NOTE, "skd_restart_device:");
/* ack all ghost interrupts */
SKD_WRITEL(skdev, FIT_INT_DEF_MASK, FIT_INT_STATUS_HOST);
state = SKD_READL(skdev, FIT_STATUS);
Dcmn_err(CE_NOTE, "skd_restart_device: drive status=0x%x\n", state);
state &= FIT_SR_DRIVE_STATE_MASK;
skdev->drive_state = state;
skdev->last_mtd = 0;
skdev->state = SKD_DRVR_STATE_RESTARTING;
skdev->timer_countdown = SKD_TIMER_MINUTES(4);
skd_soft_reset(skdev);
}
/*
*
* Name: skd_stop_device, stops the device.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_stop_device(struct skd_device *skdev)
{
clock_t cur_ticks, tmo;
int secs;
struct skd_special_context *skspcl = &skdev->internal_skspcl;
if (SKD_DRVR_STATE_ONLINE != skdev->state) {
Dcmn_err(CE_NOTE, "(%s): skd_stop_device not online no sync\n",
skdev->name);
goto stop_out;
}
if (SKD_REQ_STATE_IDLE != skspcl->req.state) {
Dcmn_err(CE_NOTE, "(%s): skd_stop_device no special\n",
skdev->name);
goto stop_out;
}
skdev->state = SKD_DRVR_STATE_SYNCING;
skdev->sync_done = 0;
skd_send_internal_skspcl(skdev, skspcl, SYNCHRONIZE_CACHE);
secs = 10;
mutex_enter(&skdev->skd_internalio_mutex);
while (skdev->sync_done == 0) {
cur_ticks = ddi_get_lbolt();
tmo = cur_ticks + drv_usectohz(1000000 * secs);
if (cv_timedwait(&skdev->cv_waitq,
&skdev->skd_internalio_mutex, tmo) == -1) {
/* Oops - timed out */
Dcmn_err(CE_NOTE, "stop_device - %d secs TMO", secs);
}
}
mutex_exit(&skdev->skd_internalio_mutex);
switch (skdev->sync_done) {
case 0:
Dcmn_err(CE_NOTE, "(%s): skd_stop_device no sync\n",
skdev->name);
break;
case 1:
Dcmn_err(CE_NOTE, "(%s): skd_stop_device sync done\n",
skdev->name);
break;
default:
Dcmn_err(CE_NOTE, "(%s): skd_stop_device sync error\n",
skdev->name);
}
stop_out:
skdev->state = SKD_DRVR_STATE_STOPPING;
skd_disable_interrupts(skdev);
/* ensure all ints on device are cleared */
SKD_WRITEL(skdev, FIT_INT_DEF_MASK, FIT_INT_STATUS_HOST);
/* soft reset the device to unload with a clean slate */
SKD_WRITEL(skdev, FIT_CR_SOFT_RESET, FIT_CONTROL);
}
/*
* CONSTRUCT
*/
static int skd_cons_skcomp(struct skd_device *);
static int skd_cons_skmsg(struct skd_device *);
static int skd_cons_skreq(struct skd_device *);
static int skd_cons_sksb(struct skd_device *);
static struct fit_sg_descriptor *skd_cons_sg_list(struct skd_device *, uint32_t,
dma_mem_t *);
/*
*
* Name: skd_construct, calls other routines to build device
* interface structures.
*
* Inputs: skdev - device state structure.
* instance - DDI instance number.
*
* Returns: Returns DDI_FAILURE on any failure otherwise returns
* DDI_SUCCESS.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static int
skd_construct(skd_device_t *skdev, int instance)
{
int rc = 0;
skdev->state = SKD_DRVR_STATE_LOAD;
skdev->irq_type = skd_isr_type;
skdev->soft_queue_depth_limit = skd_max_queue_depth;
skdev->hard_queue_depth_limit = 10; /* until GET_CMDQ_DEPTH */
skdev->num_req_context = skd_max_queue_depth;
skdev->num_fitmsg_context = skd_max_queue_depth;
skdev->queue_depth_limit = skdev->hard_queue_depth_limit;
skdev->queue_depth_lowat = 1;
skdev->proto_ver = 99; /* initialize to invalid value */
skdev->sgs_per_request = skd_sgs_per_request;
skdev->dbg_level = skd_dbg_level;
rc = skd_cons_skcomp(skdev);
if (rc < 0) {
goto err_out;
}
rc = skd_cons_skmsg(skdev);
if (rc < 0) {
goto err_out;
}
rc = skd_cons_skreq(skdev);
if (rc < 0) {
goto err_out;
}
rc = skd_cons_sksb(skdev);
if (rc < 0) {
goto err_out;
}
Dcmn_err(CE_NOTE, "CONSTRUCT VICTORY");
return (DDI_SUCCESS);
err_out:
Dcmn_err(CE_NOTE, "construct failed\n");
skd_destruct(skdev);
return (DDI_FAILURE);
}
/*
*
* Name: skd_free_phys, frees DMA memory.
*
* Inputs: skdev - device state structure.
* mem - DMA info.
*
* Returns: Nothing.
*
*/
static void
skd_free_phys(skd_device_t *skdev, dma_mem_t *mem)
{
_NOTE(ARGUNUSED(skdev));
if (mem == NULL || mem->dma_handle == NULL)
return;
(void) ddi_dma_unbind_handle(mem->dma_handle);
if (mem->acc_handle != NULL) {
ddi_dma_mem_free(&mem->acc_handle);
mem->acc_handle = NULL;
}
mem->bp = NULL;
ddi_dma_free_handle(&mem->dma_handle);
mem->dma_handle = NULL;
}
/*
*
* Name: skd_alloc_dma_mem, allocates DMA memory.
*
* Inputs: skdev - device state structure.
* mem - DMA data structure.
* sleep - indicates whether called routine can sleep.
* atype - specified 32 or 64 bit allocation.
*
* Returns: Void pointer to mem->bp on success else NULL.
* NOTE: There are some failure modes even if sleep is set
* to KM_SLEEP, so callers MUST check the return code even
* if KM_SLEEP is passed in.
*
*/
static void *
skd_alloc_dma_mem(skd_device_t *skdev, dma_mem_t *mem, uint8_t atype)
{
size_t rlen;
uint_t cnt;
ddi_dma_attr_t dma_attr = skd_64bit_io_dma_attr;
ddi_device_acc_attr_t acc_attr = {
DDI_DEVICE_ATTR_V0,
DDI_STRUCTURE_LE_ACC,
DDI_STRICTORDER_ACC
};
if (atype == ATYPE_32BIT)
dma_attr.dma_attr_addr_hi = SKD_DMA_HIGH_32BIT_ADDRESS;
dma_attr.dma_attr_sgllen = 1;
/*
* Allocate DMA memory.
*/
if (ddi_dma_alloc_handle(skdev->dip, &dma_attr, DDI_DMA_SLEEP, NULL,
&mem->dma_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!alloc_dma_mem-1, failed");
mem->dma_handle = NULL;
return (NULL);
}
if (ddi_dma_mem_alloc(mem->dma_handle, mem->size, &acc_attr,
DDI_DMA_CONSISTENT, DDI_DMA_SLEEP, NULL, (caddr_t *)&mem->bp, &rlen,
&mem->acc_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!skd_alloc_dma_mem-2, failed");
ddi_dma_free_handle(&mem->dma_handle);
mem->dma_handle = NULL;
mem->acc_handle = NULL;
mem->bp = NULL;
return (NULL);
}
bzero(mem->bp, mem->size);
if (ddi_dma_addr_bind_handle(mem->dma_handle, NULL, mem->bp,
mem->size, (DDI_DMA_CONSISTENT | DDI_DMA_RDWR), DDI_DMA_SLEEP, NULL,
&mem->cookie, &cnt) != DDI_DMA_MAPPED) {
cmn_err(CE_WARN, "!skd_alloc_dma_mem-3, failed");
ddi_dma_mem_free(&mem->acc_handle);
ddi_dma_free_handle(&mem->dma_handle);
return (NULL);
}
if (cnt > 1) {
(void) ddi_dma_unbind_handle(mem->dma_handle);
cmn_err(CE_WARN, "!skd_alloc_dma_mem-4, failed, "
"cookie_count %d > 1", cnt);
skd_free_phys(skdev, mem);
return (NULL);
}
mem->cookies = &mem->cookie;
mem->cookies->dmac_size = mem->size;
return (mem->bp);
}
/*
*
* Name: skd_cons_skcomp, allocates space for the skcomp table.
*
* Inputs: skdev - device state structure.
*
* Returns: -ENOMEM if no memory otherwise NULL.
*
*/
static int
skd_cons_skcomp(struct skd_device *skdev)
{
uint64_t *dma_alloc;
struct fit_completion_entry_v1 *skcomp;
int rc = 0;
uint32_t nbytes;
dma_mem_t *mem;
nbytes = sizeof (*skcomp) * SKD_N_COMPLETION_ENTRY;
nbytes += sizeof (struct fit_comp_error_info) * SKD_N_COMPLETION_ENTRY;
Dcmn_err(CE_NOTE, "cons_skcomp: nbytes=%d,entries=%d", nbytes,
SKD_N_COMPLETION_ENTRY);
mem = &skdev->cq_dma_address;
mem->size = nbytes;
dma_alloc = skd_alloc_dma_mem(skdev, mem, ATYPE_64BIT);
skcomp = (struct fit_completion_entry_v1 *)dma_alloc;
if (skcomp == NULL) {
rc = -ENOMEM;
goto err_out;
}
bzero(skcomp, nbytes);
Dcmn_err(CE_NOTE, "cons_skcomp: skcomp=%p nbytes=%d",
(void *)skcomp, nbytes);
skdev->skcomp_table = skcomp;
skdev->skerr_table = (struct fit_comp_error_info *)(dma_alloc +
(SKD_N_COMPLETION_ENTRY * sizeof (*skcomp) / sizeof (uint64_t)));
err_out:
return (rc);
}
/*
*
* Name: skd_cons_skmsg, allocates space for the skmsg table.
*
* Inputs: skdev - device state structure.
*
* Returns: -ENOMEM if no memory otherwise NULL.
*
*/
static int
skd_cons_skmsg(struct skd_device *skdev)
{
dma_mem_t *mem;
int rc = 0;
uint32_t i;
Dcmn_err(CE_NOTE, "skmsg_table kzalloc, struct %lu, count %u total %lu",
(ulong_t)sizeof (struct skd_fitmsg_context),
skdev->num_fitmsg_context,
(ulong_t)(sizeof (struct skd_fitmsg_context) *
skdev->num_fitmsg_context));
skdev->skmsg_table = (struct skd_fitmsg_context *)kmem_zalloc(
sizeof (struct skd_fitmsg_context) * skdev->num_fitmsg_context,
KM_SLEEP);
for (i = 0; i < skdev->num_fitmsg_context; i++) {
struct skd_fitmsg_context *skmsg;
skmsg = &skdev->skmsg_table[i];
skmsg->id = i + SKD_ID_FIT_MSG;
skmsg->state = SKD_MSG_STATE_IDLE;
mem = &skmsg->mb_dma_address;
mem->size = SKD_N_FITMSG_BYTES + 64;
skmsg->msg_buf = skd_alloc_dma_mem(skdev, mem, ATYPE_64BIT);
if (NULL == skmsg->msg_buf) {
rc = -ENOMEM;
i++;
break;
}
skmsg->offset = 0;
bzero(skmsg->msg_buf, SKD_N_FITMSG_BYTES);
skmsg->next = &skmsg[1];
}
/* Free list is in order starting with the 0th entry. */
skdev->skmsg_table[i - 1].next = NULL;
skdev->skmsg_free_list = skdev->skmsg_table;
return (rc);
}
/*
*
* Name: skd_cons_skreq, allocates space for the skreq table.
*
* Inputs: skdev - device state structure.
*
* Returns: -ENOMEM if no memory otherwise NULL.
*
*/
static int
skd_cons_skreq(struct skd_device *skdev)
{
int rc = 0;
uint32_t i;
Dcmn_err(CE_NOTE,
"skreq_table kmem_zalloc, struct %lu, count %u total %lu",
(ulong_t)sizeof (struct skd_request_context),
skdev->num_req_context,
(ulong_t) (sizeof (struct skd_request_context) *
skdev->num_req_context));
skdev->skreq_table = (struct skd_request_context *)kmem_zalloc(
sizeof (struct skd_request_context) * skdev->num_req_context,
KM_SLEEP);
for (i = 0; i < skdev->num_req_context; i++) {
struct skd_request_context *skreq;
skreq = &skdev->skreq_table[i];
skreq->id = (uint16_t)(i + SKD_ID_RW_REQUEST);
skreq->state = SKD_REQ_STATE_IDLE;
skreq->sksg_list = skd_cons_sg_list(skdev,
skdev->sgs_per_request,
&skreq->sksg_dma_address);
if (NULL == skreq->sksg_list) {
rc = -ENOMEM;
goto err_out;
}
skreq->next = &skreq[1];
}
/* Free list is in order starting with the 0th entry. */
skdev->skreq_table[i - 1].next = NULL;
skdev->skreq_free_list = skdev->skreq_table;
err_out:
return (rc);
}
/*
*
* Name: skd_cons_sksb, allocates space for the skspcl msg buf
* and data buf.
*
* Inputs: skdev - device state structure.
*
* Returns: -ENOMEM if no memory otherwise NULL.
*
*/
static int
skd_cons_sksb(struct skd_device *skdev)
{
int rc = 0;
struct skd_special_context *skspcl;
dma_mem_t *mem;
uint32_t nbytes;
skspcl = &skdev->internal_skspcl;
skspcl->req.id = 0 + SKD_ID_INTERNAL;
skspcl->req.state = SKD_REQ_STATE_IDLE;
nbytes = SKD_N_INTERNAL_BYTES;
mem = &skspcl->db_dma_address;
mem->size = nbytes;
/* data_buf's DMA pointer is skspcl->db_dma_address */
skspcl->data_buf = skd_alloc_dma_mem(skdev, mem, ATYPE_64BIT);
if (skspcl->data_buf == NULL) {
rc = -ENOMEM;
goto err_out;
}
bzero(skspcl->data_buf, nbytes);
nbytes = SKD_N_SPECIAL_FITMSG_BYTES;
mem = &skspcl->mb_dma_address;
mem->size = nbytes;
/* msg_buf DMA pointer is skspcl->mb_dma_address */
skspcl->msg_buf = skd_alloc_dma_mem(skdev, mem, ATYPE_64BIT);
if (skspcl->msg_buf == NULL) {
rc = -ENOMEM;
goto err_out;
}
bzero(skspcl->msg_buf, nbytes);
skspcl->req.sksg_list = skd_cons_sg_list(skdev, 1,
&skspcl->req.sksg_dma_address);
if (skspcl->req.sksg_list == NULL) {
rc = -ENOMEM;
goto err_out;
}
if (skd_format_internal_skspcl(skdev) == 0) {
rc = -EINVAL;
goto err_out;
}
err_out:
return (rc);
}
/*
*
* Name: skd_cons_sg_list, allocates the S/G list.
*
* Inputs: skdev - device state structure.
* n_sg - Number of scatter-gather entries.
* ret_dma_addr - S/G list DMA pointer.
*
* Returns: A list of FIT message descriptors.
*
*/
static struct fit_sg_descriptor
*skd_cons_sg_list(struct skd_device *skdev,
uint32_t n_sg, dma_mem_t *ret_dma_addr)
{
struct fit_sg_descriptor *sg_list;
uint32_t nbytes;
dma_mem_t *mem;
nbytes = sizeof (*sg_list) * n_sg;
mem = ret_dma_addr;
mem->size = nbytes;
/* sg_list's DMA pointer is *ret_dma_addr */
sg_list = skd_alloc_dma_mem(skdev, mem, ATYPE_32BIT);
if (sg_list != NULL) {
uint64_t dma_address = ret_dma_addr->cookie.dmac_laddress;
uint32_t i;
bzero(sg_list, nbytes);
for (i = 0; i < n_sg - 1; i++) {
uint64_t ndp_off;
ndp_off = (i + 1) * sizeof (struct fit_sg_descriptor);
sg_list[i].next_desc_ptr = dma_address + ndp_off;
}
sg_list[i].next_desc_ptr = 0LL;
}
return (sg_list);
}
/*
* DESTRUCT (FREE)
*/
static void skd_free_skcomp(struct skd_device *skdev);
static void skd_free_skmsg(struct skd_device *skdev);
static void skd_free_skreq(struct skd_device *skdev);
static void skd_free_sksb(struct skd_device *skdev);
static void skd_free_sg_list(struct skd_device *skdev,
struct fit_sg_descriptor *sg_list,
uint32_t n_sg, dma_mem_t dma_addr);
/*
*
* Name: skd_destruct, call various rouines to deallocate
* space acquired during initialization.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_destruct(struct skd_device *skdev)
{
if (skdev == NULL) {
return;
}
Dcmn_err(CE_NOTE, "destruct sksb");
skd_free_sksb(skdev);
Dcmn_err(CE_NOTE, "destruct skreq");
skd_free_skreq(skdev);
Dcmn_err(CE_NOTE, "destruct skmsg");
skd_free_skmsg(skdev);
Dcmn_err(CE_NOTE, "destruct skcomp");
skd_free_skcomp(skdev);
Dcmn_err(CE_NOTE, "DESTRUCT VICTORY");
}
/*
*
* Name: skd_free_skcomp, deallocates skcomp table DMA resources.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_free_skcomp(struct skd_device *skdev)
{
if (skdev->skcomp_table != NULL) {
skd_free_phys(skdev, &skdev->cq_dma_address);
}
skdev->skcomp_table = NULL;
}
/*
*
* Name: skd_free_skmsg, deallocates skmsg table DMA resources.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_free_skmsg(struct skd_device *skdev)
{
uint32_t i;
if (NULL == skdev->skmsg_table)
return;
for (i = 0; i < skdev->num_fitmsg_context; i++) {
struct skd_fitmsg_context *skmsg;
skmsg = &skdev->skmsg_table[i];
if (skmsg->msg_buf != NULL) {
skd_free_phys(skdev, &skmsg->mb_dma_address);
}
skmsg->msg_buf = NULL;
}
kmem_free(skdev->skmsg_table, sizeof (struct skd_fitmsg_context) *
skdev->num_fitmsg_context);
skdev->skmsg_table = NULL;
}
/*
*
* Name: skd_free_skreq, deallocates skspcl table DMA resources.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_free_skreq(struct skd_device *skdev)
{
uint32_t i;
if (NULL == skdev->skreq_table)
return;
for (i = 0; i < skdev->num_req_context; i++) {
struct skd_request_context *skreq;
skreq = &skdev->skreq_table[i];
skd_free_sg_list(skdev, skreq->sksg_list,
skdev->sgs_per_request, skreq->sksg_dma_address);
skreq->sksg_list = NULL;
}
kmem_free(skdev->skreq_table, sizeof (struct skd_request_context) *
skdev->num_req_context);
skdev->skreq_table = NULL;
}
/*
*
* Name: skd_free_sksb, deallocates skspcl data buf and
* msg buf DMA resources.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_free_sksb(struct skd_device *skdev)
{
struct skd_special_context *skspcl;
skspcl = &skdev->internal_skspcl;
if (skspcl->data_buf != NULL) {
skd_free_phys(skdev, &skspcl->db_dma_address);
}
skspcl->data_buf = NULL;
if (skspcl->msg_buf != NULL) {
skd_free_phys(skdev, &skspcl->mb_dma_address);
}
skspcl->msg_buf = NULL;
skd_free_sg_list(skdev, skspcl->req.sksg_list, 1,
skspcl->req.sksg_dma_address);
skspcl->req.sksg_list = NULL;
}
/*
*
* Name: skd_free_sg_list, deallocates S/G DMA resources.
*
* Inputs: skdev - device state structure.
* sg_list - S/G list itself.
* n_sg - nukmber of segments
* dma_addr - S/G list DMA address.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_free_sg_list(struct skd_device *skdev,
struct fit_sg_descriptor *sg_list,
uint32_t n_sg, dma_mem_t dma_addr)
{
if (sg_list != NULL) {
skd_free_phys(skdev, &dma_addr);
}
}
/*
*
* Name: skd_queue, queues the I/O request.
*
* Inputs: skdev - device state structure.
* pbuf - I/O request
*
* Returns: Nothing.
*
*/
static void
skd_queue(skd_device_t *skdev, skd_buf_private_t *pbuf)
{
struct waitqueue *waitq;
ASSERT(skdev != NULL);
ASSERT(pbuf != NULL);
ASSERT(WAITQ_LOCK_HELD(skdev));
waitq = &skdev->waitqueue;
if (SIMPLEQ_EMPTY(waitq))
SIMPLEQ_INSERT_HEAD(waitq, pbuf, sq);
else
SIMPLEQ_INSERT_TAIL(waitq, pbuf, sq);
}
/*
*
* Name: skd_list_skreq, displays the skreq table entries.
*
* Inputs: skdev - device state structure.
* list - flag, if true displays the entry address.
*
* Returns: Returns number of skmsg entries found.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static int
skd_list_skreq(skd_device_t *skdev, int list)
{
int inx = 0;
struct skd_request_context *skreq;
if (list) {
Dcmn_err(CE_NOTE, "skreq_table[0]\n");
skreq = &skdev->skreq_table[0];
while (skreq) {
if (list)
Dcmn_err(CE_NOTE,
"%d: skreq=%p state=%d id=%x fid=%x "
"pbuf=%p dir=%d comp=%d\n",
inx, (void *)skreq, skreq->state,
skreq->id, skreq->fitmsg_id,
(void *)skreq->pbuf,
skreq->sg_data_dir, skreq->did_complete);
inx++;
skreq = skreq->next;
}
}
inx = 0;
skreq = skdev->skreq_free_list;
if (list)
Dcmn_err(CE_NOTE, "skreq_free_list\n");
while (skreq) {
if (list)
Dcmn_err(CE_NOTE, "%d: skreq=%p state=%d id=%x fid=%x "
"pbuf=%p dir=%d\n", inx, (void *)skreq,
skreq->state, skreq->id, skreq->fitmsg_id,
(void *)skreq->pbuf, skreq->sg_data_dir);
inx++;
skreq = skreq->next;
}
return (inx);
}
/*
*
* Name: skd_list_skmsg, displays the skmsg table entries.
*
* Inputs: skdev - device state structure.
* list - flag, if true displays the entry address.
*
* Returns: Returns number of skmsg entries found.
*
*/
static int
skd_list_skmsg(skd_device_t *skdev, int list)
{
int inx = 0;
struct skd_fitmsg_context *skmsgp;
skmsgp = &skdev->skmsg_table[0];
if (list) {
Dcmn_err(CE_NOTE, "skmsg_table[0]\n");
while (skmsgp) {
if (list)
Dcmn_err(CE_NOTE, "%d: skmsgp=%p id=%x outs=%d "
"l=%d o=%d nxt=%p\n", inx, (void *)skmsgp,
skmsgp->id, skmsgp->outstanding,
skmsgp->length, skmsgp->offset,
(void *)skmsgp->next);
inx++;
skmsgp = skmsgp->next;
}
}
inx = 0;
if (list)
Dcmn_err(CE_NOTE, "skmsg_free_list\n");
skmsgp = skdev->skmsg_free_list;
while (skmsgp) {
if (list)
Dcmn_err(CE_NOTE, "%d: skmsgp=%p id=%x outs=%d l=%d "
"o=%d nxt=%p\n",
inx, (void *)skmsgp, skmsgp->id,
skmsgp->outstanding, skmsgp->length,
skmsgp->offset, (void *)skmsgp->next);
inx++;
skmsgp = skmsgp->next;
}
return (inx);
}
/*
*
* Name: skd_get_queue_pbuf, retrieves top of queue entry and
* delinks entry from the queue.
*
* Inputs: skdev - device state structure.
* drive - device number
*
* Returns: Returns the top of the job queue entry.
*
*/
static skd_buf_private_t
*skd_get_queued_pbuf(skd_device_t *skdev)
{
skd_buf_private_t *pbuf;
ASSERT(WAITQ_LOCK_HELD(skdev));
pbuf = SIMPLEQ_FIRST(&skdev->waitqueue);
if (pbuf != NULL)
SIMPLEQ_REMOVE_HEAD(&skdev->waitqueue, sq);
return (pbuf);
}
/*
* PCI DRIVER GLUE
*/
/*
*
* Name: skd_pci_info, logs certain device PCI info.
*
* Inputs: skdev - device state structure.
*
* Returns: str which contains the device speed info..
*
*/
static char *
skd_pci_info(struct skd_device *skdev, char *str, size_t len)
{
int pcie_reg;
str[0] = '\0';
pcie_reg = skd_pci_find_capability(skdev, PCI_CAP_ID_EXP);
if (pcie_reg) {
uint16_t lstat, lspeed, lwidth;
pcie_reg += 0x12;
lstat = pci_config_get16(skdev->pci_handle, pcie_reg);
lspeed = lstat & (0xF);
lwidth = (lstat & 0x3F0) >> 4;
(void) snprintf(str, len, "PCIe (%s rev %d)",
lspeed == 1 ? "2.5GT/s" :
lspeed == 2 ? "5.0GT/s" : "<unknown>",
lwidth);
}
return (str);
}
/*
* MODULE GLUE
*/
/*
*
* Name: skd_init, initializes certain values.
*
* Inputs: skdev - device state structure.
*
* Returns: Zero.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static int
skd_init(skd_device_t *skdev)
{
Dcmn_err(CE_NOTE, "skd_init: v%s-b%s\n", DRV_VERSION, DRV_BUILD_ID);
if (skd_max_queue_depth < 1 ||
skd_max_queue_depth > SKD_MAX_QUEUE_DEPTH) {
cmn_err(CE_NOTE, "skd_max_q_depth %d invalid, re-set to %d\n",
skd_max_queue_depth, SKD_MAX_QUEUE_DEPTH_DEFAULT);
skd_max_queue_depth = SKD_MAX_QUEUE_DEPTH_DEFAULT;
}
if (skd_max_req_per_msg < 1 || skd_max_req_per_msg > 14) {
cmn_err(CE_NOTE, "skd_max_req_per_msg %d invalid, set to %d\n",
skd_max_req_per_msg, SKD_MAX_REQ_PER_MSG_DEFAULT);
skd_max_req_per_msg = SKD_MAX_REQ_PER_MSG_DEFAULT;
}
if (skd_sgs_per_request < 1 || skd_sgs_per_request > 4096) {
cmn_err(CE_NOTE, "skd_sg_per_request %d invalid, set to %d\n",
skd_sgs_per_request, SKD_N_SG_PER_REQ_DEFAULT);
skd_sgs_per_request = SKD_N_SG_PER_REQ_DEFAULT;
}
if (skd_dbg_level < 0 || skd_dbg_level > 2) {
cmn_err(CE_NOTE, "skd_dbg_level %d invalid, re-set to %d\n",
skd_dbg_level, 0);
skd_dbg_level = 0;
}
return (0);
}
/*
*
* Name: skd_exit, exits the driver & logs the fact.
*
* Inputs: none.
*
* Returns: Nothing.
*
*/
static void
skd_exit(void)
{
cmn_err(CE_NOTE, "skd v%s unloading", DRV_VERSION);
}
/*
*
* Name: skd_drive_state_to_str, converts binary drive state
* to its corresponding string value.
*
* Inputs: Drive state.
*
* Returns: String representing drive state.
*
*/
const char *
skd_drive_state_to_str(int state)
{
switch (state) {
case FIT_SR_DRIVE_OFFLINE: return ("OFFLINE");
case FIT_SR_DRIVE_INIT: return ("INIT");
case FIT_SR_DRIVE_ONLINE: return ("ONLINE");
case FIT_SR_DRIVE_BUSY: return ("BUSY");
case FIT_SR_DRIVE_FAULT: return ("FAULT");
case FIT_SR_DRIVE_DEGRADED: return ("DEGRADED");
case FIT_SR_PCIE_LINK_DOWN: return ("LINK_DOWN");
case FIT_SR_DRIVE_SOFT_RESET: return ("SOFT_RESET");
case FIT_SR_DRIVE_NEED_FW_DOWNLOAD: return ("NEED_FW");
case FIT_SR_DRIVE_INIT_FAULT: return ("INIT_FAULT");
case FIT_SR_DRIVE_BUSY_SANITIZE:return ("BUSY_SANITIZE");
case FIT_SR_DRIVE_BUSY_ERASE: return ("BUSY_ERASE");
case FIT_SR_DRIVE_FW_BOOTING: return ("FW_BOOTING");
default: return ("???");
}
}
/*
*
* Name: skd_skdev_state_to_str, converts binary driver state
* to its corresponding string value.
*
* Inputs: Driver state.
*
* Returns: String representing driver state.
*
*/
static const char *
skd_skdev_state_to_str(enum skd_drvr_state state)
{
switch (state) {
case SKD_DRVR_STATE_LOAD: return ("LOAD");
case SKD_DRVR_STATE_IDLE: return ("IDLE");
case SKD_DRVR_STATE_BUSY: return ("BUSY");
case SKD_DRVR_STATE_STARTING: return ("STARTING");
case SKD_DRVR_STATE_ONLINE: return ("ONLINE");
case SKD_DRVR_STATE_PAUSING: return ("PAUSING");
case SKD_DRVR_STATE_PAUSED: return ("PAUSED");
case SKD_DRVR_STATE_DRAINING_TIMEOUT: return ("DRAINING_TIMEOUT");
case SKD_DRVR_STATE_RESTARTING: return ("RESTARTING");
case SKD_DRVR_STATE_RESUMING: return ("RESUMING");
case SKD_DRVR_STATE_STOPPING: return ("STOPPING");
case SKD_DRVR_STATE_SYNCING: return ("SYNCING");
case SKD_DRVR_STATE_FAULT: return ("FAULT");
case SKD_DRVR_STATE_DISAPPEARED: return ("DISAPPEARED");
case SKD_DRVR_STATE_BUSY_ERASE: return ("BUSY_ERASE");
case SKD_DRVR_STATE_BUSY_SANITIZE:return ("BUSY_SANITIZE");
case SKD_DRVR_STATE_BUSY_IMMINENT: return ("BUSY_IMMINENT");
case SKD_DRVR_STATE_WAIT_BOOT: return ("WAIT_BOOT");
default: return ("???");
}
}
/*
*
* Name: skd_skmsg_state_to_str, converts binary driver state
* to its corresponding string value.
*
* Inputs: Msg state.
*
* Returns: String representing msg state.
*
*/
static const char *
skd_skmsg_state_to_str(enum skd_fit_msg_state state)
{
switch (state) {
case SKD_MSG_STATE_IDLE: return ("IDLE");
case SKD_MSG_STATE_BUSY: return ("BUSY");
default: return ("???");
}
}
/*
*
* Name: skd_skreq_state_to_str, converts binary req state
* to its corresponding string value.
*
* Inputs: Req state.
*
* Returns: String representing req state.
*
*/
static const char *
skd_skreq_state_to_str(enum skd_req_state state)
{
switch (state) {
case SKD_REQ_STATE_IDLE: return ("IDLE");
case SKD_REQ_STATE_SETUP: return ("SETUP");
case SKD_REQ_STATE_BUSY: return ("BUSY");
case SKD_REQ_STATE_COMPLETED: return ("COMPLETED");
case SKD_REQ_STATE_TIMEOUT: return ("TIMEOUT");
case SKD_REQ_STATE_ABORTED: return ("ABORTED");
default: return ("???");
}
}
/*
*
* Name: skd_log_skdev, logs device state & parameters.
*
* Inputs: skdev - device state structure.
* event - event (string) to log.
*
* Returns: Nothing.
*
*/
static void
skd_log_skdev(struct skd_device *skdev, const char *event)
{
Dcmn_err(CE_NOTE, "log_skdev(%s) skdev=%p event='%s'",
skdev->name, (void *)skdev, event);
Dcmn_err(CE_NOTE, " drive_state=%s(%d) driver_state=%s(%d)",
skd_drive_state_to_str(skdev->drive_state), skdev->drive_state,
skd_skdev_state_to_str(skdev->state), skdev->state);
Dcmn_err(CE_NOTE, " busy=%d limit=%d soft=%d hard=%d lowat=%d",
skdev->queue_depth_busy, skdev->queue_depth_limit,
skdev->soft_queue_depth_limit, skdev->hard_queue_depth_limit,
skdev->queue_depth_lowat);
Dcmn_err(CE_NOTE, " timestamp=0x%x cycle=%d cycle_ix=%d",
skdev->timeout_stamp, skdev->skcomp_cycle, skdev->skcomp_ix);
}
/*
*
* Name: skd_log_skmsg, logs the skmsg event.
*
* Inputs: skdev - device state structure.
* skmsg - FIT message structure.
* event - event string to log.
*
* Returns: Nothing.
*
*/
static void
skd_log_skmsg(struct skd_device *skdev,
struct skd_fitmsg_context *skmsg, const char *event)
{
Dcmn_err(CE_NOTE, "log_skmsg:(%s) skmsg=%p event='%s'",
skdev->name, (void *)skmsg, event);
Dcmn_err(CE_NOTE, " state=%s(%d) id=0x%04x length=%d",
skd_skmsg_state_to_str(skmsg->state), skmsg->state,
skmsg->id, skmsg->length);
}
/*
*
* Name: skd_log_skreq, logs the skreq event.
*
* Inputs: skdev - device state structure.
* skreq -skreq structure.
* event - event string to log.
*
* Returns: Nothing.
*
*/
static void
skd_log_skreq(struct skd_device *skdev,
struct skd_request_context *skreq, const char *event)
{
skd_buf_private_t *pbuf;
Dcmn_err(CE_NOTE, "log_skreq: (%s) skreq=%p pbuf=%p event='%s'",
skdev->name, (void *)skreq, (void *)skreq->pbuf, event);
Dcmn_err(CE_NOTE, " state=%s(%d) id=0x%04x fitmsg=0x%04x",
skd_skreq_state_to_str(skreq->state), skreq->state,
skreq->id, skreq->fitmsg_id);
Dcmn_err(CE_NOTE, " timo=0x%x sg_dir=%d n_sg=%d",
skreq->timeout_stamp, skreq->sg_data_dir, skreq->n_sg);
if ((pbuf = skreq->pbuf) != NULL) {
uint32_t lba, count;
lba = pbuf->x_xfer->x_blkno;
count = pbuf->x_xfer->x_nblks;
Dcmn_err(CE_NOTE, " pbuf=%p lba=%u(0x%x) count=%u(0x%x) ",
(void *)pbuf, lba, lba, count, count);
Dcmn_err(CE_NOTE, " dir=%s "
" intrs=%" PRId64 " qdepth=%d",
(pbuf->dir & B_READ) ? "Read" : "Write",
skdev->intr_cntr, skdev->queue_depth_busy);
} else {
Dcmn_err(CE_NOTE, " req=NULL\n");
}
}
/*
*
* Name: skd_init_mutex, initializes all mutexes.
*
* Inputs: skdev - device state structure.
*
* Returns: DDI_FAILURE on failure otherwise DDI_SUCCESS.
*
*/
static int
skd_init_mutex(skd_device_t *skdev)
{
void *intr;
Dcmn_err(CE_CONT, "(%s%d): init_mutex flags=%x", DRV_NAME,
skdev->instance, skdev->flags);
intr = (void *)(uintptr_t)skdev->intr_pri;
if (skdev->flags & SKD_MUTEX_INITED)
cmn_err(CE_NOTE, "init_mutex: Oh-Oh - already INITED");
/* mutexes to protect the adapter state structure. */
mutex_init(&skdev->skd_lock_mutex, NULL, MUTEX_DRIVER,
DDI_INTR_PRI(intr));
mutex_init(&skdev->skd_intr_mutex, NULL, MUTEX_DRIVER,
DDI_INTR_PRI(intr));
mutex_init(&skdev->waitqueue_mutex, NULL, MUTEX_DRIVER,
DDI_INTR_PRI(intr));
mutex_init(&skdev->skd_internalio_mutex, NULL, MUTEX_DRIVER,
DDI_INTR_PRI(intr));
cv_init(&skdev->cv_waitq, NULL, CV_DRIVER, NULL);
skdev->flags |= SKD_MUTEX_INITED;
if (skdev->flags & SKD_MUTEX_DESTROYED)
skdev->flags &= ~SKD_MUTEX_DESTROYED;
Dcmn_err(CE_CONT, "init_mutex (%s%d): done, flags=%x", DRV_NAME,
skdev->instance, skdev->flags);
return (DDI_SUCCESS);
}
/*
*
* Name: skd_destroy_mutex, destroys all mutexes.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_destroy_mutex(skd_device_t *skdev)
{
if ((skdev->flags & SKD_MUTEX_DESTROYED) == 0) {
if (skdev->flags & SKD_MUTEX_INITED) {
mutex_destroy(&skdev->waitqueue_mutex);
mutex_destroy(&skdev->skd_intr_mutex);
mutex_destroy(&skdev->skd_lock_mutex);
mutex_destroy(&skdev->skd_internalio_mutex);
cv_destroy(&skdev->cv_waitq);
skdev->flags |= SKD_MUTEX_DESTROYED;
if (skdev->flags & SKD_MUTEX_INITED)
skdev->flags &= ~SKD_MUTEX_INITED;
}
}
}
/*
*
* Name: skd_setup_intr, setup the interrupt handling
*
* Inputs: skdev - device state structure.
* intr_type - requested DDI interrupt type.
*
* Returns: DDI_FAILURE on failure otherwise DDI_SUCCESS.
*
*/
static int
skd_setup_intr(skd_device_t *skdev, int intr_type)
{
int32_t count = 0;
int32_t avail = 0;
int32_t actual = 0;
int32_t ret;
uint32_t i;
Dcmn_err(CE_CONT, "(%s%d): setup_intr", DRV_NAME, skdev->instance);
/* Get number of interrupts the platform h/w supports */
if (((ret = ddi_intr_get_nintrs(skdev->dip, intr_type, &count)) !=
DDI_SUCCESS) || count == 0) {
cmn_err(CE_WARN, "!intr_setup failed, nintrs ret=%xh, cnt=%xh",
ret, count);
return (DDI_FAILURE);
}
/* Get number of available system interrupts */
if (((ret = ddi_intr_get_navail(skdev->dip, intr_type, &avail)) !=
DDI_SUCCESS) || avail == 0) {
cmn_err(CE_WARN, "!intr_setup failed, navail ret=%xh, "
"avail=%xh", ret, avail);
return (DDI_FAILURE);
}
if (intr_type == DDI_INTR_TYPE_MSIX && avail < SKD_MSIX_MAXAIF) {
cmn_err(CE_WARN, "!intr_setup failed, min MSI-X h/w vectors "
"req'd: %d, avail: %d",
SKD_MSIX_MAXAIF, count);
return (DDI_FAILURE);
}
/* Allocate space for interrupt handles */
skdev->hsize = sizeof (ddi_intr_handle_t) * avail;
skdev->htable = kmem_zalloc(skdev->hsize, KM_SLEEP);
/* Allocate the interrupts */
if ((ret = ddi_intr_alloc(skdev->dip, skdev->htable, intr_type,
0, count, &actual, 0)) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!intr_setup failed, intr_alloc ret=%xh, "
"count = %xh, " "actual=%xh", ret, count, actual);
skd_release_intr(skdev);
return (DDI_FAILURE);
}
skdev->intr_cnt = actual;
if (intr_type == DDI_INTR_TYPE_FIXED)
(void) ddi_intr_set_pri(skdev->htable[0], 10);
/* Get interrupt priority */
if ((ret = ddi_intr_get_pri(skdev->htable[0], &skdev->intr_pri)) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "!intr_setup failed, get_pri ret=%xh", ret);
skd_release_intr(skdev);
return (ret);
}
/* Add the interrupt handlers */
for (i = 0; i < actual; i++) {
if ((ret = ddi_intr_add_handler(skdev->htable[i],
skd_isr_aif, (void *)skdev, (void *)((ulong_t)i))) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "!intr_setup failed, addh#=%xh, "
"act=%xh, ret=%xh", i, actual, ret);
skd_release_intr(skdev);
return (ret);
}
}
/* Setup mutexes */
if ((ret = skd_init_mutex(skdev)) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!intr_setup failed, mutex init ret=%xh", ret);
skd_release_intr(skdev);
return (ret);
}
/* Get the capabilities */
(void) ddi_intr_get_cap(skdev->htable[0], &skdev->intr_cap);
/* Enable interrupts */
if (skdev->intr_cap & DDI_INTR_FLAG_BLOCK) {
if ((ret = ddi_intr_block_enable(skdev->htable,
skdev->intr_cnt)) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!failed, intr_setup block enable, "
"ret=%xh", ret);
skd_destroy_mutex(skdev);
skd_release_intr(skdev);
return (ret);
}
} else {
for (i = 0; i < skdev->intr_cnt; i++) {
if ((ret = ddi_intr_enable(skdev->htable[i])) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "!intr_setup failed, "
"intr enable, ret=%xh", ret);
skd_destroy_mutex(skdev);
skd_release_intr(skdev);
return (ret);
}
}
}
if (intr_type == DDI_INTR_TYPE_FIXED)
(void) ddi_intr_clr_mask(skdev->htable[0]);
skdev->irq_type = intr_type;
return (DDI_SUCCESS);
}
/*
*
* Name: skd_disable_intr, disable interrupt handling.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_disable_intr(skd_device_t *skdev)
{
uint32_t i, rval;
if (skdev->intr_cap & DDI_INTR_FLAG_BLOCK) {
/* Remove AIF block interrupts (MSI/MSI-X) */
if ((rval = ddi_intr_block_disable(skdev->htable,
skdev->intr_cnt)) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!failed intr block disable, rval=%x",
rval);
}
} else {
/* Remove AIF non-block interrupts (fixed). */
for (i = 0; i < skdev->intr_cnt; i++) {
if ((rval = ddi_intr_disable(skdev->htable[i])) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "!failed intr disable, "
"intr#=%xh, " "rval=%xh", i, rval);
}
}
}
}
/*
*
* Name: skd_release_intr, disables interrupt handling.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_release_intr(skd_device_t *skdev)
{
int32_t i;
int rval;
Dcmn_err(CE_CONT, "REL_INTR intr_cnt=%d", skdev->intr_cnt);
if (skdev->irq_type == 0) {
Dcmn_err(CE_CONT, "release_intr: (%s%d): done",
DRV_NAME, skdev->instance);
return;
}
if (skdev->htable != NULL && skdev->hsize > 0) {
i = (int32_t)skdev->hsize / (int32_t)sizeof (ddi_intr_handle_t);
while (i-- > 0) {
if (skdev->htable[i] == 0) {
Dcmn_err(CE_NOTE, "htable[%x]=0h", i);
continue;
}
if ((rval = ddi_intr_disable(skdev->htable[i])) !=
DDI_SUCCESS)
Dcmn_err(CE_NOTE, "release_intr: intr_disable "
"htable[%d], rval=%d", i, rval);
if (i < skdev->intr_cnt) {
if ((rval = ddi_intr_remove_handler(
skdev->htable[i])) != DDI_SUCCESS)
cmn_err(CE_WARN, "!release_intr: "
"intr_remove_handler FAILED, "
"rval=%d", rval);
Dcmn_err(CE_NOTE, "release_intr: "
"remove_handler htable[%d]", i);
}
if ((rval = ddi_intr_free(skdev->htable[i])) !=
DDI_SUCCESS)
cmn_err(CE_WARN, "!release_intr: intr_free "
"FAILED, rval=%d", rval);
Dcmn_err(CE_NOTE, "release_intr: intr_free htable[%d]",
i);
}
kmem_free(skdev->htable, skdev->hsize);
skdev->htable = NULL;
}
skdev->hsize = 0;
skdev->intr_cnt = 0;
skdev->intr_pri = 0;
skdev->intr_cap = 0;
skdev->irq_type = 0;
}
/*
*
* Name: skd_dealloc_resources, deallocate resources allocated
* during attach.
*
* Inputs: dip - DDI device info pointer.
* skdev - device state structure.
* seq - bit flag representing allocated item.
* instance - device instance.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_dealloc_resources(dev_info_t *dip, skd_device_t *skdev,
uint32_t seq, int instance)
{
if (skdev == NULL)
return;
if (seq & SKD_CONSTRUCTED)
skd_destruct(skdev);
if (seq & SKD_INTR_ADDED) {
skd_disable_intr(skdev);
skd_release_intr(skdev);
}
if (seq & SKD_DEV_IOBASE_MAPPED)
ddi_regs_map_free(&skdev->dev_handle);
if (seq & SKD_IOMAP_IOBASE_MAPPED)
ddi_regs_map_free(&skdev->iomap_handle);
if (seq & SKD_REGS_MAPPED)
ddi_regs_map_free(&skdev->iobase_handle);
if (seq & SKD_CONFIG_SPACE_SETUP)
pci_config_teardown(&skdev->pci_handle);
if (seq & SKD_SOFT_STATE_ALLOCED) {
if (skdev->pathname &&
(skdev->flags & SKD_PATHNAME_ALLOCED)) {
kmem_free(skdev->pathname,
strlen(skdev->pathname)+1);
}
}
if (skdev->s1120_devid)
ddi_devid_free(skdev->s1120_devid);
}
/*
*
* Name: skd_setup_interrupt, sets up the appropriate interrupt type
* msi, msix, or fixed.
*
* Inputs: skdev - device state structure.
*
* Returns: DDI_FAILURE on failure otherwise DDI_SUCCESS.
*
*/
static int
skd_setup_interrupts(skd_device_t *skdev)
{
int32_t rval = DDI_FAILURE;
int32_t i;
int32_t itypes = 0;
/*
* See what types of interrupts this adapter and platform support
*/
if ((i = ddi_intr_get_supported_types(skdev->dip, &itypes)) !=
DDI_SUCCESS) {
cmn_err(CE_NOTE, "intr supported types failed, rval=%xh, ", i);
return (DDI_FAILURE);
}
Dcmn_err(CE_NOTE, "%s:supported interrupts types: %x",
skdev->name, itypes);
itypes &= skdev->irq_type;
if (!skd_disable_msix && (itypes & DDI_INTR_TYPE_MSIX) &&
(rval = skd_setup_intr(skdev, DDI_INTR_TYPE_MSIX)) == DDI_SUCCESS) {
cmn_err(CE_NOTE, "!%s: successful MSI-X setup",
skdev->name);
} else if (!skd_disable_msi && (itypes & DDI_INTR_TYPE_MSI) &&
(rval = skd_setup_intr(skdev, DDI_INTR_TYPE_MSI)) == DDI_SUCCESS) {
cmn_err(CE_NOTE, "!%s: successful MSI setup",
skdev->name);
} else if ((itypes & DDI_INTR_TYPE_FIXED) &&
(rval = skd_setup_intr(skdev, DDI_INTR_TYPE_FIXED))
== DDI_SUCCESS) {
cmn_err(CE_NOTE, "!%s: successful fixed intr setup",
skdev->name);
} else {
cmn_err(CE_WARN, "!%s: no supported interrupt types",
skdev->name);
return (DDI_FAILURE);
}
Dcmn_err(CE_CONT, "%s: setup interrupts done", skdev->name);
return (rval);
}
/*
*
* Name: skd_get_properties, retrieves properties from skd.conf.
*
* Inputs: skdev - device state structure.
* dip - dev_info data structure.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static void
skd_get_properties(dev_info_t *dip, skd_device_t *skdev)
{
int prop_value;
skd_isr_type = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
"intr-type-cap", -1);
prop_value = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
"max-scsi-reqs", -1);
if (prop_value >= 1 && prop_value <= SKD_MAX_QUEUE_DEPTH)
skd_max_queue_depth = prop_value;
prop_value = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
"max-scsi-reqs-per-msg", -1);
if (prop_value >= 1 && prop_value <= SKD_MAX_REQ_PER_MSG)
skd_max_req_per_msg = prop_value;
prop_value = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
"max-sgs-per-req", -1);
if (prop_value >= 1 && prop_value <= SKD_MAX_N_SG_PER_REQ)
skd_sgs_per_request = prop_value;
prop_value = ddi_prop_get_int(DDI_DEV_T_ANY, dip, 0,
"dbg-level", -1);
if (prop_value >= 1 && prop_value <= 2)
skd_dbg_level = prop_value;
}
/*
*
* Name: skd_wait_for_s1120, wait for device to finish
* its initialization.
*
* Inputs: skdev - device state structure.
*
* Returns: DDI_SUCCESS or DDI_FAILURE.
*
*/
static int
skd_wait_for_s1120(skd_device_t *skdev)
{
clock_t cur_ticks, tmo;
int loop_cntr = 0;
int rc = DDI_FAILURE;
mutex_enter(&skdev->skd_internalio_mutex);
while (skdev->gendisk_on == 0) {
cur_ticks = ddi_get_lbolt();
tmo = cur_ticks + drv_usectohz(MICROSEC);
if (cv_timedwait(&skdev->cv_waitq,
&skdev->skd_internalio_mutex, tmo) == -1) {
/* Oops - timed out */
if (loop_cntr++ > 10)
break;
}
}
mutex_exit(&skdev->skd_internalio_mutex);
if (skdev->gendisk_on == 1)
rc = DDI_SUCCESS;
return (rc);
}
/*
*
* Name: skd_update_props, updates certain device properties.
*
* Inputs: skdev - device state structure.
* dip - dev info structure
*
* Returns: Nothing.
*
*/
static void
skd_update_props(skd_device_t *skdev, dev_info_t *dip)
{
int blksize = 512;
if ((ddi_prop_update_int64(DDI_DEV_T_NONE, dip, "device-nblocks",
skdev->Nblocks) != DDI_SUCCESS) ||
(ddi_prop_update_int(DDI_DEV_T_NONE, dip, "device-blksize",
blksize) != DDI_SUCCESS)) {
cmn_err(CE_NOTE, "%s: FAILED to create driver properties",
skdev->name);
}
}
/*
*
* Name: skd_setup_devid, sets up device ID info.
*
* Inputs: skdev - device state structure.
* devid - Device ID for the DDI.
*
* Returns: DDI_SUCCESS or DDI_FAILURE.
*
*/
static int
skd_setup_devid(skd_device_t *skdev, ddi_devid_t *devid)
{
int rc, sz_model, sz_sn, sz;
sz_model = scsi_ascii_inquiry_len(skdev->inq_product_id,
strlen(skdev->inq_product_id));
sz_sn = scsi_ascii_inquiry_len(skdev->inq_serial_num,
strlen(skdev->inq_serial_num));
sz = sz_model + sz_sn + 1;
(void) snprintf(skdev->devid_str, sizeof (skdev->devid_str),
"%.*s=%.*s", sz_model, skdev->inq_product_id, sz_sn,
skdev->inq_serial_num);
rc = ddi_devid_init(skdev->dip, DEVID_SCSI_SERIAL, sz,
skdev->devid_str, devid);
if (rc != DDI_SUCCESS)
cmn_err(CE_WARN, "!%s: devid_init FAILED", skdev->name);
return (rc);
}
/*
*
* Name: skd_bd_attach, attach to blkdev driver
*
* Inputs: skdev - device state structure.
* dip - device info structure.
*
* Returns: DDI_SUCCESS or DDI_FAILURE.
*
*/
static int
skd_bd_attach(dev_info_t *dip, skd_device_t *skdev)
{
int rv;
skdev->s_bdh = bd_alloc_handle(skdev, &skd_bd_ops,
&skd_64bit_io_dma_attr, KM_SLEEP);
if (skdev->s_bdh == NULL) {
cmn_err(CE_WARN, "!skd_bd_attach: FAILED");
return (DDI_FAILURE);
}
rv = bd_attach_handle(dip, skdev->s_bdh);
if (rv != DDI_SUCCESS) {
cmn_err(CE_WARN, "!bd_attach_handle FAILED\n");
} else {
Dcmn_err(CE_NOTE, "bd_attach_handle OK\n");
skdev->bd_attached++;
}
return (rv);
}
/*
*
* Name: skd_bd_detach, detach from the blkdev driver.
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_bd_detach(skd_device_t *skdev)
{
if (skdev->bd_attached)
(void) bd_detach_handle(skdev->s_bdh);
bd_free_handle(skdev->s_bdh);
}
/*
*
* Name: skd_attach, attach sdk device driver
*
* Inputs: dip - device info structure.
* cmd - DDI attach argument (ATTACH, RESUME, etc.)
*
* Returns: DDI_SUCCESS or DDI_FAILURE.
*
*/
static int
skd_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int instance;
int nregs;
skd_device_t *skdev = NULL;
int inx;
uint16_t cmd_reg;
int progress = 0;
char name[MAXPATHLEN];
off_t regsize;
char pci_str[32];
char fw_version[8];
instance = ddi_get_instance(dip);
(void) ddi_get_parent_data(dip);
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
/* Re-enable timer */
skd_start_timer(skdev);
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
Dcmn_err(CE_NOTE, "sTec S1120 Driver v%s Instance: %d",
VERSIONSTR, instance);
/*
* Check that hardware is installed in a DMA-capable slot
*/
if (ddi_slaveonly(dip) == DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s%d: installed in a "
"slot that isn't DMA-capable slot", DRV_NAME, instance);
return (DDI_FAILURE);
}
/*
* No support for high-level interrupts
*/
if (ddi_intr_hilevel(dip, 0) != 0) {
cmn_err(CE_WARN, "!%s%d: High level interrupt not supported",
DRV_NAME, instance);
return (DDI_FAILURE);
}
/*
* Allocate our per-device-instance structure
*/
if (ddi_soft_state_zalloc(skd_state, instance) !=
DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s%d: soft state zalloc failed ",
DRV_NAME, instance);
return (DDI_FAILURE);
}
progress |= SKD_SOFT_STATE_ALLOCED;
skdev = ddi_get_soft_state(skd_state, instance);
if (skdev == NULL) {
cmn_err(CE_WARN, "!%s%d: Unable to get soft state structure",
DRV_NAME, instance);
goto skd_attach_failed;
}
(void) snprintf(skdev->name, sizeof (skdev->name),
DRV_NAME "%d", instance);
skdev->dip = dip;
skdev->instance = instance;
ddi_set_driver_private(dip, skdev);
(void) ddi_pathname(dip, name);
for (inx = strlen(name); inx; inx--) {
if (name[inx] == ',') {
name[inx] = '\0';
break;
}
if (name[inx] == '@') {
break;
}
}
skdev->pathname = kmem_zalloc(strlen(name) + 1, KM_SLEEP);
(void) strlcpy(skdev->pathname, name, strlen(name) + 1);
progress |= SKD_PATHNAME_ALLOCED;
skdev->flags |= SKD_PATHNAME_ALLOCED;
if (pci_config_setup(dip, &skdev->pci_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s%d: pci_config_setup FAILED",
DRV_NAME, instance);
goto skd_attach_failed;
}
progress |= SKD_CONFIG_SPACE_SETUP;
/* Save adapter path. */
(void) ddi_dev_nregs(dip, &nregs);
/*
* 0x0 Configuration Space
* 0x1 I/O Space
* 0x2 s1120 register space
*/
if (ddi_dev_regsize(dip, 1, &regsize) != DDI_SUCCESS ||
ddi_regs_map_setup(dip, 1, &skdev->iobase, 0, regsize,
&dev_acc_attr, &skdev->iobase_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s%d: regs_map_setup(mem) failed",
DRV_NAME, instance);
goto skd_attach_failed;
}
progress |= SKD_REGS_MAPPED;
skdev->iomap_iobase = skdev->iobase;
skdev->iomap_handle = skdev->iobase_handle;
Dcmn_err(CE_NOTE, "%s: PCI iobase=%ph, iomap=%ph, regnum=%d, "
"regsize=%ld", skdev->name, (void *)skdev->iobase,
(void *)skdev->iomap_iobase, 1, regsize);
if (ddi_dev_regsize(dip, 2, &regsize) != DDI_SUCCESS ||
ddi_regs_map_setup(dip, 2, &skdev->dev_iobase, 0, regsize,
&dev_acc_attr, &skdev->dev_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s%d: regs_map_setup(mem) failed",
DRV_NAME, instance);
goto skd_attach_failed;
}
skdev->dev_memsize = (int)regsize;
Dcmn_err(CE_NOTE, "%s: DEV iobase=%ph regsize=%d",
skdev->name, (void *)skdev->dev_iobase,
skdev->dev_memsize);
progress |= SKD_DEV_IOBASE_MAPPED;
cmd_reg = pci_config_get16(skdev->pci_handle, PCI_CONF_COMM);
cmd_reg |= (PCI_COMM_ME | PCI_COMM_INTX_DISABLE);
cmd_reg &= ~PCI_COMM_PARITY_DETECT;
pci_config_put16(skdev->pci_handle, PCI_CONF_COMM, cmd_reg);
/* Get adapter PCI device information. */
skdev->vendor_id = pci_config_get16(skdev->pci_handle, PCI_CONF_VENID);
skdev->device_id = pci_config_get16(skdev->pci_handle, PCI_CONF_DEVID);
Dcmn_err(CE_NOTE, "%s: %x-%x card detected",
skdev->name, skdev->vendor_id, skdev->device_id);
skd_get_properties(dip, skdev);
(void) skd_init(skdev);
if (skd_construct(skdev, instance)) {
cmn_err(CE_WARN, "!%s: construct FAILED", skdev->name);
goto skd_attach_failed;
}
progress |= SKD_PROBED;
progress |= SKD_CONSTRUCTED;
SIMPLEQ_INIT(&skdev->waitqueue);
/*
* Setup interrupt handler
*/
if (skd_setup_interrupts(skdev) != DDI_SUCCESS) {
cmn_err(CE_WARN, "!%s: Unable to add interrupt",
skdev->name);
goto skd_attach_failed;
}
progress |= SKD_INTR_ADDED;
ADAPTER_STATE_LOCK(skdev);
skdev->flags |= SKD_ATTACHED;
ADAPTER_STATE_UNLOCK(skdev);
skdev->d_blkshift = 9;
progress |= SKD_ATTACHED;
skd_start_device(skdev);
ADAPTER_STATE_LOCK(skdev);
skdev->progress = progress;
ADAPTER_STATE_UNLOCK(skdev);
/*
* Give the board a chance to
* complete its initialization.
*/
if (skdev->gendisk_on != 1)
(void) skd_wait_for_s1120(skdev);
if (skdev->gendisk_on != 1) {
cmn_err(CE_WARN, "!%s: s1120 failed to come ONLINE",
skdev->name);
goto skd_attach_failed;
}
ddi_report_dev(dip);
skd_send_internal_skspcl(skdev, &skdev->internal_skspcl, INQUIRY);
skdev->disks_initialized++;
(void) strcpy(fw_version, "???");
(void) skd_pci_info(skdev, pci_str, sizeof (pci_str));
Dcmn_err(CE_NOTE, " sTec S1120 Driver(%s) version %s-b%s",
DRV_NAME, DRV_VERSION, DRV_BUILD_ID);
Dcmn_err(CE_NOTE, " sTec S1120 %04x:%04x %s 64 bit",
skdev->vendor_id, skdev->device_id, pci_str);
Dcmn_err(CE_NOTE, " sTec S1120 %s\n", skdev->pathname);
if (*skdev->inq_serial_num)
Dcmn_err(CE_NOTE, " sTec S1120 serial#=%s",
skdev->inq_serial_num);
if (*skdev->inq_product_id &&
*skdev->inq_product_rev)
Dcmn_err(CE_NOTE, " sTec S1120 prod ID=%s prod rev=%s",
skdev->inq_product_id, skdev->inq_product_rev);
Dcmn_err(CE_NOTE, "%s: intr-type-cap: %d",
skdev->name, skdev->irq_type);
Dcmn_err(CE_NOTE, "%s: max-scsi-reqs: %d",
skdev->name, skd_max_queue_depth);
Dcmn_err(CE_NOTE, "%s: max-sgs-per-req: %d",
skdev->name, skd_sgs_per_request);
Dcmn_err(CE_NOTE, "%s: max-scsi-req-per-msg: %d",
skdev->name, skd_max_req_per_msg);
if (skd_bd_attach(dip, skdev) == DDI_FAILURE)
goto skd_attach_failed;
skd_update_props(skdev, dip);
/* Enable timer */
skd_start_timer(skdev);
ADAPTER_STATE_LOCK(skdev);
skdev->progress = progress;
ADAPTER_STATE_UNLOCK(skdev);
skdev->attached = 1;
return (DDI_SUCCESS);
skd_attach_failed:
skd_dealloc_resources(dip, skdev, progress, instance);
if ((skdev->flags & SKD_MUTEX_DESTROYED) == 0) {
skd_destroy_mutex(skdev);
}
ddi_soft_state_free(skd_state, instance);
cmn_err(CE_WARN, "!skd_attach FAILED: progress=%x", progress);
return (DDI_FAILURE);
}
/*
*
* Name: skd_halt
*
* Inputs: skdev - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_halt(skd_device_t *skdev)
{
Dcmn_err(CE_NOTE, "%s: halt/suspend ......", skdev->name);
}
/*
*
* Name: skd_detach, detaches driver from the system.
*
* Inputs: dip - device info structure.
*
* Returns: DDI_SUCCESS on successful detach otherwise DDI_FAILURE.
*
*/
static int
skd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
skd_buf_private_t *pbuf;
skd_device_t *skdev;
int instance;
timeout_id_t timer_id = NULL;
int rv1 = DDI_SUCCESS;
struct skd_special_context *skspcl;
instance = ddi_get_instance(dip);
skdev = ddi_get_soft_state(skd_state, instance);
if (skdev == NULL) {
cmn_err(CE_WARN, "!detach failed: NULL skd state");
return (DDI_FAILURE);
}
Dcmn_err(CE_CONT, "skd_detach(%d): entered", instance);
switch (cmd) {
case DDI_DETACH:
/* Test for packet cache inuse. */
ADAPTER_STATE_LOCK(skdev);
/* Stop command/event processing. */
skdev->flags |= (SKD_SUSPENDED | SKD_CMD_ABORT_TMO);
/* Disable driver timer if no adapters. */
if (skdev->skd_timer_timeout_id != 0) {
timer_id = skdev->skd_timer_timeout_id;
skdev->skd_timer_timeout_id = 0;
}
ADAPTER_STATE_UNLOCK(skdev);
if (timer_id != 0) {
(void) untimeout(timer_id);
}
#ifdef SKD_PM
if (skdev->power_level != LOW_POWER_LEVEL) {
skd_halt(skdev);
skdev->power_level = LOW_POWER_LEVEL;
}
#endif
skspcl = &skdev->internal_skspcl;
skd_send_internal_skspcl(skdev, skspcl, SYNCHRONIZE_CACHE);
skd_stop_device(skdev);
/*
* Clear request queue.
*/
while (!SIMPLEQ_EMPTY(&skdev->waitqueue)) {
pbuf = skd_get_queued_pbuf(skdev);
skd_end_request_abnormal(skdev, pbuf, ECANCELED,
SKD_IODONE_WNIOC);
Dcmn_err(CE_NOTE,
"detach: cancelled pbuf %p %ld <%s> %lld\n",
(void *)pbuf, pbuf->x_xfer->x_nblks,
(pbuf->dir & B_READ) ? "Read" : "Write",
pbuf->x_xfer->x_blkno);
}
skd_bd_detach(skdev);
skd_dealloc_resources(dip, skdev, skdev->progress, instance);
if ((skdev->flags & SKD_MUTEX_DESTROYED) == 0) {
skd_destroy_mutex(skdev);
}
ddi_soft_state_free(skd_state, instance);
skd_exit();
break;
case DDI_SUSPEND:
/* Block timer. */
ADAPTER_STATE_LOCK(skdev);
skdev->flags |= SKD_SUSPENDED;
/* Disable driver timer if last adapter. */
if (skdev->skd_timer_timeout_id != 0) {
timer_id = skdev->skd_timer_timeout_id;
skdev->skd_timer_timeout_id = 0;
}
ADAPTER_STATE_UNLOCK(skdev);
if (timer_id != 0) {
(void) untimeout(timer_id);
}
ddi_prop_remove_all(dip);
skd_halt(skdev);
break;
default:
rv1 = DDI_FAILURE;
break;
}
if (rv1 != DDI_SUCCESS) {
cmn_err(CE_WARN, "!skd_detach, failed, rv1=%x", rv1);
} else {
Dcmn_err(CE_CONT, "skd_detach: exiting");
}
if (rv1 != DDI_SUCCESS)
return (DDI_FAILURE);
return (rv1);
}
/*
*
* Name: skd_devid_init, calls skd_setup_devid to setup
* the device's devid structure.
*
* Inputs: arg - device state structure.
* dip - dev_info structure.
* devid - devid structure.
*
* Returns: Nothing.
*
*/
/* ARGSUSED */ /* Upstream common source with other platforms. */
static int
skd_devid_init(void *arg, dev_info_t *dip, ddi_devid_t *devid)
{
skd_device_t *skdev = arg;
(void) skd_setup_devid(skdev, devid);
return (0);
}
/*
*
* Name: skd_bd_driveinfo, retrieves device's info.
*
* Inputs: drive - drive data structure.
* arg - device state structure.
*
* Returns: Nothing.
*
*/
static void
skd_bd_driveinfo(void *arg, bd_drive_t *drive)
{
skd_device_t *skdev = arg;
drive->d_qsize = (skdev->queue_depth_limit * 4) / 5;
drive->d_maxxfer = SKD_DMA_MAXXFER;
drive->d_removable = B_FALSE;
drive->d_hotpluggable = B_FALSE;
drive->d_target = 0;
drive->d_lun = 0;
if (skdev->inquiry_is_valid != 0) {
drive->d_vendor = skdev->inq_vendor_id;
drive->d_vendor_len = strlen(drive->d_vendor);
drive->d_product = skdev->inq_product_id;
drive->d_product_len = strlen(drive->d_product);
drive->d_serial = skdev->inq_serial_num;
drive->d_serial_len = strlen(drive->d_serial);
drive->d_revision = skdev->inq_product_rev;
drive->d_revision_len = strlen(drive->d_revision);
}
}
/*
*
* Name: skd_bd_mediainfo, retrieves device media info.
*
* Inputs: arg - device state structure.
* media - container for media info.
*
* Returns: Zero.
*
*/
static int
skd_bd_mediainfo(void *arg, bd_media_t *media)
{
skd_device_t *skdev = arg;
media->m_nblks = skdev->Nblocks;
media->m_blksize = 512;
media->m_pblksize = 4096;
media->m_readonly = B_FALSE;
media->m_solidstate = B_TRUE;
return (0);
}
/*
*
* Name: skd_rw, performs R/W requests for blkdev driver.
*
* Inputs: skdev - device state structure.
* xfer - tranfer structure.
* dir - I/O direction.
*
* Returns: EAGAIN if device is not online. EIO if blkdev wants us to
* be a dump device (for now).
* Value returned by skd_start().
*
*/
static int
skd_rw(skd_device_t *skdev, bd_xfer_t *xfer, int dir)
{
skd_buf_private_t *pbuf;
/*
* The x_flags structure element is not defined in Oracle Solaris
*/
/* We'll need to fix this in order to support dump on this device. */
if (xfer->x_flags & BD_XFER_POLL)
return (EIO);
if (skdev->state != SKD_DRVR_STATE_ONLINE) {
Dcmn_err(CE_NOTE, "Device - not ONLINE");
skd_request_fn_not_online(skdev);
return (EAGAIN);
}
pbuf = kmem_zalloc(sizeof (skd_buf_private_t), KM_NOSLEEP);
if (pbuf == NULL)
return (ENOMEM);
WAITQ_LOCK(skdev);
pbuf->dir = dir;
pbuf->x_xfer = xfer;
skd_queue(skdev, pbuf);
skdev->ios_queued++;
WAITQ_UNLOCK(skdev);
skd_start(skdev);
return (0);
}
/*
*
* Name: skd_bd_read, performs blkdev read requests.
*
* Inputs: arg - device state structure.
* xfer - tranfer request structure.
*
* Returns: Value return by skd_rw().
*
*/
static int
skd_bd_read(void *arg, bd_xfer_t *xfer)
{
return (skd_rw(arg, xfer, B_READ));
}
/*
*
* Name: skd_bd_write, performs blkdev write requests.
*
* Inputs: arg - device state structure.
* xfer - tranfer request structure.
*
* Returns: Value return by skd_rw().
*
*/
static int
skd_bd_write(void *arg, bd_xfer_t *xfer)
{
return (skd_rw(arg, xfer, B_WRITE));
}