mf624_SIMULINK.c

   1 /*
   2  * Application using MF624 UIO driver
   3  *
   4  * Copyright (C) 2011 Rostislav Lisovy <lisovy@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <stdio.h>
  22 #include <errno.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <dirent.h>
  28 #include <sys/types.h>
  29 #include <sys/mman.h>
  30 #include <stdint.h> // uintX_t
  31 #include <inttypes.h>
  32 #include <unistd.h>
  33 #include <alloca.h>
  34 #include <stdlib.h>
  35
  36 #include "mf624_SIMULINK.h"
  37
  38 /****************************************************************/
  39
  40
  41 /* Which uio device node to use */
  42 #define UIO "uio0"
  43
  44 mf624_state_t* mfst=NULL;
  45 unsigned mfst_refcnt = 0;
  46
  47 static int bar_mapping_fill(bar_mapping_t *barmap, const char *uio_dev, int map_nr)
  48 {
  49         FILE *file;
  50         void *s;
  51         int ssiz;
  52         static size_t page_size;
  53
  54         page_size = sysconf(_SC_PAGESIZE);
  55
  56         ssiz = snprintf(NULL, 0, "/sys/class/uio/%s/maps/map%i/", uio_dev, map_nr);
  57         if (ssiz < 0)
  58                 return -1;
  59         /* add reserve to store each size addr, name, offset, size */
  60         ssiz += 6 + 1;
  61         s = alloca(ssiz);
  62
  63         snprintf(s, ssiz, "/sys/class/uio/%s/maps/map%i/addr", uio_dev, map_nr);
  64         file = fopen(s, "rb");
  65         if (file == NULL)
  66           return -1;
  67         fscanf(file, "%"SCNiPTR, &barmap->phys_addr);
  68         fclose(file);
  69
  70         snprintf(s, ssiz, "/sys/class/uio/%s/maps/map%i/offset", uio_dev, map_nr);
  71         file = fopen(s, "rb");
  72         if (file == NULL) {
  73                 barmap->offset = barmap->phys_addr & (page_size - 1);
  74         } else {
  75                 fscanf(file, "%"SCNi32, &barmap->offset);
  76                 fclose(file);
  77         }
  78
  79         snprintf(s, ssiz, "/sys/class/uio/%s/maps/map%i/size", uio_dev, map_nr);
  80         file = fopen(s, "rb");
  81         if (file == NULL)
  82           return -1;
  83         fscanf(file, "%"SCNi32, &barmap->size);
  84         fclose(file);
  85
  86         barmap->mmap_offset = page_size * map_nr + barmap->offset;
  87
  88         return 0;
  89 }
  90
  91 static int bar_mapping_setup(bar_mapping_t *barmap, int device_fd)
  92 {
  93         static size_t page_mask = 0;
  94         off_t mmap_start;
  95         size_t mmap_size;
  96
  97         if (!page_mask)
  98                  page_mask = sysconf(_SC_PAGESIZE) - 1;
  99
 100         mmap_start = barmap->mmap_offset & ~page_mask;
 101         mmap_size = barmap->mmap_offset + barmap->size + page_mask - mmap_start;
 102         mmap_size &= ~page_mask;
 103
 104         barmap->mmap_addr = mmap(0, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, device_fd, mmap_start);
 105         if (barmap->mmap_addr == MAP_FAILED) {
 106                 return -1;
 107         }
 108
 109         barmap->virt_addr = (uintptr_t)barmap->mmap_addr;
 110         barmap->virt_addr += barmap->mmap_offset & page_mask;
 111
 112         return 0;
 113 }
 114
 115 static int bar_mapping_destroy(bar_mapping_t *barmap)
 116 {
 117         off_t mmap_start;
 118         size_t mmap_size;
 119         size_t page_mask = sysconf(_SC_PAGESIZE) - 1;
 120
 121         mmap_start = barmap->mmap_offset & ~page_mask;
 122         mmap_size = barmap->mmap_offset + barmap->size + page_mask - mmap_start;
 123         mmap_size &= ~page_mask;
 124
 125         return munmap(barmap->mmap_addr, mmap_size);
 126 }
 127
 128 /****************************************************************/
 129
 130 #define BUFF_SMALL              32
 131 #define BUFF_MID                256
 132 #define min(a, b)               ((a) > (b) ? (b) : (a))
 133
 134
 135
 136
 137
 138 mf624_state_t mf624_state;
 139
 140 /* Print one byte as binary number */
 141 static void print_8bin(int nr)
 142 {
 143         int i;
 144         for (i = 7; i >= 0; i--) {
 145                 printf("%d" , ((nr & (1 << i)) > 0));
 146         }
 147
 148         printf("\n");
 149 }
 150
 151
 152
 153 void DIO_write(mf624_state_t* mfst, int16_t val)
 154 {
 155         mf624_write16(val, MFST2REG(mfst, 2, DOUT_reg));
 156 }
 157
 158 uint16_t DIO_read(mf624_state_t* mfst)
 159 {
 160         return mf624_read16(MFST2REG(mfst, 2, DIN_reg)) & 0xFF;
 161 }
 162
 163 void DAC_enable(mf624_state_t* mfst)
 164 {
 165         // Setting DACEN and LDAC bits in GPIO register influences all DACs
 166         mf624_write32((mf624_read32(MFST2REG(mfst, 0, GPIOC_reg))
 167                 | GPIOC_DACEN_mask) // enable output
 168                 & ~GPIOC_LDAC_mask, // enable conversion
 169                 MFST2REG(mfst, 0, GPIOC_reg));
 170 }
 171
 172
 173
 174 int DAC_write(mf624_state_t* mfst, dac_channel_t channel, int val)
 175 {
 176         if (channel > sizeof(dac_channel2reg)/sizeof(*dac_channel2reg))
 177                 return -1;
 178
 179         mf624_write16(val, MFST2REG(mfst, 2, dac_channel2reg[channel]));
 180         return 0;
 181 }
 182
 183 int ADC_enable(mf624_state_t* mfst, adc_channel_t channel)
 184 {
 185         mfst->ADC_enabled = 0;
 186
 187         if (channel > sizeof(adc_channel2reg)/sizeof(*adc_channel2reg))
 188                 return -1;
 189
 190         mfst->ADC_enabled = (1 << channel);
 191
 192         mfst->ADC_enabled &= 0xFF;
 193         mf624_write16(mfst->ADC_enabled, MFST2REG(mfst, 2, ADCTRL_reg));
 194         //print_8bin(ADC_enabled);
 195
 196         return 0;
 197 }
 198
 199 /* This function blocks until conversion is finished */
 200 double ADC_read(mf624_state_t* mfst, adc_channel_t channel)
 201 {
 202         volatile int i;
 203         int result;
 204
 205         // Activate trigger to start conversion
 206         mf624_read16(MFST2REG(mfst, 2, ADSTART_reg));
 207
 208         // Check if conversion has finished
 209         while((mf624_read32(MFST2REG(mfst, 0, GPIOC_reg)) & GPIOC_EOLC_mask)) {
 210                 for (i = 0; i < 1000; i++) {} // small wait
 211         }
 212
 213         ADC_enable(mfst, channel);
 214         result = mf624_read16(MFST2REG(mfst, 2, ADDATA0_reg));
 215
 216         return 10.0 * ((int16_t) (result << 2)) / (double) 0x8000;
 217 }
 218
 219
 220 static int open_device(char* path) {
 221         int device_fd;
 222
 223         device_fd = open(path, O_RDWR | O_SYNC);
 224         if (device_fd == -1) {
 225                 perror(path);
 226                 return -1;
 227         }
 228
 229         return device_fd;
 230 }
 231
 232 static void wait_for_interrupts(int device_fd)
 233 {
 234         read(device_fd, NULL, 1);
 235 }
 236
 237 static int disable_interrupts(int device_fd)
 238 {
 239         uint32_t control_value = 0;
 240         int status;
 241
 242         status = write(device_fd, &control_value, sizeof(uint32_t));
 243         if (status == -1) {
 244                 perror("write()");
 245                 return -1;
 246         }
 247
 248         return status;
 249 }
 250
 251 static int enable_interrupts(int device_fd)
 252 {
 253         uint32_t control_value = 1;
 254         int status;
 255
 256         status = write(device_fd, &control_value, sizeof(uint32_t));
 257         if (status == -1) {
 258                 perror("write()");
 259                 return -1;
 260         }
 261
 262         return status;
 263 }
 264
 265 static void list_available_mem_regions(char* device)
 266 {
 267         int status;
 268         char path[] = "/sys/class/uio/";
 269         char subdir[] = "/maps/";
 270         char directory[BUFF_MID];
 271         memset(directory, '\0', BUFF_MID);
 272
 273         DIR *dip;
 274         struct dirent *dit;
 275
 276         strncat(directory, path, strlen(path));
 277         strncat(directory, device, min(strlen(device), 8));
 278         strncat(directory, subdir, strlen(subdir));
 279
 280         dip = opendir(directory);
 281         if (dip == NULL) {
 282                 perror("opendir");
 283                 return;
 284         }
 285
 286         while ((dit = readdir(dip)) != NULL) {
 287                 if (strcmp(dit->d_name, ".") && strcmp(dit->d_name, "..")) {
 288                         printf(" %s\n", dit->d_name);
 289                 }
 290         }
 291
 292         status = closedir(dip);
 293         if (status == -1) {
 294                 perror("closedir()");
 295                 return;
 296         }
 297
 298 }
 299
 300
 301 static void list_available_io_ports(char *device)
 302 {
 303         int status;
 304         char path[] = "/sys/class/uio/";
 305         char subdir[] = "/portio/";
 306         char directory[BUFF_MID];
 307         memset(directory, '\0', BUFF_MID);
 308
 309         DIR *dip;
 310         struct dirent *dit;
 311
 312         strncat(directory, path, strlen(path));
 313         strncat(directory, device, min(strlen(device), 8));
 314         strncat(directory, subdir, strlen(subdir));
 315
 316         status = access(directory, F_OK);
 317         if (status == -1) {
 318                 printf(" There are no IO port available\n");
 319                 return;
 320         }
 321
 322         dip = opendir(directory);
 323         if (dip == NULL) {
 324                 perror("opendir");
 325                 return;
 326         }
 327
 328         while ((dit = readdir(dip)) != NULL) {
 329                 if (strcmp(dit->d_name, ".") && strcmp(dit->d_name, "..")) {
 330                         printf(" %s\n", dit->d_name);
 331                 }
 332         }
 333
 334         status = closedir(dip);
 335         if (status == -1) {
 336                 perror("closedir()");
 337                 return;
 338         }
 339
 340 }
 341
 342
 343 static void run_simple_tests(char* dev_name)
 344 {
 345         int status;
 346         int device_fd;
 347         char buff[BUFF_SMALL];
 348         memset(buff, '\0', BUFF_SMALL);
 349
 350         strncat(buff, "/dev/", 5);
 351         strncat(buff, dev_name, min(strlen(dev_name), 8));
 352
 353         printf("Opening %s\n", buff);
 354
 355         device_fd = open_device(buff);
 356         if (device_fd != -1) {
 357                 printf("Tring to enable interrupts\n");
 358                 status = enable_interrupts(device_fd);
 359                 if (status != -1) {
 360                         printf(" Probably OK\n");
 361                 }
 362
 363                 printf("Tring to disable interrupts\n");
 364                 status = disable_interrupts(device_fd);
 365                 if (status != -1) {
 366                         printf(" Probably OK\n");
 367                 }
 368         }
 369
 370
 371         printf("Checking for available memory regions exported by the UIO driver\n");
 372         list_available_mem_regions(dev_name);
 373
 374         printf("Checking for available IO ports exported by the UIO driver\n");
 375         list_available_io_ports(dev_name);
 376 }
 377
 378 static int mmap_regions(mf624_state_t* mfst)
 379 {
 380         if (bar_mapping_fill(&mfst->bar0, mfst->uio_dev, 0) < 0) {
 381                 fprintf(stderr, "%s bar0 mapping fill failed\n", mfst->uio_dev);
 382                 return -1;
 383         }
 384
 385         if (bar_mapping_fill(&mfst->bar2, mfst->uio_dev, 1) < 0) {
 386                 fprintf(stderr, "%s bar2 mapping fill failed\n", mfst->uio_dev);
 387                 return -1;
 388         }
 389
 390         if (bar_mapping_fill(&mfst->bar4, mfst->uio_dev, 2) < 0) {
 391                 fprintf(stderr, "%s bar4 mapping fill failed\n", mfst->uio_dev);
 392                 return -1;
 393         }
 394
 395         if (bar_mapping_setup(&mfst->bar0, mfst->device_fd) < 0) {
 396                 fprintf(stderr, "%s bar0 mapping setup failed\n", mfst->uio_dev);
 397                 return -1;
 398         }
 399
 400         if (bar_mapping_setup(&mfst->bar2, mfst->device_fd) < 0) {
 401                 fprintf(stderr, "%s bar2 mapping setup failed\n", mfst->uio_dev);
 402                 return -1;
 403         }
 404
 405         if (bar_mapping_setup(&mfst->bar4, mfst->device_fd) < 0) {
 406                 fprintf(stderr, "%s bar4 mapping setup failed\n", mfst->uio_dev);
 407                 return -1;
 408         }
 409
 410 #if 1
 411         printf("bar0.phys_addr = %"PRIxPTR"\n", mfst->bar0.phys_addr);
 412         printf("bar2.phys_addr = %"PRIxPTR"\n", mfst->bar2.phys_addr);
 413         printf("bar4.phys_addr = %"PRIxPTR"\n", mfst->bar4.phys_addr);
 414
 415         printf("bar0.virt_addr = %"PRIxPTR"\n", mfst->bar0.virt_addr);
 416         printf("bar2.virt_addr = %"PRIxPTR"\n", mfst->bar2.virt_addr);
 417         printf("bar4.virt_addr = %"PRIxPTR"\n", mfst->bar4.virt_addr);
 418 #endif
 419
 420         return 0;
 421 }
 422
 423
 424
 425 /**
 426  * Try to initialize the MF624 UIO driver.
 427  *
 428  * If and only if S is not NULL and initialization fails, then
 429  * ssSetErrorStatus() gets called to report the error via Simulink
 430  * interface.
 431  *
 432  * @param S Pointer to SimStruct for error reporting or NULL.
 433  *
 434  * @return Zero in case of success, -1 in case of error.
 435  */
 436 int mf624_init(SimStruct *S)
 437 {
 438         if (mfst==NULL) {
 439                 mfst = malloc(sizeof(mf624_state_t));
 440                 char fn[32];
 441                 mfst->uio_dev = UIO;
 442                 snprintf(fn, sizeof(fn), "/dev/%s", mfst->uio_dev);
 443
 444                 mfst->device_fd = open_device(fn);
 445                 if (mfst->device_fd < 0) {
 446                         if (S) ssSetErrorStatus(S,"/dev/" UIO ": open failed");
 447                         goto free;
 448                 }
 449                 if (mmap_regions(mfst) < 0) {
 450                         if (S) ssSetErrorStatus(S,"/dev/" UIO ": mmap_regions failed");
 451                         goto close;
 452                 }
 453         }
 454         mfst_refcnt++;
 455         return 0;
 456 close:
 457         close(mfst->device_fd);
 458 free:
 459         free(mfst);
 460         mfst = NULL;
 461         return -1;
 462 }
 463
 464 int mf624_done()
 465 {
 466         if (mfst) {
 467                 if (--mfst_refcnt == 0) {
 468                         close(mfst->device_fd);
 469                         bar_mapping_destroy(&mfst->bar0);
 470                         bar_mapping_destroy(&mfst->bar2);
 471                         bar_mapping_destroy(&mfst->bar4);
 472                         free(mfst);
 473                         mfst = NULL;
 474                 }
 475         }
 476
 477         return 0;
 478 }
 479
 480
 481 /**
 482  * Check whether MF624 card is initialized.
 483  *
 484  * @param S
 485  *
 486  * @return Zero if MF624 is initialized, -1 othewise.
 487  */
 488 int mf624_check(SimStruct *S)
 489 {
 490         if (mfst==NULL) {
 491                 if (S) ssSetErrorStatus(S, "MF624 is not initialized");
 492                 return -1;
 493         }
 494         else
 495                 return 0;
 496 }
 497
 498 /*int main(int argc, char* argv[])
 499 {
 500         mf624_state_t* mfst = &mf624_state;
 501         char buff[BUFF_SMALL];
 502         memset(buff, '\0', BUFF_SMALL);
 503
 504         if (argc < 2) {
 505                 printf("Usage: %s UIO_DEVICE\n   UIO_DEVICE\tname of uio device in /dev\n", argv[0]);
 506                 return 1;
 507         }
 508
 509         mfst->uio_dev = argv[1];
 510
 511         strncat(buff, "/dev/", 5);
 512         strncat(buff, mfst->uio_dev, sizeof(buff) - 6);
 513
 514         mfst->device_fd = open_device(buff);
 515         if (mfst->device_fd < 0) {
 516                 fprintf(stderr, "%s open failed (%s)!\n", mfst->uio_dev, strerror(errno));
 517                 return 2;
 518         }
 519         if (mmap_regions(mfst) < 0) {
 520                 fprintf(stderr, "%s mmap_regions failed (%s)!\n", mfst->uio_dev, strerror(errno));
 521                 return 2;
 522         }
 523
 524         DAC_enable(mfst);
 525
 526         while (1){
 527                 printf("Reading DIO: ");
 528                 print_8bin(DIO_read(mfst));
 529                 sleep(1);
 530
 531                 printf("Setting DA1 to 10 V\n");
 532                 DAC_write(mfst, DA1, 0x3FFF);
 533                 sleep(1);
 534
 535                 printf("Reading ADC0: ");
 536                 printf("%f V\n", ADC_read(mfst, AD0));
 537                 sleep(1);
 538
 539                 printf("Reading ADC1: ");
 540                 printf("%f V\n", ADC_read(mfst, AD1));
 541                 sleep(1);
 542
 543                 printf("Setting DIO to 0xff\n");
 544                 DIO_write(mfst, 0xff);
 545                 sleep(1);
 546
 547                 printf("Setting DIO to 0x00\n");
 548                 DIO_write(mfst, 0x00);
 549                 sleep(1);
 550
 551                 printf("Setting DA1 to 5 V\n");
 552                 DAC_write(mfst, DA1, 0x3000);
 553                 sleep(1);
 554
 555                 printf("Reading ADC0: ");
 556                 printf("%f V\n", ADC_read(mfst, AD0));
 557                 sleep(1);
 558
 559                 printf("Reading ADC1: ");
 560                 printf("%f V\n", ADC_read(mfst, AD1));
 561                 sleep(1);
 562                 printf("----------------------\n\n");
 563         }
 564
 565
 566         return 0;
 567 }*/