mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-24 01:41:39 +00:00
![Cai Huoqing](/assets/img/avatar_default.png)
use SPDX-License-Identifier instead of a verbose license text Link: https://lore.kernel.org/r/20210823042622.109-1-caihuoqing@baidu.com Signed-off-by: Cai Huoqing <caihuoqing@baidu.com> Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
450 lines
11 KiB
C
450 lines
11 KiB
C
// 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;
|
|
}
|