virtual to physical addressing with mmap - memory

Question

I want to write to a physical address to change the voltage of a pin using an ARM board- but in order to write to a physical address, I need to take a virtual address, and map it to the physical address using mmap.
So I did that, in this way:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/mman.h>
#define MAP_SIZE 4096UL
#define MAP_MASK (MAP_SIZE - 1)
int main(void) {
int fd;
int *map_base_c,*map_base_d, *map_base_p, *virt_addr;
off_t target,control,data,pullup;
control=0x56000050;
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
map_base_d = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd,data & ~MAP_MASK);
printf("Memory mapped at address %p.\n", map_base_d);
virt_addr = map_base_d; //+ (data & MAP_MASK)
*virt_addr = 0x00; //This is where it goes off. find out why!!!
printf("Value at address 0x%X (%p): 0x%X\n", data, virt_addr,(*virt_addr));
close(fd);
return 0;
}
But, The pin didn't get a high voltage as I'd expected. Is there something wrong with the way I'm changing the address?
Also, is there a way to see the physical address which was mapped to the virtual address?
Thanks!

Answer 1

In your call to mmap, the offset argument should be the lowest physical address which you want access to. In your code, you pass data & ~MAP_MASK, and data hasn't been initialized (or has been default-initialized to 0).
I believe you want something similar to the following:
uintptr_t control = 0x56000050;
uintptr_t base = control & ~MAP_MASK;
int fd;
void *map_base_d;
int *virt_addr;
if((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) FATAL;
map_base_d = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, base);
//now *map_base_d corresponds to the physical address of 0x56000000
virt_addr = map_base_d + (control - base);
*virt_addr = 0x00; //Make sure virt_addr is a pointer of the right width (int*, char*, etc), so that you don't accidentally write a dword when you really only want to write a single word.