Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Dean Luick | 1195 | 83.98% | 5 | 55.56% |
Mike Marciniszyn | 189 | 13.28% | 1 | 11.11% |
Jan Sokolowski | 37 | 2.60% | 1 | 11.11% |
caihuoqing | 1 | 0.07% | 1 | 11.11% |
Krzysztof Kozlowski | 1 | 0.07% | 1 | 11.11% |
Total | 1423 | 9 |
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause /* * Copyright(c) 2015, 2016 Intel Corporation. */ #include <linux/delay.h> #include "hfi.h" #include "common.h" #include "eprom.h" /* * The EPROM is logically divided into three partitions: * partition 0: the first 128K, visible from PCI ROM BAR * partition 1: 4K config file (sector size) * partition 2: the rest */ #define P0_SIZE (128 * 1024) #define P1_SIZE (4 * 1024) #define P1_START P0_SIZE #define P2_START (P0_SIZE + P1_SIZE) /* controller page size, in bytes */ #define EP_PAGE_SIZE 256 #define EP_PAGE_MASK (EP_PAGE_SIZE - 1) #define EP_PAGE_DWORDS (EP_PAGE_SIZE / sizeof(u32)) /* controller commands */ #define CMD_SHIFT 24 #define CMD_NOP (0) #define CMD_READ_DATA(addr) ((0x03 << CMD_SHIFT) | addr) #define CMD_RELEASE_POWERDOWN_NOID ((0xab << CMD_SHIFT)) /* controller interface speeds */ #define EP_SPEED_FULL 0x2 /* full speed */ /* * How long to wait for the EPROM to become available, in ms. * The spec 32 Mb EPROM takes around 40s to erase then write. * Double it for safety. */ #define EPROM_TIMEOUT 80000 /* ms */ /* * Read a 256 byte (64 dword) EPROM page. * All callers have verified the offset is at a page boundary. */ static void read_page(struct hfi1_devdata *dd, u32 offset, u32 *result) { int i; write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_READ_DATA(offset)); for (i = 0; i < EP_PAGE_DWORDS; i++) result[i] = (u32)read_csr(dd, ASIC_EEP_DATA); write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_NOP); /* close open page */ } /* * Read length bytes starting at offset from the start of the EPROM. */ static int read_length(struct hfi1_devdata *dd, u32 start, u32 len, void *dest) { u32 buffer[EP_PAGE_DWORDS]; u32 end; u32 start_offset; u32 read_start; u32 bytes; if (len == 0) return 0; end = start + len; /* * Make sure the read range is not outside of the controller read * command address range. Note that '>' is correct below - the end * of the range is OK if it stops at the limit, but no higher. */ if (end > (1 << CMD_SHIFT)) return -EINVAL; /* read the first partial page */ start_offset = start & EP_PAGE_MASK; if (start_offset) { /* partial starting page */ /* align and read the page that contains the start */ read_start = start & ~EP_PAGE_MASK; read_page(dd, read_start, buffer); /* the rest of the page is available data */ bytes = EP_PAGE_SIZE - start_offset; if (len <= bytes) { /* end is within this page */ memcpy(dest, (u8 *)buffer + start_offset, len); return 0; } memcpy(dest, (u8 *)buffer + start_offset, bytes); start += bytes; len -= bytes; dest += bytes; } /* start is now page aligned */ /* read whole pages */ while (len >= EP_PAGE_SIZE) { read_page(dd, start, buffer); memcpy(dest, buffer, EP_PAGE_SIZE); start += EP_PAGE_SIZE; len -= EP_PAGE_SIZE; dest += EP_PAGE_SIZE; } /* read the last partial page */ if (len) { read_page(dd, start, buffer); memcpy(dest, buffer, len); } return 0; } /* * Initialize the EPROM handler. */ int eprom_init(struct hfi1_devdata *dd) { int ret = 0; /* only the discrete chip has an EPROM */ if (dd->pcidev->device != PCI_DEVICE_ID_INTEL0) return 0; /* * It is OK if both HFIs reset the EPROM as long as they don't * do it at the same time. */ ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT); if (ret) { dd_dev_err(dd, "%s: unable to acquire EPROM resource, no EPROM support\n", __func__); goto done_asic; } /* reset EPROM to be sure it is in a good state */ /* set reset */ write_csr(dd, ASIC_EEP_CTL_STAT, ASIC_EEP_CTL_STAT_EP_RESET_SMASK); /* clear reset, set speed */ write_csr(dd, ASIC_EEP_CTL_STAT, EP_SPEED_FULL << ASIC_EEP_CTL_STAT_RATE_SPI_SHIFT); /* wake the device with command "release powerdown NoID" */ write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_RELEASE_POWERDOWN_NOID); dd->eprom_available = true; release_chip_resource(dd, CR_EPROM); done_asic: return ret; } /* magic character sequence that begins an image */ #define IMAGE_START_MAGIC "APO=" /* magic character sequence that might trail an image */ #define IMAGE_TRAIL_MAGIC "egamiAPO" /* EPROM file types */ #define HFI1_EFT_PLATFORM_CONFIG 2 /* segment size - 128 KiB */ #define SEG_SIZE (128 * 1024) struct hfi1_eprom_footer { u32 oprom_size; /* size of the oprom, in bytes */ u16 num_table_entries; u16 version; /* version of this footer */ u32 magic; /* must be last */ }; struct hfi1_eprom_table_entry { u32 type; /* file type */ u32 offset; /* file offset from start of EPROM */ u32 size; /* file size, in bytes */ }; /* * Calculate the max number of table entries that will fit within a directory * buffer of size 'dir_size'. */ #define MAX_TABLE_ENTRIES(dir_size) \ (((dir_size) - sizeof(struct hfi1_eprom_footer)) / \ sizeof(struct hfi1_eprom_table_entry)) #define DIRECTORY_SIZE(n) (sizeof(struct hfi1_eprom_footer) + \ (sizeof(struct hfi1_eprom_table_entry) * (n))) #define MAGIC4(a, b, c, d) ((d) << 24 | (c) << 16 | (b) << 8 | (a)) #define FOOTER_MAGIC MAGIC4('e', 'p', 'r', 'm') #define FOOTER_VERSION 1 /* * Read all of partition 1. The actual file is at the front. Adjust * the returned size if a trailing image magic is found. */ static int read_partition_platform_config(struct hfi1_devdata *dd, void **data, u32 *size) { void *buffer; void *p; u32 length; int ret; buffer = kmalloc(P1_SIZE, GFP_KERNEL); if (!buffer) return -ENOMEM; ret = read_length(dd, P1_START, P1_SIZE, buffer); if (ret) { kfree(buffer); return ret; } /* config partition is valid only if it starts with IMAGE_START_MAGIC */ if (memcmp(buffer, IMAGE_START_MAGIC, strlen(IMAGE_START_MAGIC))) { kfree(buffer); return -ENOENT; } /* scan for image magic that may trail the actual data */ p = strnstr(buffer, IMAGE_TRAIL_MAGIC, P1_SIZE); if (p) length = p - buffer; else length = P1_SIZE; *data = buffer; *size = length; return 0; } /* * The segment magic has been checked. There is a footer and table of * contents present. * * directory is a u32 aligned buffer of size EP_PAGE_SIZE. */ static int read_segment_platform_config(struct hfi1_devdata *dd, void *directory, void **data, u32 *size) { struct hfi1_eprom_footer *footer; struct hfi1_eprom_table_entry *table; struct hfi1_eprom_table_entry *entry; void *buffer = NULL; void *table_buffer = NULL; int ret, i; u32 directory_size; u32 seg_base, seg_offset; u32 bytes_available, ncopied, to_copy; /* the footer is at the end of the directory */ footer = (struct hfi1_eprom_footer *) (directory + EP_PAGE_SIZE - sizeof(*footer)); /* make sure the structure version is supported */ if (footer->version != FOOTER_VERSION) return -EINVAL; /* oprom size cannot be larger than a segment */ if (footer->oprom_size >= SEG_SIZE) return -EINVAL; /* the file table must fit in a segment with the oprom */ if (footer->num_table_entries > MAX_TABLE_ENTRIES(SEG_SIZE - footer->oprom_size)) return -EINVAL; /* find the file table start, which precedes the footer */ directory_size = DIRECTORY_SIZE(footer->num_table_entries); if (directory_size <= EP_PAGE_SIZE) { /* the file table fits into the directory buffer handed in */ table = (struct hfi1_eprom_table_entry *) (directory + EP_PAGE_SIZE - directory_size); } else { /* need to allocate and read more */ table_buffer = kmalloc(directory_size, GFP_KERNEL); if (!table_buffer) return -ENOMEM; ret = read_length(dd, SEG_SIZE - directory_size, directory_size, table_buffer); if (ret) goto done; table = table_buffer; } /* look for the platform configuration file in the table */ for (entry = NULL, i = 0; i < footer->num_table_entries; i++) { if (table[i].type == HFI1_EFT_PLATFORM_CONFIG) { entry = &table[i]; break; } } if (!entry) { ret = -ENOENT; goto done; } /* * Sanity check on the configuration file size - it should never * be larger than 4 KiB. */ if (entry->size > (4 * 1024)) { dd_dev_err(dd, "Bad configuration file size 0x%x\n", entry->size); ret = -EINVAL; goto done; } /* check for bogus offset and size that wrap when added together */ if (entry->offset + entry->size < entry->offset) { dd_dev_err(dd, "Bad configuration file start + size 0x%x+0x%x\n", entry->offset, entry->size); ret = -EINVAL; goto done; } /* allocate the buffer to return */ buffer = kmalloc(entry->size, GFP_KERNEL); if (!buffer) { ret = -ENOMEM; goto done; } /* * Extract the file by looping over segments until it is fully read. */ seg_offset = entry->offset % SEG_SIZE; seg_base = entry->offset - seg_offset; ncopied = 0; while (ncopied < entry->size) { /* calculate data bytes available in this segment */ /* start with the bytes from the current offset to the end */ bytes_available = SEG_SIZE - seg_offset; /* subtract off footer and table from segment 0 */ if (seg_base == 0) { /* * Sanity check: should not have a starting point * at or within the directory. */ if (bytes_available <= directory_size) { dd_dev_err(dd, "Bad configuration file - offset 0x%x within footer+table\n", entry->offset); ret = -EINVAL; goto done; } bytes_available -= directory_size; } /* calculate bytes wanted */ to_copy = entry->size - ncopied; /* max out at the available bytes in this segment */ if (to_copy > bytes_available) to_copy = bytes_available; /* * Read from the EPROM. * * The sanity check for entry->offset is done in read_length(). * The EPROM offset is validated against what the hardware * addressing supports. In addition, if the offset is larger * than the actual EPROM, it silently wraps. It will work * fine, though the reader may not get what they expected * from the EPROM. */ ret = read_length(dd, seg_base + seg_offset, to_copy, buffer + ncopied); if (ret) goto done; ncopied += to_copy; /* set up for next segment */ seg_offset = footer->oprom_size; seg_base += SEG_SIZE; } /* success */ ret = 0; *data = buffer; *size = entry->size; done: kfree(table_buffer); if (ret) kfree(buffer); return ret; } /* * Read the platform configuration file from the EPROM. * * On success, an allocated buffer containing the data and its size are * returned. It is up to the caller to free this buffer. * * Return value: * 0 - success * -ENXIO - no EPROM is available * -EBUSY - not able to acquire access to the EPROM * -ENOENT - no recognizable file written * -ENOMEM - buffer could not be allocated * -EINVAL - invalid EPROM contentents found */ int eprom_read_platform_config(struct hfi1_devdata *dd, void **data, u32 *size) { u32 directory[EP_PAGE_DWORDS]; /* aligned buffer */ int ret; if (!dd->eprom_available) return -ENXIO; ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT); if (ret) return -EBUSY; /* read the last page of the segment for the EPROM format magic */ ret = read_length(dd, SEG_SIZE - EP_PAGE_SIZE, EP_PAGE_SIZE, directory); if (ret) goto done; /* last dword of the segment contains a magic value */ if (directory[EP_PAGE_DWORDS - 1] == FOOTER_MAGIC) { /* segment format */ ret = read_segment_platform_config(dd, directory, data, size); } else { /* partition format */ ret = read_partition_platform_config(dd, data, size); } done: release_chip_resource(dd, CR_EPROM); return ret; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1