/* SPDX-License-Identifier: GPL-2.0-only */ #include <boot_device.h> #include <symbols.h> #include <console/console.h> #include <assert.h> #include <commonlib/storage/sd_mmc.h> #include <cbfs.h> #include <soc/ti/am335x/mmc.h> #include <soc/ti/am335x/header.h> // Where the coreboot image is expected to be located on the SD card // Only certain locations are allowed - check the AM335x technical reference // manual for more details. #define COREBOOT_IMAGE_OFFSET (128 * KiB) #define SD_BLOCK_SIZE 512 static struct am335x_mmc_host sd_host; static struct storage_media media; static size_t partial_block_read(uint8_t *dest, uint64_t block, uint32_t offset, uint32_t count) { static uint8_t overflow_block[SD_BLOCK_SIZE]; uint64_t blocks_read = storage_block_read(&media, block, 1, &overflow_block); if (blocks_read != 1) { printk(BIOS_ERR, "Expected to read 1 block but read: %llu\n", blocks_read); return 0; } assert((offset + count) <= SD_BLOCK_SIZE); int dest_index = 0; for (int overflow_index = offset; overflow_index < (offset + count); overflow_index++) dest[dest_index++] = overflow_block[overflow_index]; return count; } // This supports reads from a SD card that aren't necessarily aligned to the // sd block size static ssize_t sd_readat(const struct region_device *rdev, void *dest, size_t offset, size_t count) { uint8_t *buffer = (uint8_t *)dest; uint64_t block_start = offset / SD_BLOCK_SIZE; uint64_t block_end = (offset + count) / SD_BLOCK_SIZE; uint64_t blocks = block_end - block_start + 1; // Read the last first, which might not be aligned on a SD block uint32_t first_block_offset = offset % SD_BLOCK_SIZE; size_t first_block_to_read = MIN(SD_BLOCK_SIZE - first_block_offset, count); size_t bytes_read = partial_block_read(buffer, block_start, first_block_offset, first_block_to_read); if (blocks == 1) return bytes_read; buffer += bytes_read; if (blocks > 2) { // Read all the "whole" blocks between the start and end blocks uint64_t to_read = blocks - 2; uint64_t blocks_read = storage_block_read(&media, block_start + 1, to_read, (void *)buffer); if (blocks_read != to_read) { printk(BIOS_ERR, "Expecting to read %llu blocks but only read %llu\n", to_read, blocks_read); return blocks_read * SD_BLOCK_SIZE; } buffer += to_read * SD_BLOCK_SIZE; bytes_read += to_read * SD_BLOCK_SIZE; } // Read the last block, which might not be aligned on a SD block bytes_read += partial_block_read(buffer, block_end, 0, count - bytes_read); return bytes_read; } static const struct region_device_ops am335x_sd_ops = { .mmap = mmap_helper_rdev_mmap, .munmap = mmap_helper_rdev_munmap, .readat = sd_readat, }; extern struct omap_image_headers headers; static struct mmap_helper_region_device sd_mdev = MMAP_HELPER_DEV_INIT( &am335x_sd_ops, COREBOOT_IMAGE_OFFSET + sizeof(headers), CONFIG_ROM_SIZE, &cbfs_cache); static bool init_done = false; void boot_device_init(void) { if (init_done) return; sd_host.sd_clock_hz = 96000000; sd_host.reg = (void *)MMCHS0_BASE; am335x_mmc_init_storage(&sd_host); storage_setup_media(&media, &sd_host.sd_mmc_ctrlr); storage_display_setup(&media); init_done = true; } const struct region_device *boot_device_ro(void) { return &sd_mdev.rdev; }