src/uio/userspace/test_application/main.c

   1 #include <stdio.h>
   2 #include <errno.h>
   3 #include <sys/stat.h>
   4 #include <fcntl.h>
   5 #include <unistd.h>
   6 #include <string.h>
   7 #include <dirent.h>
   8 #include <sys/types.h>
   9 #include <sys/mman.h>
  10 #include <stdint.h> // uintX_t
  11 #include <unistd.h>
  12
  13 /* Hardware specific */
  14 #define AD_LO           0x0
  15 #define AD_HI           0x1
  16 #define AD_CTRL         0x0
  17
  18
  19 #define BUFF_SMALL      32
  20 #define BUFF_MID        256
  21 #define min(a, b)       ((a) > (b) ? (b) : (a))
  22
  23
  24 int status;
  25 void* mf614_mem = NULL;
  26
  27 void delay()
  28 {
  29         for (int i = 0; i < 65000; i++) {}
  30 }
  31
  32 void mf614_adc_init(int channel)
  33 {
  34         *(((uint8_t *) mf614_mem) + AD_CTRL) = 1 << 6 | 0 << 5 | 0 << 4 /* RNG */| 0 << 3 /*BIP*/| channel;
  35 }
  36
  37 int open_device(char* path) {
  38         status = open(path, O_RDWR);
  39         if (status == -1) {
  40                 perror("open()");
  41                 return -1;
  42         }
  43
  44         return status;
  45 }
  46
  47 void wait_for_interrupts(int device_fd)
  48 {
  49         read(device_fd, NULL, 1);
  50 }
  51
  52 int disable_interrupts(int device_fd)
  53 {
  54         char buff[4]; // we have to write 32 bit number
  55         strncpy(buff, "0", 4);
  56
  57         status = write(device_fd, buff, 4);
  58         if (status == -1) {
  59                 perror("write()");
  60                 return -1;
  61         }
  62
  63         return status;
  64 }
  65
  66 int enable_interrupts(int device_fd)
  67 {
  68         char buff[4]; // we have to write 32 bit number
  69         strncpy(buff, "1", 4);
  70
  71         status = write(device_fd, buff, 4);
  72         if (status == -1) {
  73                 perror("write()");
  74                 return -1;
  75         }
  76
  77         return status;
  78 }
  79
  80 void list_available_mem_regions(char* device)
  81 {
  82         char path[] = "/sys/class/uio/";
  83         char subdir[] = "/maps/";
  84         char directory[BUFF_MID];
  85         memset(directory, '\0', BUFF_MID);
  86
  87         DIR *dip;
  88         struct dirent *dit;
  89
  90         strncat(directory, path, strlen(path));
  91         strncat(directory, device, min(strlen(device), 8));
  92         strncat(directory, subdir, strlen(subdir));
  93
  94         dip = opendir(directory);
  95         if (dip == NULL) {
  96                 perror("opendir");
  97                 return;
  98         }
  99
 100         while ((dit = readdir(dip)) != NULL) {
 101                 if (strcmp(dit->d_name, ".") && strcmp(dit->d_name, "..")) {
 102                         printf(" %s\n", dit->d_name);
 103                 }
 104         }
 105
 106         status = closedir(dip);
 107         if (status == -1) {
 108                 perror("closedir()");
 109                 return;
 110         }
 111
 112 }
 113
 114
 115 void list_available_io_ports(char *device)
 116 {
 117         char path[] = "/sys/class/uio/";
 118         char subdir[] = "/portio/";
 119         char directory[BUFF_MID];
 120         memset(directory, '\0', BUFF_MID);
 121
 122         DIR *dip;
 123         struct dirent *dit;
 124
 125         strncat(directory, path, strlen(path));
 126         strncat(directory, device, min(strlen(device), 8));
 127         strncat(directory, subdir, strlen(subdir));
 128
 129         status = access(directory, F_OK);
 130         if (status == -1) {
 131                 printf(" There are no IO port available\n");
 132                 return;
 133         }
 134
 135         dip = opendir(directory);
 136         if (dip == NULL) {
 137                 perror("opendir");
 138                 return;
 139         }
 140
 141         while ((dit = readdir(dip)) != NULL) {
 142                 if (strcmp(dit->d_name, ".") && strcmp(dit->d_name, "..")) {
 143                         printf(" %s\n", dit->d_name);
 144                 }
 145         }
 146
 147         status = closedir(dip);
 148         if (status == -1) {
 149                 perror("closedir()");
 150                 return;
 151         }
 152
 153 }
 154
 155
 156 void run_simple_tests(char* dev_name)
 157 {
 158         int device_fd;
 159         char buff[BUFF_SMALL];
 160         memset(buff, '\0', BUFF_SMALL);
 161
 162         strncat(buff, "/dev/", 5);
 163         strncat(buff, dev_name, min(strlen(dev_name), 8));
 164
 165         printf("Opening %s\n", buff);
 166
 167         device_fd = open_device(buff);
 168         if (device_fd != -1) {
 169                 printf("Tring to enable interrupts\n");
 170                 status = enable_interrupts(device_fd);
 171                 if (status != -1) {
 172                         printf(" Probably OK\n");
 173                 }
 174
 175                 printf("Tring to disable interrupts\n");
 176                 status = disable_interrupts(device_fd);
 177                 if (status != -1) {
 178                         printf(" Probably OK\n");
 179                 }
 180         }
 181
 182
 183         printf("Checking for available memory regions exported by the UIO driver\n");
 184         list_available_mem_regions(dev_name);
 185
 186         printf("Checking for available IO ports exported by the UIO driver\n");
 187         list_available_io_ports(dev_name);
 188 }
 189
 190
 191 int main(int argc, char* argv[])
 192 {
 193         int device_fd;
 194         int mem_size = 1; //TODO
 195         float adc_value;
 196         char buff[BUFF_SMALL];
 197         char read_buff[BUFF_SMALL];
 198         memset(buff, '\0', BUFF_SMALL);
 199
 200
 201         if (argc < 2) {
 202                 printf("Usage: %s UIO_DEVICE\n   UIO_DEVICE\tname of uio device in /dev\n", argv[0]);
 203                 return 1;
 204         }
 205
 206
 207         strncat(buff, "/dev/", 5);
 208         strncat(buff, argv[1], min(strlen(argv[1]), 8));
 209
 210         device_fd = open_device(buff);
 211         if (device_fd != -1) {
 212                 mf614_mem = mmap(0, mem_size * sysconf(_SC_PAGESIZE), PROT_READ | PROT_WRITE, MAP_SHARED, device_fd, 0);
 213                 if (mf614_mem == MAP_FAILED) {
 214                         perror("mmap()");
 215                 }
 216
 217
 218                 while(1) {
 219
 220
 221                         for (int i = 0; i <= 7; i++) {
 222                                 mf614_adc_init(i);
 223                                 //enable_interrupts(device_fd);
 224                                 //read(device_fd, read_buff, 1); // should block until interrupt erceived
 225
 226                                 // ... got interrupt -- handle it
 227                                 //disable_interrupts(device_fd);
 228
 229                                 delay();
 230                                 adc_value = *(((uint8_t *) mf614_mem) + AD_LO) | (*(((uint8_t *) mf614_mem) + AD_HI) << 8);
 231                                 printf("[CH %d] ADC = %f V\n", i, adc_value/819);
 232                         }
 233                         printf("\n");
 234                 }
 235         }
 236
 237
 238         return 0;
 239 }