ocs_ramdisc.c

Go to the documentation of this file.

/*
 * Copyright (c) 2011-2015, Emulex
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

/**
 * @file
 *
 */

/**
 * @defgroup ramdisc RAMdisc
 *
 */

#include "ocs.h"
#include "ocs_ramdisc.h"
#include "scsi_asc_ascq.h"
#include "ocs_dif.h"

/* Set to 1 to format the disk with a pattern */
#define ENABLE_SEED_WITH_PATTERN    0

#if ENABLE_DIF_VERIFICATION == 1 || ENABLE_SEED_WITH_PATTERN == 1
#include "ocs_dif.h"
#endif

#if defined(OCS_INCLUDE_DEBUG)
#include "ocs_debug.h"
#endif

/**
 * @ingroup ramdisc
 * @brief Create a new ramdisc instance (LUN).
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc instance to initialize.
 * @param block_size Ramdisc block size.
 * @param blocks_per_segment Ramdisc blocks per storage segment.
 * @param block_count Ramdisc total device block count.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */

int32_t ocs_new_ramdisc(ocs_t *ocs, ocs_ramdisc_t *ramdisc, uint32_t block_size,
            uint32_t blocks_per_segment, uint64_t block_count)
{
    ramdisc_segment_t *seg;
    uint32_t i;
    int32_t rc;

    ocs_assert(ocs, -1);
    ocs_assert(ramdisc, -1);
    ocs_assert(blocks_per_segment, -1);

    ocs_memset(ramdisc, 0, sizeof(*ramdisc));
    ramdisc->data_block_size = block_size;
    ramdisc->phys_block_size = block_size;
    ramdisc->segment_block_size = block_size;
    ramdisc->blocks_per_segment = blocks_per_segment;
    ramdisc->block_count = block_count;
    ramdisc->pending_block_size = 0;
    ramdisc->prot_capable = ocs_scsi_get_property(ocs, OCS_SCSI_DIF_CAPABLE);
    ramdisc->p_type = 0;
    ramdisc->prot_en = 0;

    ramdisc->segment_size  = blocks_per_segment * block_size;
    ramdisc->segment_count = (block_count + blocks_per_segment - 1) / blocks_per_segment;

    ramdisc->segment_pool = ocs_pool_alloc(ocs, sizeof(ramdisc_segment_t), ramdisc->segment_count, FALSE);
    if (ramdisc->segment_pool == NULL) {
        ocs_log_err(ocs, "ocs_pool_alloc(%lu, %u) failed\n",
                sizeof(ramdisc_segment_t), ramdisc->segment_count);
        return -1;
    }

#if !defined(OCS_USPACE)
    if (ocs->ocs_os.hw_cmpl_context != OCS_HW_CMPL_CONTEXT_THREAD)
        ramdisc->segments = ocs_kmalloc(ocs, ramdisc->segment_count * sizeof(ramdisc_segment_t *), OCS_M_NOWAIT | OCS_M_ZERO);
    else
#endif
        ramdisc->segments = ocs_malloc(ocs, ramdisc->segment_count * sizeof(ramdisc_segment_t *), OCS_M_NOWAIT | OCS_M_ZERO);

    if (ramdisc->segments == NULL) {
        ocs_log_err(ocs, "ocs_malloc(%u * %lu) segments failed\n",
                ramdisc->segment_count, sizeof(ramdisc_segment_t *));
        return -1;
    }

    ocs_list_init(&ramdisc->dif_pool_list, dif_pool_t, link);

    for (i = 0; i < ramdisc->segment_count; i ++) {
        ramdisc->segments[i] = ocs_pool_get(ramdisc->segment_pool);
        seg = ramdisc->segments[i];
        if (seg == NULL) {
            ocs_log_err(ocs, "unable to get segment %u\n", i);
            return -1;
        }

        rc = ocs_dma_alloc(ocs, &seg->data_segment, ramdisc->segment_size, 4096);
        if (rc) {
            ocs_log_err(ocs, "ocs_dma_alloc failed creating segment %u\n", i);
            ocs_del_ramdisc(ocs, ramdisc);
            return -1;
        }
    }

    return 0;
}

/**
 * @ingroup ramdisc
 * @brief Delete a ramdisc instance.
 *
 * @par Description
 * The resources associated with a previously-initialized ramdisc instance are freed.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc instance to free.
 *
 * @return Returns 0 on success, or a negative error code value on failure.
 */

int32_t ocs_del_ramdisc(ocs_t *ocs, ocs_ramdisc_t *ramdisc)
{
    uint64_t i;
    ramdisc_segment_t *seg;

    ocs_assert(ocs, -1);
    ocs_assert(ramdisc, -1);
    if (ramdisc) {
        if (ramdisc->segments) {
            for (i = 0; i < ramdisc->segment_count; i ++) {
                seg = ramdisc->segments[i];
                if (seg->data_segment.size != 0) {
                    ocs_dma_free(ocs, &seg->data_segment);
                } else {
                    break;
                }
                if (seg->dif_segment.virt != NULL) {
                    dif_pool_free(ocs, &ramdisc->dif_pool_list);
                }
            }

#if !defined(OCS_USPACE)
            if (ocs->ocs_os.hw_cmpl_context != OCS_HW_CMPL_CONTEXT_THREAD)
                ocs_kfree(ocs, ramdisc->segments, ramdisc->segment_count * sizeof(ramdisc_segment_t *));
            else
#endif
                ocs_free(ocs, ramdisc->segments, ramdisc->segment_count * sizeof(ramdisc_segment_t *));

            ramdisc->segments = NULL;
        }

        if (ramdisc->segment_pool != NULL) {
            ocs_pool_free(ramdisc->segment_pool);
            ramdisc->segment_pool = NULL;
        }
    }
    return 0;
}

/**
 * @ingroup ramdisc
 * @brief Build an SGL list for blocks in a ramdisc.
 *
 * @par Description
 * A starting block address and count are used to build a generic scatter gather list.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to a ramdisc instance.
 * @param sgl Pointer to the SGL.
 * @param max_sgl Maximum number of scatter gather entries in an SGL.
 * @param max_sge_size Maximum size of an SGE, in bytes.
 * @param lba Starting block address.
 * @param block_count The number of blocks to transfer for the IO.
 * May be updated to contain the number of blocks in the SGLs,
 * which may be less if the @c max_sgl count or @c max_xfer_size is reached.
 * @param req_flags SGL flags indicating the type of SGL to be built.
 * If the SGL_REQ_FLAGS_PHYS (1U << 0) bit is set, then the SGL includes
 * the block data and DIF. Otherwise, the SGL builds a DIF or non-DIF SGL.<br>
 * @b Note: In the case of a separate DIF, an SGL_REQ_FLAGS_PHYS results
 * in a one block data SGE followed by an 8-byte SGE containing the DIF data, repeating.
 *
 * @param dump_buffer If TRUE and debug is enabled, the memory pointed to by
 * the SGE is dumped to the log.
 *
 * @return Returns the number of SGLs, or a negative error value on failure.
 */

int32_t ocs_ramdisc_sgl(ocs_t *ocs, ocs_ramdisc_t *ramdisc, ocs_ramdisc_sgl_t *sgl,
            uint32_t max_sgl, uint32_t max_sge_size,
            uint32_t lba, uint32_t *block_count, uint32_t req_flags, uint8_t dump_buffer)
{
    uint32_t s0;        // index first segment in this SGL
    uint32_t l0;        // first lba of current segment
    uint32_t lba_off;   // lba offset into segment
    uint32_t dif_off;   // lba offset into segment
    uint32_t off;       // byte offset into segment
    ramdisc_segment_t *seg;
    uint32_t sgl_count = 0;
    uint32_t blocks_remaining = *block_count;
    uint32_t i;
    uint32_t dif_separate = ramdisc->dif_separate && ramdisc->prot_en;
    uint32_t multi_dif_separate = 1;

    ocs_assert(ocs, -1);
    ocs_assert(ramdisc, -1);
    ocs_assert(ramdisc->segments, -1);
    ocs_assert(ramdisc->segment_count > 0, -1);
    ocs_assert(sgl, -1);

    /* if this request falls off the end of the ramdisc, then return an error */
    if ((lba + blocks_remaining) > ramdisc->block_count) {
        return -1;
    }

    s0 = lba / ramdisc->blocks_per_segment;
    l0 = s0 * ramdisc->blocks_per_segment;
    lba_off = lba - l0;
    off = (lba_off * ramdisc->segment_block_size);
    dif_off = (lba_off * DIF_SIZE);

    /* See if multiple DIF separate SGEs are supported by the calling adapter */
    if (dif_separate) {
        multi_dif_separate = ocs_scsi_get_property(ocs, OCS_SCSI_DIF_MULTI_SEPARATE);
    }

    while ((blocks_remaining > 0) &&
        (sgl_count < max_sgl)) {
        uint32_t n;

        n = MIN(blocks_remaining, (ramdisc->blocks_per_segment - lba_off));
        seg = ramdisc->segments[s0];

#if defined(OCS_INCLUDE_DEBUG)
        /* Dump the Data */
        if (dump_buffer) {
            uintptr_t phys = seg->data_segment.phys + off;
            char desc[64];

            sprintf(desc, "Phy addr: 0x%x 0x%08x size: 0x%x",
                ocs_addr32_hi(phys),
                ocs_addr32_lo(phys),
                n*ramdisc->segment_block_size);

            ocs_dump32(OCS_DEBUG_ALWAYS, ocs, desc,
                   (uint8_t*)seg->data_segment.virt + off, n*ramdisc->segment_block_size);

            /* dump the DIF separates */
            if (dif_separate) {
                phys = seg->dif_segment.phys + dif_off;

                sprintf(desc, "Dif Separate Phy addr: 0x%x 0x%08x size: 0x%x",
                    ocs_addr32_hi(phys),
                    ocs_addr32_lo(phys),
                    n * DIF_SIZE);

                ocs_dump32(OCS_DEBUG_ALWAYS, ocs, desc,
                       (uint8_t*)seg->dif_segment.virt + dif_off,
                       n * DIF_SIZE);
            }
        }
#endif
        if (dif_separate && (req_flags & SGL_REQ_FLAGS_PHYS)) {
            /* Limit to 1 block if dif mutiple separates is not supported */
            if (!multi_dif_separate) {
                n = 1;
            }

            /* Physical SGL is requested, with DIF separate, we need to generate
             * an sgl for the data block and an sgl for the DIF block
             */
            for (i = 0; i < n; i ++) {
                if ((sgl_count + 1) < max_sgl) {
                    sgl[0].addr = seg->data_segment.phys + off;
                    sgl[0].dif_addr = 0;
                    sgl[0].len = ramdisc->segment_block_size;
                    sgl[1].addr = seg->dif_segment.phys + dif_off;
                    sgl[1].dif_addr = 0;
                    sgl[1].len = DIF_SIZE;
                    sgl_count += 2;
                    sgl += 2;
                    off += ramdisc->segment_block_size;
                    dif_off += DIF_SIZE;
                }
            }

        } else {
            sgl->addr = seg->data_segment.phys + off;
            sgl->len = n*ramdisc->segment_block_size;
            if (dif_separate) {
                sgl->dif_addr = seg->dif_segment.phys + dif_off;
            } else {
                sgl->dif_addr = 0;
            }
            sgl_count++;
            sgl++;
            s0++;
        }

        lba_off = 0;
        off = 0;
        dif_off = 0;
        blocks_remaining -= n;

        if (dif_separate && !multi_dif_separate) {
            break;
        }
    }

    *block_count -= blocks_remaining;

    return sgl_count;
}


/**
 * @ingroup ramdisc
 * @brief Reformat an existing ramdisc, possibly the changing block size and/or protection.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc instance.
 * @param block_size Requested block size
 * @param p_type Requested new protection type.
 * @param prot_en Requested new protection enabled flag.
 * @param dif_separate Requested DIF separates
 *
 * @return Returns a non-zero value if the format changed, or 0 if the format did not change.
 */

int32_t ocs_format_ramdisc(ocs_t *ocs, ocs_ramdisc_t *ramdisc, uint32_t block_size, uint8_t p_type, uint8_t prot_en, uint8_t dif_separate)
{
    uint32_t i;
    uint32_t j;
    int format_changed = 0;
    ramdisc_segment_t *seg;
    uint16_t crc = 0;
    uint32_t blkCount;

    if (block_size == 0) {
        block_size = 512;
    }

    if (ramdisc->force_dif_separate) {
        dif_separate = TRUE;
    }

    format_changed =  (block_size != ramdisc->data_block_size) || (p_type != ramdisc->p_type) ||
        (prot_en != ramdisc->prot_en);

    /*
     * Segment size will stay the same
     * Block size may change
     * If the block size changes, there will be a different number of blocks in each segment.
     * If the blocks per segment changes, the overall block count will change.
     *
     * If prot_en is true, then the actual block size needs to be 8 bytes bigger than the
     * requested size of the block.
     */

    ramdisc->p_type = p_type;
    ramdisc->prot_en = prot_en;
    ramdisc->dif_separate = dif_separate;

    ramdisc->data_block_size = block_size;
    ramdisc->phys_block_size = block_size;
    ramdisc->segment_block_size = block_size;

    if (prot_en) {
        ramdisc->phys_block_size += DIF_SIZE;
        if (!ramdisc->dif_separate) {
            ramdisc->segment_block_size += DIF_SIZE;
        }
    }

    if (prot_en) {
        block_size += DIF_SIZE;
    }

    ramdisc->blocks_per_segment = ramdisc->segment_size / ramdisc->segment_block_size;
    ramdisc->block_count = ramdisc->blocks_per_segment * ramdisc->segment_count;

    ocs_log_info(ocs, "Formating LUN %d with %" PRIu64 " blocks of %d/%d bytes, p_type is %d, prot_en is %d dif_separate %d\n",
        ramdisc->lun, ramdisc->block_count, ramdisc->data_block_size, ramdisc->phys_block_size,
        ramdisc->p_type, ramdisc->prot_en, ramdisc->dif_separate);

    /* Seed the blocks with zeroes or a pattern */
    blkCount = 0;
    for (i = 0; i < ramdisc->segment_count; i++) {
        seg = ramdisc->segments[i];
#if ENABLE_SEED_WITH_PATTERN==1
        uint32_t *blk_dword = seg->data_segment.virt;
        uint32_t dwords_per_blk = ramdisc->data_block_size / sizeof(uint32_t);
        /*
         * Seed each block with the LBA in the first 4 bytes followed
         * by a simple incrementing dword pattern.
         */
        for (j = 0; j < ramdisc->blocks_per_segment; j++) {
            uint32_t k;

            blk_dword[0] = blkCount;
            for (k = 1; k < dwords_per_blk - 1; k++) {
                blk_dword[k] = blkCount + k;
            }
            blkCount++;
            blk_dword += dwords_per_blk;
            if (!ramdisc->dif_separate) {
                /* skip over the inline DIF bytes */
                blk_dword += 2;
            }
        }
#else
        ocs_memset(seg->data_segment.virt, 0, ramdisc->segment_size);
#endif

        /* If DIF separates, then initialize separates */
        if (ramdisc->dif_separate) {
            /* If not previously allocated, then allocate DIF separate segment */
            if (seg->dif_segment.virt == NULL) {
                int32_t rc;

                rc = dif_pool_alloc(ocs, &ramdisc->dif_pool_list,
                    (DIF_SIZE * ramdisc->segment_size) / RAMDISC_MIN_BLOCK_SIZE,
                    &seg->dif_segment);
                if (rc) {
                    ocs_log_err(ocs, "dif_pool_alloc failed: %d\n", rc);
                    return -1;
                }
            }
            ocs_memset(seg->dif_segment.virt, 0, seg->dif_segment.size);
        }
    }


    if (ocs->ctrlmask & OCS_CTRLMASK_TGT_SET_DIF_REF_TAG_CRC) {
        /* Calculate the CRC for a zeroed block */
        crc = 0;
        crc = ocs_scsi_dif_calc_crc(ramdisc->segments[0]->data_segment.virt,
                        ramdisc->segment_block_size,
                        crc);
    }

    /* If protection is enabled initialize DIF block to FF's */
    blkCount = 0;
    if ((ramdisc->prot_en == 1) && (ramdisc->p_type != 0)) {
        for (i = 0; i < ramdisc->segment_count; i++) {
            uint8_t *dif_block;
            uint32_t dif_incr;
            seg = ramdisc->segments[i];
            if (ramdisc->dif_separate) {
                dif_block = seg->dif_segment.virt;
                dif_incr = DIF_SIZE;
            } else {
                dif_block = ((uint8_t*)seg->data_segment.virt) + ramdisc->data_block_size;
                dif_incr = ramdisc->segment_block_size;
            }
            for (j = 0; j < ramdisc->blocks_per_segment; j++) {
                if (ocs->ctrlmask & OCS_CTRLMASK_TGT_SET_DIF_REF_TAG_CRC) {
#if ENABLE_SEED_WITH_PATTERN==1
                    uint8_t* blk_start;

                    blk_start = ((uint8_t*)seg->data_segment.virt);
                    if (ramdisc->dif_separate) {
                        blk_start += (ramdisc->data_block_size * j);
                    } else {
                        blk_start += (ramdisc->phys_block_size * j);
                    }

                    crc = 0;
                    crc = ocs_scsi_dif_calc_crc(blk_start,
                                    ramdisc->data_block_size,
                                    crc);
#endif
                    dif_block[0] = (crc >> 8);
                    dif_block[1] = (crc & 0xff);
                    dif_block[2] = 0xff;
                    dif_block[3] = 0xff;
                    dif_block[4] = blkCount >> 24;
                    dif_block[5] = (blkCount >> 16) & 0xff;
                    dif_block[6] = (blkCount >> 8) & 0xff;
                    dif_block[7] = blkCount & 0xff;
                } else {
                    ocs_memset(dif_block, 0xff, DIF_SIZE);
                }
                dif_block += dif_incr;
                blkCount++;
            }
        }

    }
    return format_changed;

}

/**
 * @ingroup ramdisc
 * @brief Set the ramdisc block size.
 *
 * @par Description
 * The block size is set for a ramdisc instance.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc object to initialize.
 * @param block_size Ramdisc device block size.
 *
 * @return None.
 */

void ocs_set_ramdisc_blocksize(ocs_t *ocs, ocs_ramdisc_t *ramdisc, uint32_t block_size)
{
    ramdisc->pending_block_size = block_size;
}

/**
 * @ingroup ramdisc
 * @brief Get the ramdisc block size.
 *
 * @par Description
 * Return the block size for a ramdisc instance.
 *
 * @param ocs Pointer to the ocs structure.
 * @param ramdisc Pointer to the ramdisc object.
 *
 * @return Returns the block size of the ramdisc.
 */

uint32_t ocs_get_ramdisc_blocksize(ocs_t *ocs, ocs_ramdisc_t *ramdisc)
{
    ocs_assert(ocs, 0);
    ocs_assert(ramdisc, 0);

    return ramdisc->segment_block_size;
}

/**
 * @ingroup ramdisc
 * @brief Return the address of a ramdisc logical block.
 *
 * @par Description
 * Given a pointer to a ramdisc and a logical block address, return
 * the address in memory of the first byte of the block.
 *
 * @param ramdisc Pointer to the ramdisc structure.
 * @param lba Logical Block Address.
 *
 * @return Returns the pointer to the first block of the LBA, or NULL if the LBA is invalid.
 */

uint8_t* ocs_ramdisc_lba_address(ocs_ramdisc_t *ramdisc, uint64_t lba)
{
    ramdisc_segment_t *seg;

    if (lba >= ramdisc->block_count) {
        return NULL;
    }

    seg = ramdisc->segments[lba / ramdisc->blocks_per_segment];

    return ((uint8_t*)seg->data_segment.virt) + ((lba % ramdisc->blocks_per_segment) * ramdisc->segment_block_size);

}

/**
 * @ingroup ramdisc
 * @brief Return the address of the DIF block if protection is enabled.
 *
 * @par Description
 * Given a pointer to a ramdisc and a logical block address, return
 * the address in memory of the DIF block if protection is enabled.
 *
 * @param ramdisc Pointer to the ramdisc structure.
 * @param lba Logical Block Address.
 *
 * @return Returns the pointer to the first block of the LBA, or NULL if the LBA is invalid.
 */

dif_t* ocs_ramdisc_dif_address(ocs_ramdisc_t *ramdisc, uint64_t lba)
{
    ramdisc_segment_t *seg;

    if (lba >= ramdisc->block_count) {
        return NULL;
    }

    seg = ramdisc->segments[lba / ramdisc->blocks_per_segment];

    if (ramdisc->dif_separate) {
        return (dif_t*) (((uint8_t*)seg->dif_segment.virt) + (lba % ramdisc->blocks_per_segment)*DIF_SIZE);
    } else {
        return (dif_t*) (ocs_ramdisc_lba_address(ramdisc, lba) + ramdisc->segment_block_size - sizeof(dif_t));
    }
}

/**
 * @brief initialize the DIF memory pool
 *
 * @par Description
 * Clears all previous allocations of DIF memory. Leaves all the previously-allocated
 * memory buffers in the pool.
 *
 * @param ocs Pointer to the ocs structure.
 * @param head Head of the dif_pool_t linked list.
 *
 * @return None.
 */

void
dif_pool_init(ocs_t *ocs, ocs_list_t *head)
{
    dif_pool_t *difpool;

    if (!ocs_list_empty(head)) {
        ocs_list_foreach(head, difpool) {
            difpool->inuse_count = 0;
        }
    }
}

/**
 * @brief Free the DIF memory pool.
 *
 * @par Description
 * Frees all of the DIF memory pool buffers.
 *
 * @param ocs Pointer to the ocs structure.
 * @param head Pointer to the head of DIF pool entries list.
 *
 * @return None.
 */

void
dif_pool_free(ocs_t *ocs, ocs_list_t *head)
{
    dif_pool_t *difpool;
    dif_pool_t *next;

    if (!ocs_list_empty(head)) {
        ocs_list_foreach_safe(head, difpool, next) {
            ocs_list_remove(head, difpool);

            ocs_dma_free(ocs, &difpool->dmabuf);
            ocs_free(ocs, difpool, sizeof(*difpool));
        }
    }
}

/**
 * @brief Allocate a new dif_pool_t entry.
 *
 * @par Description
 * Allocates a new dif_pool_t entry.
 *
 * @param ocs Pointer to the ocs_t structure.
 * @param head Pointer to the head of DIF buffer entry linked list.
 *
 * @return Returns 0 on success, a negative error code value on failure.
 */

static int32_t
dif_pool_new(ocs_t *ocs, ocs_list_t *head)
{
    dif_pool_t *difpool;
    int32_t rc;

    difpool = ocs_malloc(ocs, sizeof(*difpool), OCS_M_NOWAIT | OCS_M_ZERO);
    if (difpool == NULL) {
        ocs_log_err(ocs, "ocs_malloc failed\n");
        return -1;
    }
    rc = ocs_dma_alloc(ocs, &difpool->dmabuf, DIF_POOL_SIZE, OCS_MIN_DMA_ALIGNMENT);
    if (rc) {
        ocs_log_err(ocs, "ocs_dma_alloc() failed: %d\n", rc);
        ocs_free(ocs, difpool, sizeof(*difpool));
        return -1;
    }
    ocs_list_add_tail(head, difpool);

    return 0;
}

/**
 * @brief Allocate memory for the DIF memory pool.
 *
 * @par Description
 * Allocates a buffer of @c size from a DIF memory pool. Returns a physical address.
 *
 * @param ocs Pointer to the ocs_t structure.
 * @param head Pointer to the head of a DIF pool entry linked list.
 * @param size Size of the memory to allocate.
 * @param difdma Returns the address of the requested DIF segment.
 *
 * @return Returns 0 on success.
 */

int32_t
dif_pool_alloc(ocs_t *ocs, ocs_list_t *head, uint32_t size, ocs_difdma_t *difdma)
{
    dif_pool_t *difpool;
    int32_t rc = -1;

    /* Roundup request size to be a multiple of something nice */
    size = ocs_roundup(size, 16);

    ocs_assert(size <= DIF_POOL_SIZE, -1);

    if (ocs_list_empty(head)) {
        rc = dif_pool_new(ocs, head);
        if (rc) {
            return -1;
        }
    }

    difpool = ocs_list_get_tail(head);
    if ((difpool->dmabuf.size - difpool->inuse_count) < size) {
        rc = dif_pool_new(ocs, head);
        if (rc) {
            return -1;
        }
        difpool = ocs_list_get_tail(head);
    }
    ocs_assert((difpool->dmabuf.size - difpool->inuse_count) >= size, -1);
    difdma->phys = difpool->dmabuf.phys + difpool->inuse_count;
    difdma->virt = ((uint8_t*)difpool->dmabuf.virt) + difpool->inuse_count;
    difdma->size = size;
    difpool->inuse_count += size;

    return 0;
}

void
ocs_ddump_ramdisc(ocs_textbuf_t *textbuf, ocs_ramdisc_t *ramdisc)
{
#if defined(ENABLE_DDUMP_RAMDISC_SEGMENTS)
    ramdisc_segment_t *seg;
    uint64_t i;
#endif

    ocs_ddump_section(textbuf, "ramdisc", ramdisc->lun);
        ocs_ddump_value(textbuf, "lun", "%d", ramdisc->lun);
        ocs_ddump_value(textbuf, "data_block_size", "%d", ramdisc->data_block_size);
        ocs_ddump_value(textbuf, "phys_block_size", "%d", ramdisc->phys_block_size);
        ocs_ddump_value(textbuf, "segment_block_size", "%d", ramdisc->segment_block_size);
        ocs_ddump_value(textbuf, "blocks_per_segment", "%d", ramdisc->blocks_per_segment);
        ocs_ddump_value(textbuf, "block_count", "%" PRIu64, ramdisc->block_count);
        ocs_ddump_value(textbuf, "pending_block_size", "%d", ramdisc->pending_block_size);
        ocs_ddump_value(textbuf, "prot_capable", "%d", ramdisc->prot_capable);
        ocs_ddump_value(textbuf, "p_type", "%d", ramdisc->p_type);
        ocs_ddump_value(textbuf, "prot_en", "%d", ramdisc->prot_en);
        ocs_ddump_value(textbuf, "segment_count", "%d", ramdisc->segment_count);
        ocs_ddump_value(textbuf, "segment_size", "%d", ramdisc->segment_size);
        ocs_ddump_value(textbuf, "dif_separate", "%d", ramdisc->dif_separate);
#if defined(ENABLE_DDUMP_RAMDISC_SEGMENTS)
        for (i = 0; i < ramdisc->segment_count; i++) {
            seg = ramdisc->segments[i];
            ocs_ddump_section(textbuf, "ramdisc_segment", i);
                ocs_ddump_section(textbuf, "data_segment", 0);
                    ocs_ddump_value(textbuf, "virt", "%p", seg->data_segment.virt);
                    ocs_ddump_value(textbuf, "phys", "%016lx", seg->data_segment.phys);
                    ocs_ddump_value(textbuf, "size", "%d", seg->data_segment.size);
                ocs_ddump_endsection(textbuf, "data_segment", 0);
                ocs_ddump_section(textbuf, "dif_segment", 0);
                    ocs_ddump_value(textbuf, "virt", "%p", seg->dif_segment.virt);
                    ocs_ddump_value(textbuf, "phys", "%016lx", seg->dif_segment.phys);
                    ocs_ddump_value(textbuf, "size", "%d", seg->dif_segment.size);
                ocs_ddump_endsection(textbuf, "dif_segment", 0);
            ocs_ddump_endsection(textbuf, "ramdisc_segment", i);
        }
#endif
    ocs_ddump_endsection(textbuf, "ramdisc", ramdisc->lun);
}

#if ENABLE_DIF_VERIFICATION == 1
/**
 * @brief Verify the DIF information on an LBA range - Used to verify chip operations
 *
 * @par Description
 * Calculate the DIF CRC, ref tag and app tag and verifies the values.
 *
 * @param ocs Pointer to the ocs_t structure.
 * @param ramdisc Pointer to the ramdisc instance to initialize.
 * @param lba Starting block address.
 * @param block_count The number of blocks to transfer for the IO.
 *
 * @return Returns 0 on success.
 */
int32_t
ocs_ramdisc_dif_verify(ocs_t *ocs, ocs_ramdisc_t *ramdisc,
               uint64_t lba, uint32_t block_count)
{
    uint32_t i;
    uint16_t crc;
    uint8_t *difbytes;
    int32_t rc = 0;
    uint16_t recv_crc;
    uint16_t recv_apptag;
    uint32_t recv_reftag;
    uint32_t s0;        // index first segment in this SGL
    uint32_t l0;        // first lba of current segment
    uint32_t lba_off;   // lba offset into segment
    uint32_t dif_off;   // lba offset into segment
    uint32_t off;       // byte offset into segment
    ramdisc_segment_t *seg;
    uint8_t errors_detected;

    /* return if DIF is not enabled - nothing to check */
    if (ramdisc->prot_en == 0) {
        return 0;
    }

    for (i = 0; i < block_count; i++) {
        /* if this request falls off the end of the ramdisc, then return an error */
        if ((lba + block_count) > ramdisc->block_count) {
            return -1;
        }

        s0 = (lba + i) / ramdisc->blocks_per_segment;
        l0 = s0 * ramdisc->blocks_per_segment;
        lba_off = (lba + i) - l0;
        off = (lba_off * ramdisc->segment_block_size);
        dif_off = (lba_off * DIF_SIZE);
        seg = ramdisc->segments[s0];

        crc = 0;
        crc = ocs_scsi_dif_calc_crc(seg->data_segment.virt + off, ramdisc->data_block_size, crc);
        if (ramdisc->dif_separate && ramdisc->prot_en) {
            difbytes = (uint8_t*)seg->dif_segment.virt + dif_off;
        } else {
            difbytes = (uint8_t*)seg->data_segment.virt + off + ramdisc->data_block_size;
        }

        errors_detected = FALSE;
        /* verify the CRC */
        recv_crc = ((uint16_t)difbytes[0]) << 8 | difbytes[1];

        if (crc != recv_crc && recv_crc != 0xFFFF) {
            ocs_log_test(ocs, "miscompare (CRC) on LBA 0x%" PRIx64 ", "
                "memory contains 0x%x but calculated 0x%x\n",
                lba + i,
                recv_crc,
                crc);
            errors_detected = TRUE;
            rc = -1;
        }

        /* verify the app tag */
        recv_apptag = ((uint16_t)difbytes[2]) << 8 | difbytes[3];
        if (0 != recv_apptag && recv_apptag != 0xFFFF) {
            ocs_log_test(ocs, "miscompare (app_tag) on LBA 0x%" PRIx64 ", "
                "memory contains 0x%x but calculated 0x%x\n",
                lba + i,
                recv_apptag,
                0);
            errors_detected = TRUE;
            rc = -1;
        }

        /* verify the ref tag */
        recv_reftag = (((uint32_t)difbytes[4] << 24) |
                   ((uint32_t)difbytes[5] << 16) |
                   ((uint32_t)difbytes[6] << 8) |
                   difbytes[7]);

        if (lba + i != recv_reftag && recv_reftag != 0xFFFFFFFF) {
            ocs_log_test(ocs, "miscompare (ref_tag) on LBA 0x%" PRIx64 ", "
                "memory contains 0x%x but calculated 0x%" PRIx64 "\n",
                lba + i,
                recv_reftag,
                lba + i);
            errors_detected = TRUE;
            rc = -1;
        }

        /* Dump the data block if there are any errors */
        if (errors_detected) {
            char desc[64];

            sprintf(desc, "Lba 0x%" PRIx64, lba + i);

            ocs_dump32(OCS_DEBUG_ALWAYS, ocs, desc,
                   (uint8_t*)seg->data_segment.virt + off,
                   ramdisc->phys_block_size);
        }
    }

    return rc;
}
#endif