mirror of
https://github.com/trezor/trezor-firmware.git
synced 2024-12-27 00:28:10 +00:00
112 lines
3.1 KiB
C
112 lines
3.1 KiB
C
/*
|
|
* This file is part of the TREZOR project, https://trezor.io/
|
|
*
|
|
* Copyright (c) SatoshiLabs
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "common.h"
|
|
#include "sdcard.h"
|
|
#include "profile.h"
|
|
|
|
#ifndef SDCARD_FILE
|
|
#define SDCARD_FILE profile_sdcard_path()
|
|
#endif
|
|
|
|
#define SDCARD_SIZE (32 * 1024 * 1024)
|
|
|
|
static uint8_t *sdcard_buffer;
|
|
static secbool sdcard_powered;
|
|
|
|
static void sdcard_exit(void)
|
|
{
|
|
int r = munmap(sdcard_buffer, SDCARD_SIZE);
|
|
ensure(sectrue * (r == 0), "munmap failed");
|
|
}
|
|
|
|
void sdcard_init(void) {
|
|
int r;
|
|
|
|
// check whether the file exists and it has the correct size
|
|
struct stat sb;
|
|
r = stat(SDCARD_FILE, &sb);
|
|
|
|
// (re)create if non existant or wrong size
|
|
if (r != 0 || sb.st_size != SDCARD_SIZE) {
|
|
int fd = open(SDCARD_FILE, O_RDWR | O_CREAT | O_TRUNC, (mode_t)0600);
|
|
ensure(sectrue * (fd >= 0), "open failed");
|
|
for (int i = 0; i < SDCARD_SIZE / 16; i++) {
|
|
ssize_t s = write(fd, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 16);
|
|
ensure(sectrue * (s >= 0), "write failed");
|
|
}
|
|
r = close(fd);
|
|
ensure(sectrue * (r == 0), "close failed");
|
|
}
|
|
|
|
// mmap file
|
|
int fd = open(SDCARD_FILE, O_RDWR);
|
|
ensure(sectrue * (fd >= 0), "open failed");
|
|
|
|
void *map = mmap(0, SDCARD_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
|
ensure(sectrue * (map != MAP_FAILED), "mmap failed");
|
|
|
|
sdcard_buffer = (uint8_t *)map;
|
|
|
|
sdcard_powered = secfalse;
|
|
|
|
atexit(sdcard_exit);
|
|
}
|
|
|
|
secbool sdcard_is_present(void) {
|
|
return sectrue;
|
|
}
|
|
|
|
secbool sdcard_power_on(void) {
|
|
sdcard_powered = sectrue;
|
|
return sectrue;
|
|
}
|
|
|
|
void sdcard_power_off(void) {
|
|
sdcard_powered = secfalse;
|
|
}
|
|
|
|
uint64_t sdcard_get_capacity_in_bytes(void) {
|
|
return sdcard_powered == sectrue ? SDCARD_SIZE : 0;
|
|
}
|
|
|
|
secbool sdcard_read_blocks(uint32_t *dest, uint32_t block_num, uint32_t num_blocks) {
|
|
if (sectrue != sdcard_powered) {
|
|
return secfalse;
|
|
}
|
|
memcpy(dest, sdcard_buffer + block_num * SDCARD_BLOCK_SIZE, num_blocks * SDCARD_BLOCK_SIZE);
|
|
return sectrue;
|
|
}
|
|
|
|
secbool sdcard_write_blocks(const uint32_t *src, uint32_t block_num, uint32_t num_blocks) {
|
|
if (sectrue != sdcard_powered) {
|
|
return secfalse;
|
|
}
|
|
memcpy(sdcard_buffer + block_num * SDCARD_BLOCK_SIZE, src, num_blocks * SDCARD_BLOCK_SIZE);
|
|
return sectrue;
|
|
}
|