2 * Copyright(c) 2015, 2016 Intel Corporation.
4 * This file is provided under a dual BSD/GPLv2 license. When using or
5 * redistributing this file, you may do so under either license.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of version 2 of the GNU General Public License as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
20 * Redistribution and use in source and binary forms, with or without
21 * modification, are permitted provided that the following conditions
24 * - Redistributions of source code must retain the above copyright
25 * notice, this list of conditions and the following disclaimer.
26 * - Redistributions in binary form must reproduce the above copyright
27 * notice, this list of conditions and the following disclaimer in
28 * the documentation and/or other materials provided with the
30 * - Neither the name of Intel Corporation nor the names of its
31 * contributors may be used to endorse or promote products derived
32 * from this software without specific prior written permission.
34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47 #include <linux/delay.h>
53 * The EPROM is logically divided into three partitions:
54 * partition 0: the first 128K, visible from PCI ROM BAR
55 * partition 1: 4K config file (sector size)
56 * partition 2: the rest
58 #define P0_SIZE (128 * 1024)
59 #define P1_SIZE (4 * 1024)
60 #define P1_START P0_SIZE
61 #define P2_START (P0_SIZE + P1_SIZE)
63 /* controller page size, in bytes */
64 #define EP_PAGE_SIZE 256
65 #define EP_PAGE_MASK (EP_PAGE_SIZE - 1)
66 #define EP_PAGE_DWORDS (EP_PAGE_SIZE / sizeof(u32))
68 /* controller commands */
71 #define CMD_READ_DATA(addr) ((0x03 << CMD_SHIFT) | addr)
72 #define CMD_RELEASE_POWERDOWN_NOID ((0xab << CMD_SHIFT))
74 /* controller interface speeds */
75 #define EP_SPEED_FULL 0x2 /* full speed */
78 * How long to wait for the EPROM to become available, in ms.
79 * The spec 32 Mb EPROM takes around 40s to erase then write.
80 * Double it for safety.
82 #define EPROM_TIMEOUT 80000 /* ms */
85 * Read a 256 byte (64 dword) EPROM page.
86 * All callers have verified the offset is at a page boundary.
88 static void read_page(struct hfi1_devdata *dd, u32 offset, u32 *result)
92 write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_READ_DATA(offset));
93 for (i = 0; i < EP_PAGE_DWORDS; i++)
94 result[i] = (u32)read_csr(dd, ASIC_EEP_DATA);
95 write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_NOP); /* close open page */
99 * Read length bytes starting at offset from the start of the EPROM.
101 static int read_length(struct hfi1_devdata *dd, u32 start, u32 len, void *dest)
103 u32 buffer[EP_PAGE_DWORDS];
115 * Make sure the read range is not outside of the controller read
116 * command address range. Note that '>' is correct below - the end
117 * of the range is OK if it stops at the limit, but no higher.
119 if (end > (1 << CMD_SHIFT))
122 /* read the first partial page */
123 start_offset = start & EP_PAGE_MASK;
125 /* partial starting page */
127 /* align and read the page that contains the start */
128 read_start = start & ~EP_PAGE_MASK;
129 read_page(dd, read_start, buffer);
131 /* the rest of the page is available data */
132 bytes = EP_PAGE_SIZE - start_offset;
135 /* end is within this page */
136 memcpy(dest, (u8 *)buffer + start_offset, len);
140 memcpy(dest, (u8 *)buffer + start_offset, bytes);
146 /* start is now page aligned */
148 /* read whole pages */
149 while (len >= EP_PAGE_SIZE) {
150 read_page(dd, start, buffer);
151 memcpy(dest, buffer, EP_PAGE_SIZE);
153 start += EP_PAGE_SIZE;
155 dest += EP_PAGE_SIZE;
158 /* read the last partial page */
160 read_page(dd, start, buffer);
161 memcpy(dest, buffer, len);
168 * Initialize the EPROM handler.
170 int eprom_init(struct hfi1_devdata *dd)
174 /* only the discrete chip has an EPROM */
175 if (dd->pcidev->device != PCI_DEVICE_ID_INTEL0)
179 * It is OK if both HFIs reset the EPROM as long as they don't
180 * do it at the same time.
182 ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT);
185 "%s: unable to acquire EPROM resource, no EPROM support\n",
190 /* reset EPROM to be sure it is in a good state */
193 write_csr(dd, ASIC_EEP_CTL_STAT, ASIC_EEP_CTL_STAT_EP_RESET_SMASK);
194 /* clear reset, set speed */
195 write_csr(dd, ASIC_EEP_CTL_STAT,
196 EP_SPEED_FULL << ASIC_EEP_CTL_STAT_RATE_SPI_SHIFT);
198 /* wake the device with command "release powerdown NoID" */
199 write_csr(dd, ASIC_EEP_ADDR_CMD, CMD_RELEASE_POWERDOWN_NOID);
201 dd->eprom_available = true;
202 release_chip_resource(dd, CR_EPROM);
207 /* magic character sequence that trails an image */
208 #define IMAGE_TRAIL_MAGIC "egamiAPO"
211 * Read all of partition 1. The actual file is at the front. Adjust
212 * the returned size if a trailing image magic is found.
214 static int read_partition_platform_config(struct hfi1_devdata *dd, void **data,
222 buffer = kmalloc(P1_SIZE, GFP_KERNEL);
226 ret = read_length(dd, P1_START, P1_SIZE, buffer);
232 /* scan for image magic that may trail the actual data */
233 p = strnstr(buffer, IMAGE_TRAIL_MAGIC, P1_SIZE);
245 * Read the platform configuration file from the EPROM.
247 * On success, an allocated buffer containing the data and its size are
248 * returned. It is up to the caller to free this buffer.
252 * -ENXIO - no EPROM is available
253 * -EBUSY - not able to acquire access to the EPROM
254 * -ENOENT - no recognizable file written
255 * -ENOMEM - buffer could not be allocated
257 int eprom_read_platform_config(struct hfi1_devdata *dd, void **data, u32 *size)
259 u32 directory[EP_PAGE_DWORDS]; /* aligned buffer */
262 if (!dd->eprom_available)
265 ret = acquire_chip_resource(dd, CR_EPROM, EPROM_TIMEOUT);
269 /* read the last page of P0 for the EPROM format magic */
270 ret = read_length(dd, P1_START - EP_PAGE_SIZE, EP_PAGE_SIZE, directory);
274 /* last dword of P0 contains a magic indicator */
275 if (directory[EP_PAGE_DWORDS - 1] == 0) {
276 /* partition format */
277 ret = read_partition_platform_config(dd, data, size);
281 /* nothing recognized */
285 release_chip_resource(dd, CR_EPROM);