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 begins an image */
208 #define IMAGE_START_MAGIC "APO="
210 /* magic character sequence that might trail an image */
211 #define IMAGE_TRAIL_MAGIC "egamiAPO"
213 /* EPROM file types */
214 #define HFI1_EFT_PLATFORM_CONFIG 2
216 /* segment size - 128 KiB */
217 #define SEG_SIZE (128 * 1024)
219 struct hfi1_eprom_footer
{
220 u32 oprom_size
; /* size of the oprom, in bytes */
221 u16 num_table_entries
;
222 u16 version
; /* version of this footer */
223 u32 magic
; /* must be last */
226 struct hfi1_eprom_table_entry
{
227 u32 type
; /* file type */
228 u32 offset
; /* file offset from start of EPROM */
229 u32 size
; /* file size, in bytes */
233 * Calculate the max number of table entries that will fit within a directory
234 * buffer of size 'dir_size'.
236 #define MAX_TABLE_ENTRIES(dir_size) \
237 (((dir_size) - sizeof(struct hfi1_eprom_footer)) / \
238 sizeof(struct hfi1_eprom_table_entry))
240 #define DIRECTORY_SIZE(n) (sizeof(struct hfi1_eprom_footer) + \
241 (sizeof(struct hfi1_eprom_table_entry) * (n)))
243 #define MAGIC4(a, b, c, d) ((d) << 24 | (c) << 16 | (b) << 8 | (a))
244 #define FOOTER_MAGIC MAGIC4('e', 'p', 'r', 'm')
245 #define FOOTER_VERSION 1
248 * Read all of partition 1. The actual file is at the front. Adjust
249 * the returned size if a trailing image magic is found.
251 static int read_partition_platform_config(struct hfi1_devdata
*dd
, void **data
,
259 buffer
= kmalloc(P1_SIZE
, GFP_KERNEL
);
263 ret
= read_length(dd
, P1_START
, P1_SIZE
, buffer
);
269 /* config partition is valid only if it starts with IMAGE_START_MAGIC */
270 if (memcmp(buffer
, IMAGE_START_MAGIC
, strlen(IMAGE_START_MAGIC
))) {
275 /* scan for image magic that may trail the actual data */
276 p
= strnstr(buffer
, IMAGE_TRAIL_MAGIC
, P1_SIZE
);
288 * The segment magic has been checked. There is a footer and table of
291 * directory is a u32 aligned buffer of size EP_PAGE_SIZE.
293 static int read_segment_platform_config(struct hfi1_devdata
*dd
,
294 void *directory
, void **data
, u32
*size
)
296 struct hfi1_eprom_footer
*footer
;
297 struct hfi1_eprom_table_entry
*table
;
298 struct hfi1_eprom_table_entry
*entry
;
300 void *table_buffer
= NULL
;
303 u32 seg_base
, seg_offset
;
304 u32 bytes_available
, ncopied
, to_copy
;
306 /* the footer is at the end of the directory */
307 footer
= (struct hfi1_eprom_footer
*)
308 (directory
+ EP_PAGE_SIZE
- sizeof(*footer
));
310 /* make sure the structure version is supported */
311 if (footer
->version
!= FOOTER_VERSION
)
314 /* oprom size cannot be larger than a segment */
315 if (footer
->oprom_size
>= SEG_SIZE
)
318 /* the file table must fit in a segment with the oprom */
319 if (footer
->num_table_entries
>
320 MAX_TABLE_ENTRIES(SEG_SIZE
- footer
->oprom_size
))
323 /* find the file table start, which precedes the footer */
324 directory_size
= DIRECTORY_SIZE(footer
->num_table_entries
);
325 if (directory_size
<= EP_PAGE_SIZE
) {
326 /* the file table fits into the directory buffer handed in */
327 table
= (struct hfi1_eprom_table_entry
*)
328 (directory
+ EP_PAGE_SIZE
- directory_size
);
330 /* need to allocate and read more */
331 table_buffer
= kmalloc(directory_size
, GFP_KERNEL
);
334 ret
= read_length(dd
, SEG_SIZE
- directory_size
,
335 directory_size
, table_buffer
);
338 table
= table_buffer
;
341 /* look for the platform configuration file in the table */
342 for (entry
= NULL
, i
= 0; i
< footer
->num_table_entries
; i
++) {
343 if (table
[i
].type
== HFI1_EFT_PLATFORM_CONFIG
) {
354 * Sanity check on the configuration file size - it should never
355 * be larger than 4 KiB.
357 if (entry
->size
> (4 * 1024)) {
358 dd_dev_err(dd
, "Bad configuration file size 0x%x\n",
364 /* check for bogus offset and size that wrap when added together */
365 if (entry
->offset
+ entry
->size
< entry
->offset
) {
367 "Bad configuration file start + size 0x%x+0x%x\n",
368 entry
->offset
, entry
->size
);
373 /* allocate the buffer to return */
374 buffer
= kmalloc(entry
->size
, GFP_KERNEL
);
381 * Extract the file by looping over segments until it is fully read.
383 seg_offset
= entry
->offset
% SEG_SIZE
;
384 seg_base
= entry
->offset
- seg_offset
;
386 while (ncopied
< entry
->size
) {
387 /* calculate data bytes available in this segment */
389 /* start with the bytes from the current offset to the end */
390 bytes_available
= SEG_SIZE
- seg_offset
;
391 /* subtract off footer and table from segment 0 */
394 * Sanity check: should not have a starting point
395 * at or within the directory.
397 if (bytes_available
<= directory_size
) {
399 "Bad configuration file - offset 0x%x within footer+table\n",
404 bytes_available
-= directory_size
;
407 /* calculate bytes wanted */
408 to_copy
= entry
->size
- ncopied
;
410 /* max out at the available bytes in this segment */
411 if (to_copy
> bytes_available
)
412 to_copy
= bytes_available
;
415 * Read from the EPROM.
417 * The sanity check for entry->offset is done in read_length().
418 * The EPROM offset is validated against what the hardware
419 * addressing supports. In addition, if the offset is larger
420 * than the actual EPROM, it silently wraps. It will work
421 * fine, though the reader may not get what they expected
424 ret
= read_length(dd
, seg_base
+ seg_offset
, to_copy
,
431 /* set up for next segment */
432 seg_offset
= footer
->oprom_size
;
433 seg_base
+= SEG_SIZE
;
449 * Read the platform configuration file from the EPROM.
451 * On success, an allocated buffer containing the data and its size are
452 * returned. It is up to the caller to free this buffer.
456 * -ENXIO - no EPROM is available
457 * -EBUSY - not able to acquire access to the EPROM
458 * -ENOENT - no recognizable file written
459 * -ENOMEM - buffer could not be allocated
460 * -EINVAL - invalid EPROM contentents found
462 int eprom_read_platform_config(struct hfi1_devdata
*dd
, void **data
, u32
*size
)
464 u32 directory
[EP_PAGE_DWORDS
]; /* aligned buffer */
467 if (!dd
->eprom_available
)
470 ret
= acquire_chip_resource(dd
, CR_EPROM
, EPROM_TIMEOUT
);
474 /* read the last page of the segment for the EPROM format magic */
475 ret
= read_length(dd
, SEG_SIZE
- EP_PAGE_SIZE
, EP_PAGE_SIZE
, directory
);
479 /* last dword of the segment contains a magic value */
480 if (directory
[EP_PAGE_DWORDS
- 1] == FOOTER_MAGIC
) {
482 ret
= read_segment_platform_config(dd
, directory
, data
, size
);
484 /* partition format */
485 ret
= read_partition_platform_config(dd
, data
, size
);
489 release_chip_resource(dd
, CR_EPROM
);