ocs_ramdisc.h

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
 * OCS ramdisc declarations and exported API
 */

#if !defined(__OCS_RAMDISC_H__)
#define __OCS_RAMDISC_H__

#define DIF_POOL_SIZE               OCS_MAX_DMA_ALLOC
#define RAMDISC_MIN_BLOCK_SIZE          512

/* Flag to enable DIF verification after write operations and before reads. */
#define ENABLE_DIF_VERIFICATION 0

/**
 * @ brief DIF block structure
 */

typedef struct {
    uint16_t crc;
    uint16_t app_tag;
    uint32_t ref_tag;
} dif_t;

/**
 * @brief DIF separates allocation pool
 *
 */

typedef struct dif_pool_s dif_pool_t;

struct dif_pool_s {
    ocs_dma_t dmabuf;           /*<< DIF memory pool allocator */
    uint32_t inuse_count;           /*<< bytes in use */
    ocs_list_link_t link;           /*<< link for list of dif_pool_t objects */
};

typedef struct {
    void        *virt;
    uintptr_t   phys;
    size_t      size;
} ocs_difdma_t;

/**
 * @brief ramdisc segment structure
 */
typedef struct {
    ocs_dma_t data_segment;
    ocs_difdma_t dif_segment;
} ramdisc_segment_t;

/**
 * @brief ramdisc instance structure
 */

typedef struct {
    uint32_t lun;               /**< LUN number for this ramdisc */
    uint32_t data_block_size;       /**< data (logical) block size in bytes */
    uint32_t phys_block_size;       /**< actual formatted block size in bytes including DIF */
    uint32_t segment_block_size;        /**< block size within segment */
    uint8_t dif_separate;           /**< TRUE if separate DIF */
    uint32_t blocks_per_segment;        /**< blocks per segment */
    uint64_t block_count;           /**< block count */
    uint32_t pending_block_size;        /**< last block size sent in a mode select (user data only, no DIF) */
    uint8_t prot_capable;                   /**< interface is capable of doing T10 PI */
    uint8_t p_type;             /**< protection type for T10 PI */
    uint8_t prot_en;            /**< protection enabled flag for T10 PI */
    uint8_t external_dif;           /**< proprietary end-to-end protection enabled */
    char t10_vendor_id[8];          /**< T10 Vendor ID to use with external_dif */

    uint8_t force_dif_separate;     /*<< If TRUE, then always format with DIF separate */

    ocs_pool_t *segment_pool;
    ramdisc_segment_t **segments;       /**< pointer to allocated segment pointers */
    uint32_t segment_count;         /**< segment count */
    uint32_t segment_size;          /**< segment size in bytes */

    /* DIF separates allocation pool */
    ocs_list_t dif_pool_list;       /**< linked list of memory segments for DIF separates */

} ocs_ramdisc_t;

/**
 * @brief generic ramdisc scatter-gather list
 */

typedef struct ocs_ramdisc_sgl_s {
    uintptr_t   addr;           /**< physical address */
    uintptr_t   dif_addr;       /**< address of DIF segment, zero if DIF is interleaved */
    size_t      len;            /**< length in bytes */
} ocs_ramdisc_sgl_t;


extern 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);
extern int32_t ocs_del_ramdisc(ocs_t *ocs, ocs_ramdisc_t *ramdisc);
#define SGL_REQ_FLAGS_PHYS      (1U << 0)
extern 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);
extern int32_t ocs_ramdisc_first_burst(ocs_t *ocs, ocs_ramdisc_t *ramdisc,
                uint32_t lba, uint32_t lba_offset,
                uint8_t *buffer, uint32_t buffer_size);
extern 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 separate);
extern void ocs_set_ramdisc_blocksize(ocs_t *ocs, ocs_ramdisc_t *ramdisc, uint32_t block_size);
extern uint32_t ocs_get_ramdisc_blocksize(ocs_t *ocs, ocs_ramdisc_t *ramdisc);
extern uint8_t* ocs_ramdisc_lba_address(ocs_ramdisc_t *ramdisc, uint64_t lba);
extern dif_t* ocs_ramdisc_dif_address(ocs_ramdisc_t *ramdisc, uint64_t lba);
extern void ocs_ddump_ramdisc(ocs_textbuf_t *textbuf, ocs_ramdisc_t *ramdisc);

/* DIF separates allocation */
extern void dif_pool_init(ocs_t *ocs, ocs_list_t *head);
extern void dif_pool_free(ocs_t *ocs, ocs_list_t *head);
extern int32_t dif_pool_alloc(ocs_t *ocs, ocs_list_t *head, uint32_t size, ocs_difdma_t *difdma);

/* DIF verification - debugging only */
#if ENABLE_DIF_VERIFICATION == 1
extern int32_t ocs_ramdisc_dif_verify(ocs_t *ocs, ocs_ramdisc_t *ramdisc,
                   uint64_t lba, uint32_t block_count);
#endif

#endif // __OCS_RAMDISC_H__