/* * * 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 * Gordon Waidhofer * John Hamilton */ /* * 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. * Copyright (c) 2018, Joyent, Inc. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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" : "", 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, ®size) != 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, ®size) != 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)); }