pcivpd.c

Go to the documentation of this file.

/*
 * Copyright (C) 2010 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/pci.h>
#include <ipxe/isapnp.h>
#include <ipxe/pcivpd.h>

/** @file
 *
 * PCI Vital Product Data
 *
 */

/**
 * Initialise PCI Vital Product Data
 *
 * @v vpd               PCI VPD
 * @v pci               PCI device
 * @ret rc              Return status code
 */
int pci_vpd_init ( struct pci_vpd *vpd, struct pci_device *pci ) {

        /* Initialise structure */
        vpd->pci = pci;
        pci_vpd_invalidate_cache ( vpd );

        /* Locate VPD capability */
        vpd->cap = pci_find_capability ( pci, PCI_CAP_ID_VPD );
        if ( ! vpd->cap ) {
                DBGC ( vpd, PCI_FMT " does not support VPD\n",
                       PCI_ARGS ( pci ) );
                return -ENOTTY;
        }

        DBGC ( vpd, PCI_FMT " VPD is at offset %02x\n",
               PCI_ARGS ( pci ), vpd->cap );
        return 0;
}

/**
 * Read one dword of PCI Vital Product Data
 *
 * @v vpd               PCI VPD
 * @v address           Address to read
 * @ret data            Read data
 * @ret rc              Return status code
 */
static int pci_vpd_read_dword ( struct pci_vpd *vpd, int address,
                                uint32_t *data ) {
        struct pci_device *pci = vpd->pci;
        unsigned int cap = vpd->cap;
        unsigned int retries;
        uint16_t flag;

        /* Fail if no VPD present */
        if ( ! cap )
                return -ENOTTY;

        /* Return cached value, if present */
        if ( pci_vpd_cache_is_valid ( vpd ) &&
             ( vpd->cache.address == address ) ) {
                *data = vpd->cache.data;
                return 0;
        }

        /* Initiate read */
        pci_write_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), address );

        /* Wait for read to complete */
        for ( retries = 0 ; retries < PCI_VPD_MAX_WAIT_MS ; retries++ ) {

                /* Check if data is ready */
                pci_read_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), &flag );
                if ( flag & PCI_VPD_FLAG ) {

                        /* Read data */
                        pci_read_config_dword ( pci, ( cap + PCI_VPD_DATA ),
                                                data );
                        DBGC2 ( vpd, PCI_FMT " VPD %04x => %08x\n",
                                PCI_ARGS ( pci ), address, htonl ( *data ) );

                        /* Populate cache */
                        vpd->cache.address = address;
                        vpd->cache.data = *data;

                        return 0;
                }

                /* Wait 1ms before retrying */
                mdelay ( 1 );
        }

        DBGC ( vpd, PCI_FMT " VPD %04x read via %02x timed out\n",
               PCI_ARGS ( pci ), address, cap );
        return -ETIMEDOUT;
}

/**
 * Write one dword of PCI Vital Product Data
 *
 * @v vpd               PCI VPD
 * @v address           Address to write
 * @v data              Data to write
 * @ret rc              Return status code
 */
static int pci_vpd_write_dword ( struct pci_vpd *vpd, int address,
                                 uint32_t data ) {
        struct pci_device *pci = vpd->pci;
        unsigned int cap = vpd->cap;
        unsigned int retries;
        uint16_t flag;

        /* Fail if no VPD present */
        if ( ! cap )
                return -ENOTTY;

        /* Invalidate cache */
        pci_vpd_invalidate_cache ( vpd );

        DBGC2 ( vpd, PCI_FMT " VPD %04x <= %08x\n",
                PCI_ARGS ( pci ), address, htonl ( data ) );

        /* Write data */
        pci_write_config_dword ( pci, ( cap + PCI_VPD_DATA ), data );

        /* Initiate write */
        pci_write_config_word ( pci, ( cap + PCI_VPD_ADDRESS ),
                                ( address | PCI_VPD_FLAG ) );

        /* Wait for write to complete */
        for ( retries = 0 ; retries < PCI_VPD_MAX_WAIT_MS ; retries++ ) {

                /* Check if write has completed */
                pci_read_config_word ( pci, ( cap + PCI_VPD_ADDRESS ), &flag );
                if ( ! ( flag & PCI_VPD_FLAG ) )
                        return 0;

                /* Wait 1ms before retrying */
                mdelay ( 1 );
        }

        DBGC ( vpd, PCI_FMT " VPD %04x write via %02x timed out\n",
               PCI_ARGS ( pci ), address, cap );
        return -ETIMEDOUT;
}

/**
 * Read PCI VPD
 *
 * @v vpd               PCI VPD
 * @v address           Starting address
 * @v buf               Data buffer
 * @v len               Length of data buffer
 * @ret rc              Return status code
 */
int pci_vpd_read ( struct pci_vpd *vpd, unsigned int address, void *buf,
                   size_t len ) {
        uint8_t *bytes = buf;
        uint32_t data;
        size_t skip_len;
        unsigned int i;
        int rc;

        /* Calculate length to skip at start of data */
        skip_len = ( address & 0x03 );

        /* Read data, a dword at a time */
        for ( address &= ~0x03 ; len ; address += 4 ) {

                /* Read whole dword */
                if ( ( rc = pci_vpd_read_dword ( vpd, address, &data ) ) != 0 )
                        return rc;

                /* Copy data to buffer */
                for ( i = 4 ; i ; i-- ) {
                        if ( skip_len ) {
                                skip_len--;
                        } else if ( len ) {
                                *(bytes++) = data;
                                len--;
                        }
                        data = ( ( data << 24 ) | ( data >> 8 ) );
                }
        }

        return 0;
}

/**
 * Write PCI VPD
 *
 * @v vpd               PCI VPD
 * @v address           Starting address
 * @v buf               Data buffer
 * @v len               Length of data buffer
 * @ret rc              Return status code
 */
int pci_vpd_write ( struct pci_vpd *vpd, unsigned int address, const void *buf,
                    size_t len ) {
        const uint8_t *bytes = buf;
        uint32_t data;
        size_t skip_len;
        unsigned int i;
        int rc;

        /* Calculate length to skip at start of data */
        skip_len = ( address & 0x03 );

        /* Write data, a dword at a time */
        for ( address &= ~0x03 ; len ; address += 4 ) {

                /* Read existing dword, if necessary */
                if ( skip_len || ( len <= 0x03 ) ) {
                        if ( ( rc = pci_vpd_read_dword ( vpd, address,
                                                         &data ) ) != 0 )
                                return rc;
                }

                /* Copy data from buffer */
                for ( i = 4 ; i ; i-- ) {
                        if ( skip_len ) {
                                skip_len--;
                        } else if ( len ) {
                                data = ( ( data & ~0xff ) | *(bytes++) );
                                len--;
                        }
                        data = ( ( data << 24 ) | ( data >> 8 ) );
                }

                /* Write whole dword */
                if ( ( rc = pci_vpd_write_dword ( vpd, address, data ) ) != 0 )
                        return rc;
        }
        return 0;
}

/**
 * Dump PCI VPD region (for debugging)
 *
 * @v vpd               PCI VPD
 * @v address           Starting address
 * @v len               Length of data
 */
static void pci_vpd_dump ( struct pci_vpd *vpd, unsigned int address,
                           size_t len ) {
        int rc;

        /* Do nothing in non-debug builds */
        if ( ! DBG_LOG )
                return;

        /* Read data */
        {
                char buf[len];
                if ( ( rc = pci_vpd_read ( vpd, address, buf,
                                           sizeof ( buf ) ) ) != 0 )
                        return;
                DBGC_HDA ( vpd, address, buf, sizeof ( buf ) );
        }
}

/**
 * Locate PCI VPD tag
 *
 * @v vpd               PCI VPD
 * @v tag               ISAPnP tag
 * @ret address         Address of tag body
 * @ret len             Length of tag body
 * @ret rc              Return status code
 */
static int pci_vpd_find_tag ( struct pci_vpd *vpd, unsigned int tag,
                              unsigned int *address, size_t *len ) {
        uint8_t read_tag;
        uint16_t read_len;
        int rc;

        /* Scan through tags looking for a match */
        *address = 0;
        do {
                /* Read tag byte */
                if ( ( rc = pci_vpd_read ( vpd, (*address)++, &read_tag,
                                           sizeof ( read_tag ) ) ) != 0 )
                        return rc;

                /* Extract tag and length */
                if ( ISAPNP_IS_LARGE_TAG ( read_tag ) ) {
                        if ( ( rc = pci_vpd_read ( vpd, *address, &read_len,
                                                   sizeof ( read_len ) ) ) != 0)
                                return rc;
                        *address += sizeof ( read_len );
                        read_len = le16_to_cpu ( read_len );
                        read_tag = ISAPNP_LARGE_TAG_NAME ( read_tag );
                } else {
                        read_len = ISAPNP_SMALL_TAG_LEN ( read_tag );
                        read_tag = ISAPNP_SMALL_TAG_NAME ( read_tag );
                }

                /* Check for tag match */
                if ( tag == read_tag ) {
                        *len = read_len;
                        DBGC ( vpd, PCI_FMT " VPD tag %02x is at "
                               "[%04x,%04zx)\n", PCI_ARGS ( vpd->pci ), tag,
                               *address, ( *address + *len ) );
                        return 0;
                }

                /* Move to next tag */
                *address += read_len;

        } while ( read_tag != ISAPNP_TAG_END );

        DBGC ( vpd, PCI_FMT " VPD tag %02x not found\n",
               PCI_ARGS ( vpd->pci ), tag );
        return -ENOENT;
}

/**
 * Locate PCI VPD field
 *
 * @v vpd               PCI VPD
 * @v field             VPD field descriptor
 * @ret address         Address of field body
 * @ret len             Length of field body
 * @ret rc              Return status code
 */
int pci_vpd_find ( struct pci_vpd *vpd, unsigned int field,
                   unsigned int *address, size_t *len ) {
        struct pci_vpd_field read_field;
        int rc;

        /* Locate containing tag */
        if ( ( rc = pci_vpd_find_tag ( vpd, PCI_VPD_TAG ( field ),
                                       address, len ) ) != 0 )
                return rc;

        /* Return immediately if we are searching for a whole-tag field */
        if ( ! PCI_VPD_KEYWORD ( field ) ) {
                pci_vpd_dump ( vpd, *address, *len );
                return 0;
        }

        /* Scan through fields looking for a match */
        while ( *len >= sizeof ( read_field ) ) {

                /* Read field header */
                if ( ( rc = pci_vpd_read ( vpd, *address, &read_field,
                                           sizeof ( read_field ) ) ) != 0 )
                        return rc;
                *address += sizeof ( read_field );
                *len -= sizeof ( read_field );

                /* Check for keyword match */
                if ( read_field.keyword == PCI_VPD_KEYWORD ( field ) ) {
                        *len = read_field.len;
                        DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
                               " is at [%04x,%04zx)\n", PCI_ARGS ( vpd->pci ),
                               PCI_VPD_FIELD_ARGS ( field ),
                               *address, ( *address + *len ) );
                        pci_vpd_dump ( vpd, *address, *len );
                        return 0;
                }

                /* Move to next field */
                if ( read_field.len > *len )
                        break;
                *address += read_field.len;
                *len -= read_field.len;
        }

        DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " not found\n",
               PCI_ARGS ( vpd->pci ), PCI_VPD_FIELD_ARGS ( field ) );
        return -ENOENT;
}

/**
 * Resize VPD field
 *
 * @v vpd               PCI VPD
 * @v field             VPD field descriptor
 * @v len               New length of field body
 * @ret address         Address of field body
 * @ret rc              Return status code
 */
int pci_vpd_resize ( struct pci_vpd *vpd, unsigned int field, size_t len,
                     unsigned int *address ) {
        struct pci_vpd_field rw_field;
        struct pci_vpd_field old_field;
        struct pci_vpd_field new_field;
        unsigned int rw_address;
        unsigned int old_address;
        unsigned int copy_address;
        unsigned int dst_address;
        unsigned int dump_address;
        size_t rw_len;
        size_t old_len;
        size_t available_len;
        size_t copy_len;
        size_t dump_len;
        void *copy;
        int rc;

        /* Sanity checks */
        assert ( PCI_VPD_TAG ( field ) == PCI_VPD_TAG_RW );
        assert ( PCI_VPD_KEYWORD ( field ) != 0 );
        assert ( field != PCI_VPD_FIELD_RW );

        /* Locate 'RW' field */
        if ( ( rc = pci_vpd_find ( vpd, PCI_VPD_FIELD_RW, &rw_address,
                                   &rw_len ) ) != 0 )
                goto err_no_rw;

        /* Locate old field, if any */
        if ( ( rc = pci_vpd_find ( vpd, field, &old_address,
                                   &old_len ) ) == 0 ) {

                /* Field already exists */
                if ( old_address > rw_address ) {
                        DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
                               " at [%04x,%04zx) is after field "
                               PCI_VPD_FIELD_FMT " at [%04x,%04zx)\n",
                               PCI_ARGS ( vpd->pci ),
                               PCI_VPD_FIELD_ARGS ( field ),
                               old_address, ( old_address + old_len ),
                               PCI_VPD_FIELD_ARGS ( PCI_VPD_FIELD_RW ),
                               rw_address, ( rw_address + rw_len ) );
                        rc = -ENXIO;
                        goto err_after_rw;
                }
                dst_address = ( old_address - sizeof ( old_field ) );
                copy_address = ( old_address + old_len );
                copy_len = ( rw_address - sizeof ( rw_field ) - copy_address );

                /* Calculate available length */
                available_len = ( rw_len + old_len );

        } else {

                /* Field does not yet exist */
                dst_address = ( rw_address - sizeof ( rw_field ) );
                copy_address = dst_address;
                copy_len = 0;

                /* Calculate available length */
                available_len = ( ( rw_len > sizeof ( new_field ) ) ?
                                  ( rw_len - sizeof ( new_field ) ) : 0 );
        }

        /* Dump region before changes */
        dump_address = dst_address;
        dump_len = ( rw_address + rw_len - dump_address );
        DBGC ( vpd, PCI_FMT " VPD before resizing field " PCI_VPD_FIELD_FMT
               " to %zd bytes:\n", PCI_ARGS ( vpd->pci ),
               PCI_VPD_FIELD_ARGS ( field ), len );
        pci_vpd_dump ( vpd, dump_address, dump_len );

        /* Check available length */
        if ( available_len > PCI_VPD_MAX_LEN )
                available_len = PCI_VPD_MAX_LEN;
        if ( len > available_len ) {
                DBGC ( vpd, PCI_FMT " VPD no space for field "
                       PCI_VPD_FIELD_FMT " (need %02zx, have %02zx)\n",
                       PCI_ARGS ( vpd->pci ), PCI_VPD_FIELD_ARGS ( field ),
                       len, available_len );
                rc = -ENOSPC;
                goto err_no_space;
        }

        /* Preserve intermediate fields, if any */
        copy = malloc ( copy_len );
        if ( ! copy ) {
                rc = -ENOMEM;
                goto err_copy_alloc;
        }
        if ( ( rc = pci_vpd_read ( vpd, copy_address, copy, copy_len ) ) != 0 )
                goto err_copy_read;

        /* Create new field, if applicable */
        if ( len ) {
                new_field.keyword = PCI_VPD_KEYWORD ( field );
                new_field.len = len;
                if ( ( rc = pci_vpd_write ( vpd, dst_address, &new_field,
                                            sizeof ( new_field ) ) ) != 0 )
                        goto err_new_write;
                dst_address += sizeof ( new_field );
                *address = dst_address;
                DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " is now "
                       "at [%04x,%04x)\n", PCI_ARGS ( vpd->pci ),
                       PCI_VPD_FIELD_ARGS ( field ), dst_address,
                       ( dst_address + new_field.len ) );
                dst_address += len;
        } else {
                DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT
                       " no longer exists\n", PCI_ARGS ( vpd->pci ),
                       PCI_VPD_FIELD_ARGS ( field ) );
        }

        /* Restore intermediate fields, if any */
        if ( ( rc = pci_vpd_write ( vpd, dst_address, copy, copy_len ) ) != 0 )
                goto err_copy_write;
        dst_address += copy_len;

        /* Create 'RW' field */
        rw_field.keyword = PCI_VPD_KEYWORD ( PCI_VPD_FIELD_RW );
        rw_field.len = ( rw_len +
                         ( rw_address - sizeof ( rw_field ) ) - dst_address );
        if ( ( rc = pci_vpd_write ( vpd, dst_address, &rw_field,
                                    sizeof ( rw_field ) ) ) != 0 )
                goto err_rw_write;
        dst_address += sizeof ( rw_field );
        DBGC ( vpd, PCI_FMT " VPD field " PCI_VPD_FIELD_FMT " is now "
               "at [%04x,%04x)\n", PCI_ARGS ( vpd->pci ),
               PCI_VPD_FIELD_ARGS ( PCI_VPD_FIELD_RW ), dst_address,
               ( dst_address + rw_field.len ) );

        /* Dump region after changes */
        DBGC ( vpd, PCI_FMT " VPD after resizing field " PCI_VPD_FIELD_FMT
               " to %zd bytes:\n", PCI_ARGS ( vpd->pci ),
               PCI_VPD_FIELD_ARGS ( field ), len );
        pci_vpd_dump ( vpd, dump_address, dump_len );

        rc = 0;

 err_rw_write:
 err_new_write:
 err_copy_write:
 err_copy_read:
        free ( copy );
 err_copy_alloc:
 err_no_space:
 err_after_rw:
 err_no_rw:
        return rc;
}