FM10K/fm10k-dump
FM10K/fm10k-dump
1
0
Fork 0
Code Issues Pull requests Releases 5 Activity

Apply consistent spaces and style across project
All checks were successful
continuous-integration/drone/push Build is passing
Details
continuous-integration/drone/tag Build is passing
Details

Browse source
This commit is contained in:
DataHoarder 2021-12-19 15:32:37 +01:00
parent 702209cbe6
commit 37b1644120
5 changed files with 135 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/fm10k-dump.c
View file

@ -55,7 +55,7 @@ int main(int argc, char **argv) {
FM10K_PCI_MAPPED_DEVICE map;
FM10K_PCI_DEVICES devices = fm10k_pci_findDevices();
if(fm10k_pci_findDevice(&devices, &map)){
if (fm10k_pci_findDevice(&devices, &map)) {
printf("Unable to find FM10K device with BAR4 port access, or could not take SPI lock. Check bifurcation settings?\n");
return 1;
}

3
src/fm10k-flash.c
View file

@ -39,7 +39,6 @@
#include <unistd.h>
int main(int argc, char **argv) {
FILE *fdBackup;
FILE *fdInput;
@ -79,7 +78,7 @@ int main(int argc, char **argv) {
FM10K_PCI_MAPPED_DEVICE map;
FM10K_PCI_DEVICES devices = fm10k_pci_findDevices();
if(fm10k_pci_findDevice(&devices, &map)){
if (fm10k_pci_findDevice(&devices, &map)) {
printf("Unable to find FM10K device with BAR4 port access, or could not take SPI lock. Check bifurcation settings?\n");
return 1;
}

53
src/fm10k.c
View file

@ -430,43 +430,43 @@ const KNOWN_FLASH_DEVICE *getKnownFlashFromManufacturerData(SPI_COMMAND_READ_MAN
return NULL;
}
uint8_t fm10k_mem_spi_LockTake(uintptr_t mem){
uint8_t fm10k_mem_spi_LockTake(uintptr_t mem) {
uint32_t maxTries = 64;
API_SPI_LOCK_STATE spiLock;
do{
do {
ReadRegister32(mem, FM10K_API_SPI_LOCK_STATE, &spiLock.value);
if(!spiLock.fields.LockTaken){
if (!spiLock.fields.LockTaken) {
spiLock.fields.LockTaken = 1;
spiLock.fields.LockOwner = 0; //Switch API
WriteRegister32(mem, FM10K_API_SPI_LOCK_STATE, spiLock.value);
nanosleep(&(struct timespec){0, 50000}, NULL); //Delay to observe if lock was actually taken by us
nanosleep(&(struct timespec) {0, 50000}, NULL); //Delay to observe if lock was actually taken by us
ReadRegister32(mem, FM10K_API_SPI_LOCK_STATE, &spiLock.value);
if(spiLock.fields.LockTaken && spiLock.fields.LockOwner == 0){
if (spiLock.fields.LockTaken && spiLock.fields.LockOwner == 0) {
printf("Taken SPI Lock\n");
return 0;
}
}else if(spiLock.fields.LockOwner == 0){ //Are we taking a lock again, with same owner?
} else if (spiLock.fields.LockOwner == 0) { //Are we taking a lock again, with same owner?
printf("WARNING: SPI Lock was already taken by us, maybe other process was using it?\n");
return 0;
}
nanosleep(&(struct timespec){0, 1000}, NULL);
nanosleep(&(struct timespec) {0, 1000}, NULL);
} while (--maxTries);
return 1;
}
void fm10k_mem_spi_LockRelease(uintptr_t mem){
void fm10k_mem_spi_LockRelease(uintptr_t mem) {
API_SPI_LOCK_STATE spiLock;
ReadRegister32(mem, FM10K_API_SPI_LOCK_STATE, &spiLock.value);
if(!spiLock.fields.LockTaken) {
if (!spiLock.fields.LockTaken) {
printf("WARNING: SPI Lock was already released\n");
return;
}
if(spiLock.fields.LockOwner != 0){
if (spiLock.fields.LockOwner != 0) {
printf("WARNING: SPI Lock Owner unexpected: %u\n", spiLock.fields.LockOwner);
return;
}
@ -479,7 +479,7 @@ void fm10k_mem_spi_LockRelease(uintptr_t mem){
uint32_t bsm_interruptMask[2] = {0, 0};
void fm10k_mem_bsm_DisableInterrupts(uintptr_t mem){
void fm10k_mem_bsm_DisableInterrupts(uintptr_t mem) {
//Save old registers
ReadRegister32(mem, FM10K_REGISTER_INTERRUPT_MASK_BSM(0), bsm_interruptMask);
ReadRegister32(mem, FM10K_REGISTER_INTERRUPT_MASK_BSM(1), bsm_interruptMask + 1);
@ -487,34 +487,34 @@ void fm10k_mem_bsm_DisableInterrupts(uintptr_t mem){
WriteRegister32(mem, FM10K_REGISTER_INTERRUPT_MASK_BSM(1), 0xFFFFFFFF);
}
void fm10k_mem_bsm_RestoreInterrupts(uintptr_t mem){
void fm10k_mem_bsm_RestoreInterrupts(uintptr_t mem) {
WriteRegister32(mem, FM10K_REGISTER_INTERRUPT_MASK_BSM(0), bsm_interruptMask[0]);
WriteRegister32(mem, FM10K_REGISTER_INTERRUPT_MASK_BSM(1), bsm_interruptMask[1]);
}
uint8_t fm10k_mem_TakePlatformLock(uintptr_t mem){
if(fm10k_mem_spi_LockTake(mem)){
uint8_t fm10k_mem_TakePlatformLock(uintptr_t mem) {
if (fm10k_mem_spi_LockTake(mem)) {
return 1;
}
fm10k_mem_bsm_DisableInterrupts(mem);
return 0;
}
void fm10k_mem_ReleasePlatformLock(uintptr_t mem){
void fm10k_mem_ReleasePlatformLock(uintptr_t mem) {
fm10k_mem_spi_LockRelease(mem);
fm10k_mem_bsm_RestoreInterrupts(mem);
}
int fm10k_pci_unmapDevice(FM10K_PCI_MAPPED_DEVICE* map){
if(map->map != NULL && map->map != MAP_FAILED){
if(munmap(map->map, FM10K_BAR4_SIZE) != 0){
int fm10k_pci_unmapDevice(FM10K_PCI_MAPPED_DEVICE *map) {
if (map->map != NULL && map->map != MAP_FAILED) {
if (munmap(map->map, FM10K_BAR4_SIZE) != 0) {
return 1;
}
map->map = NULL;
}
if (map->fd > 0) {
if(close(map->fd) != 0){
if (close(map->fd) != 0) {
return 1;
}
map->fd = 0;
@ -523,7 +523,7 @@ int fm10k_pci_unmapDevice(FM10K_PCI_MAPPED_DEVICE* map){
return 0;
}
int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE* device, FM10K_PCI_MAPPED_DEVICE* map){
int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE *device, FM10K_PCI_MAPPED_DEVICE *map) {
int fdBAR4;
fdBAR4 = open(device->bar4Path, O_RDWR);
if (fdBAR4 <= 0) {
@ -543,7 +543,7 @@ int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE* device, FM10K_PCI_MAPPED_DEVICE*
map->fd = fdBAR4;
map->map = memmapAddr;
if(fm10k_mem_TakePlatformLock((uintptr_t) map->map)){
if (fm10k_mem_TakePlatformLock((uintptr_t) map->map)) {
//Error taking lock
fm10k_pci_unmapDevice(map);
return 1;
@ -552,13 +552,13 @@ int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE* device, FM10K_PCI_MAPPED_DEVICE*
return 0;
}
int fm10k_pci_findDevice(const FM10K_PCI_DEVICES* devices, FM10K_PCI_MAPPED_DEVICE* map) {
if(devices->count == 0){
int fm10k_pci_findDevice(const FM10K_PCI_DEVICES *devices, FM10K_PCI_MAPPED_DEVICE *map) {
if (devices->count == 0) {
return 1;
}
for(uint32_t i = 0; i < devices->count; ++i){
if(fm10k_pci_mapDevice(&devices->devices[i], map) == 0){
for (uint32_t i = 0; i < devices->count; ++i) {
if (fm10k_pci_mapDevice(&devices->devices[i], map) == 0) {
return 0;
}
}
@ -608,7 +608,8 @@ FM10K_PCI_DEVICES fm10k_pci_findDevices() {
devices.devices[devices.count].vendor = vendor;
devices.devices[devices.count].class = class;
sprintf(devices.devices[devices.count].bar4Path, "/sys/bus/pci/devices/%s/resource4", entry->d_name);
sprintf(devices.devices[devices.count].bar4Path, "/sys/bus/pci/devices/%s/resource4",
entry->d_name);
++devices.count;
}
}

18
src/fm10k.h
View file

@ -70,9 +70,9 @@
typedef union {
uint32_t value;
struct {
uint8_t LockTaken : 1; //Whether lock is currently taken by anyone
uint8_t LockOwner : 2; //Who owns the lock. Switch API = 0, QV tools = 1, Board Manager = 2, RESERVED = 3
uint32_t Reserved : 29;
uint8_t LockTaken: 1; //Whether lock is currently taken by anyone
uint8_t LockOwner: 2; //Who owns the lock. Switch API = 0, QV tools = 1, Board Manager = 2, RESERVED = 3
uint32_t Reserved: 29;
} __attribute__((packed)) fields;
} API_SPI_LOCK_STATE;
@ -169,8 +169,8 @@ typedef struct {
} FM10K_PCI_DEVICE;
typedef struct {
const FM10K_PCI_DEVICE* device;
void* map;
const FM10K_PCI_DEVICE *device;
void *map;
int fd;
} FM10K_PCI_MAPPED_DEVICE;
@ -181,7 +181,9 @@ typedef struct {
FM10K_PCI_DEVICES fm10k_pci_findDevices();
int fm10k_pci_findDevice(const FM10K_PCI_DEVICES* devices, FM10K_PCI_MAPPED_DEVICE* map);
int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE* device, FM10K_PCI_MAPPED_DEVICE* map);
int fm10k_pci_unmapDevice(FM10K_PCI_MAPPED_DEVICE* map);
int fm10k_pci_findDevice(const FM10K_PCI_DEVICES *devices, FM10K_PCI_MAPPED_DEVICE *map);
int fm10k_pci_mapDevice(const FM10K_PCI_DEVICE *device, FM10K_PCI_MAPPED_DEVICE *map);
int fm10k_pci_unmapDevice(FM10K_PCI_MAPPED_DEVICE *map);

8
src/test.c
View file

@ -41,15 +41,17 @@ int main(int argc, char **argv) {
uint32_t testsFailed = 0;
{
SPI_CTRL s;
TEST((uint32_t)sizeof(s.fields), (uint32_t)sizeof(s.value), "SPI_CTRL packed misalignment. size struct %u, size value %u");
TEST((uint32_t) sizeof(s.fields), (uint32_t) sizeof(s.value), "SPI_CTRL packed misalignment. size struct %u, size value %u");
}
{
SPI_COMMAND_READ_MANUFACTURER_RESULT s;
TEST((uint32_t)sizeof(s.fields), (uint32_t)sizeof(s.value), "SPI_COMMAND_READ_MANUFACTURER_RESULT packed misalignment. size struct %u, size value %u");
TEST((uint32_t) sizeof(s.fields), (uint32_t) sizeof(s.value),
"SPI_COMMAND_READ_MANUFACTURER_RESULT packed misalignment. size struct %u, size value %u");
}
{
API_SPI_LOCK_STATE s;
TEST((uint32_t)sizeof(s.fields), (uint32_t)sizeof(s.value), "API_SPI_LOCK_STATE packed misalignment. size struct %u, size value %u");
TEST((uint32_t) sizeof(s.fields), (uint32_t) sizeof(s.value),
"API_SPI_LOCK_STATE packed misalignment. size struct %u, size value %u");
}
printf("\nTests run, failed %u/%u\n", testsFailed, tests);