ocs_vpd.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 VPD parser
 */

#if !defined(__OCS_VPD_H__)
#define __OCS_VPD_H__

/**
 * @brief VPD buffer structure
 */

typedef struct {
    uint8_t *buffer;
    uint32_t length;
    uint32_t offset;
    uint8_t checksum;
    } vpdbuf_t;

/**
 * @brief return next VPD byte
 *
 * Returns next VPD byte and updates accumulated checksum
 *
 * @param vpd pointer to vpd buffer
 *
 * @return returns next byte for success, or a negative error code value for failure.
 *
 */

static inline int
vpdnext(vpdbuf_t *vpd)
{
    int rc = -1;
    if (vpd->offset < vpd->length) {
        rc = vpd->buffer[vpd->offset++];
        vpd->checksum += rc;
    }
    return rc;
}

/**
 * @brief return true if no more vpd buffer data
 *
 * return true if the vpd buffer data has been completely consumed
 *
 * @param vpd pointer to vpd buffer
 *
 * @return returns true if no more data
 *
 */
static inline int
vpddone(vpdbuf_t *vpd)
{
    return vpd->offset >= vpd->length;
}
/**
 * @brief return pointer to current VPD data location
 *
 * Returns a pointer to the current location in the VPD data
 *
 * @param vpd pointer to vpd buffer
 *
 * @return pointer to current VPD data location
 */

static inline uint8_t *
vpdref(vpdbuf_t *vpd)
{
    return &vpd->buffer[vpd->offset];
}

#define VPD_LARGE_RESOURCE_TYPE_ID_STRING_TAG   0x82
#define VPD_LARGE_RESOURCE_TYPE_R_TAG       0x90
#define VPD_LARGE_RESOURCE_TYPE_W_TAG       0x91
#define VPD_SMALL_RESOURCE_TYPE_END_TAG     0x78

/**
 * @brief find a VPD entry
 *
 * Finds a VPD entry given the two character code
 *
 * @param vpddata pointer to raw vpd data buffer
 * @param vpddata_length length of vpddata buffer in bytes
 * @param key key to look up

 * @return returns a pointer to the key location or NULL if not found or checksum error
 */

static inline uint8_t *
ocs_find_vpd(uint8_t *vpddata, uint32_t vpddata_length, const char *key)
{
    vpdbuf_t vpdbuf;
    uint8_t *pret = NULL;
    uint8_t c0 = key[0];
    uint8_t c1 = key[1];

    vpdbuf.buffer = (uint8_t*) vpddata;
    vpdbuf.length = vpddata_length;
    vpdbuf.offset = 0;
    vpdbuf.checksum = 0;

    while (!vpddone(&vpdbuf)) {
        int type = vpdnext(&vpdbuf);
        int len_lo;
        int len_hi;
        int len;
        int i;

        if (type == VPD_SMALL_RESOURCE_TYPE_END_TAG) {
            break;
        }

        len_lo = vpdnext(&vpdbuf);
        len_hi = vpdnext(&vpdbuf);
        len = len_lo + (len_hi << 8);

        if ((type == VPD_LARGE_RESOURCE_TYPE_R_TAG) || (type == VPD_LARGE_RESOURCE_TYPE_W_TAG)) {
            while (len > 0) {
                int rc0;
                int rc1;
                int sublen;
                uint8_t *pstart;

                rc0 = vpdnext(&vpdbuf);
                rc1 = vpdnext(&vpdbuf);

                /* Mark this location */
                pstart = vpdref(&vpdbuf);

                sublen = vpdnext(&vpdbuf);

                /* Adjust remaining len */
                len -= (sublen + 3);

                /* check for match with request */
                if ((c0 == rc0) && (c1 == rc1)) {
                    pret = pstart;
                    for (i = 0; i < sublen; i++) {
                        vpdnext(&vpdbuf);
                    }
                /* check for "RV" end */
                } else if ('R' == rc0 && 'V' == rc1) {

                    /* Read the checksum */
                    for (i = 0; i < sublen; i++) {
                        vpdnext(&vpdbuf);
                    }

                    /* The accumulated checksum should be zero here */
                    if (vpdbuf.checksum != 0) {
                        ocs_log_test(NULL, "checksum error\n");
                        return NULL;
                    }
                }
                else
                    for (i = 0; i < sublen; i++) {
                        vpdnext(&vpdbuf);
                    }
            }
        }

        for (i = 0; i < len; i++) {
            vpdnext(&vpdbuf);
        }
    }

    return pret;
}
#endif // __OCS_VPD_H__