| /* | |
| * 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; | |
| } |