src/mraa.c

   1 /*
   2  * Author: Brendan Le Foll <brendan.le.foll@intel.com>
   3  * Author: Thomas Ingleby <thomas.c.ingleby@intel.com>
   4  * Copyright (c) 2014 Intel Corporation.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be
  15  * included in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include <stddef.h>
  27 #include <stdlib.h>
  28 #include <sched.h>
  29 #include <string.h>
  30
  31 #include "mraa_internal.h"
  32 #include "intel_galileo_rev_d.h"
  33 #include "intel_galileo_rev_g.h"
  34 #include "intel_edison_fab_c.h"
  35 #include "intel_de3815.h"
  36 #include "gpio.h"
  37 #include "version.h"
  38
  39 mraa_board_t* plat = NULL;
  40 static mraa_platform_t platform_type = MRAA_UNKNOWN_PLATFORM;
  41 mraa_adv_func_t* advance_func;
  42
  43 const char *
  44 mraa_get_version()
  45 {
  46     return gVERSION;
  47 }
  48
  49 mraa_result_t
  50 mraa_set_log_level(int level)
  51 {
  52     if (level <= 7 && level >= 0) {
  53         setlogmask(LOG_UPTO(level));
  54         return MRAA_SUCCESS;
  55     }
  56     return MRAA_ERROR_INVALID_PARAMETER;
  57 }
  58
  59 mraa_result_t __attribute__((constructor))
  60 mraa_init()
  61 {
  62 #ifdef DEBUG
  63     setlogmask(LOG_UPTO(LOG_DEBUG));
  64 #else
  65     setlogmask(LOG_UPTO(LOG_NOTICE));
  66 #endif
  67
  68     openlog("libmraa", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1);
  69     syslog(LOG_DEBUG, "libmraa initialised by user %d", getuid());
  70
  71     if (plat != NULL) {
  72         return MRAA_ERROR_PLATFORM_ALREADY_INITIALISED;
  73     }
  74 #ifdef SWIGPYTHON
  75     // Initialise python threads, this allows use to grab the GIL when we are
  76     // required to do so
  77     Py_InitializeEx(0);
  78     PyEval_InitThreads();
  79 #endif
  80     // detect a galileo gen2 board
  81     char *line = NULL;
  82     // let getline allocate memory for *line
  83     size_t len = 0;
  84     FILE *fh = fopen("/sys/devices/virtual/dmi/id/board_name", "r");
  85     if (fh != NULL) {
  86         if (getline(&line, &len, fh) != -1) {
  87             if (strncmp(line, "GalileoGen2", 10) == 0) {
  88                 platform_type = MRAA_INTEL_GALILEO_GEN2;
  89             } else if (strncmp(line, "BODEGA BAY", 10) == 0) {
  90                 platform_type = MRAA_INTEL_EDISON_FAB_C;
  91             } else if (strncmp(line, "SALT BAY", 7) == 0) {
  92                 platform_type = MRAA_INTEL_EDISON_FAB_C;
  93             } else if (strncmp(line, "DE3815", 6) == 0) {
  94                 platform_type = MRAA_INTEL_DE3815;
  95             } else {
  96                 platform_type = MRAA_INTEL_GALILEO_GEN1;
  97             }
  98             free(line);
  99         }
 100         fclose(fh);
 101     }
 102
 103     advance_func = (mraa_adv_func_t*) malloc(sizeof(mraa_adv_func_t));
 104     memset(advance_func, 0, sizeof(mraa_adv_func_t));
 105
 106     switch(platform_type) {
 107         case MRAA_INTEL_GALILEO_GEN2:
 108             plat = mraa_intel_galileo_gen2();
 109             break;
 110         case MRAA_INTEL_GALILEO_GEN1:
 111             plat = mraa_intel_galileo_rev_d();
 112             break;
 113         case MRAA_INTEL_EDISON_FAB_C:
 114             plat = mraa_intel_edison_fab_c();
 115             break;
 116         case MRAA_INTEL_DE3815:
 117             plat = mraa_intel_de3815();
 118             break;
 119         default:
 120             plat = mraa_intel_galileo_rev_d();
 121             syslog(LOG_ERR, "Platform not found, initialising MRAA_INTEL_GALILEO_GEN1");
 122     }
 123
 124     syslog(LOG_NOTICE, "libmraa initialised for platform %d", platform_type);
 125     return MRAA_SUCCESS;
 126 }
 127
 128 void
 129 mraa_deinit()
 130 {
 131     free(plat->pins);
 132     free(plat);
 133     closelog();
 134 }
 135
 136 int
 137 mraa_set_priority(const unsigned int priority)
 138 {
 139     struct sched_param sched_s;
 140
 141     memset(&sched_s, 0, sizeof(struct sched_param));
 142     if (priority > sched_get_priority_max(SCHED_RR)) {
 143         sched_s.sched_priority = sched_get_priority_max(SCHED_RR);
 144     }
 145     else {
 146         sched_s.sched_priority = priority;
 147     }
 148
 149     return sched_setscheduler(0, SCHED_RR, &sched_s);
 150 }
 151
 152 static mraa_result_t
 153 mraa_setup_mux_mapped(mraa_pin_t meta)
 154 {
 155     int mi;
 156     for (mi = 0; mi < meta.mux_total; mi++) {
 157         mraa_gpio_context mux_i;
 158         mux_i = mraa_gpio_init_raw(meta.mux[mi].pin);
 159         if (mux_i == NULL)
 160             return MRAA_ERROR_INVALID_HANDLE;
 161         mraa_gpio_dir(mux_i, MRAA_GPIO_OUT);
 162         if (mraa_gpio_write(mux_i, meta.mux[mi].value) != MRAA_SUCCESS)
 163             return MRAA_ERROR_INVALID_RESOURCE;
 164     }
 165     return MRAA_SUCCESS;
 166 }
 167
 168 unsigned int
 169 mraa_setup_gpio(int pin)
 170 {
 171     if (plat == NULL)
 172         return MRAA_PLATFORM_NO_INIT;
 173
 174     if (pin < 0 || pin > plat->phy_pin_count)
 175         return MRAA_NO_SUCH_IO;
 176
 177     if(plat->pins[pin].capabilites.gpio != 1)
 178       return MRAA_NO_SUCH_IO;
 179
 180     if (plat->pins[pin].gpio.mux_total > 0)
 181        if (mraa_setup_mux_mapped(plat->pins[pin].gpio) != MRAA_SUCCESS)
 182             return MRAA_NO_SUCH_IO;
 183     return plat->pins[pin].gpio.pinmap;
 184 }
 185
 186 unsigned int
 187 mraa_setup_aio(int aio)
 188 {
 189     if (plat == NULL)
 190         return MRAA_PLATFORM_NO_INIT;
 191
 192     if (aio < 0 || aio > plat->aio_count)
 193         return MRAA_NO_SUCH_IO;
 194
 195     int pin = aio + plat->gpio_count;
 196
 197     if (plat->pins[pin].capabilites.aio != 1)
 198       return MRAA_NO_SUCH_IO;
 199
 200     if (plat->pins[pin].aio.mux_total > 0)
 201        if (mraa_setup_mux_mapped(plat->pins[pin].aio) != MRAA_SUCCESS)
 202             return MRAA_NO_SUCH_IO;
 203     return plat->pins[pin].aio.pinmap;
 204 }
 205
 206 unsigned int
 207 mraa_setup_i2c(int* bus)
 208 {
 209     if (plat == NULL)
 210         return MRAA_PLATFORM_NO_INIT;
 211
 212     if (plat->i2c_bus_count == 0) {
 213         syslog(LOG_ERR, "No i2c buses defined in platform");
 214         return MRAA_NO_SUCH_IO;
 215     }
 216     if (*bus >= plat->i2c_bus_count) {
 217         syslog(LOG_ERR, "Above i2c bus count");
 218         return MRAA_NO_SUCH_IO;
 219     }
 220
 221     if (plat->i2c_bus[*bus].bus_id == -1) {
 222         syslog(LOG_ERR, "Invalid i2c bus, moving to default i2c bus");
 223         *bus = plat->def_i2c_bus;
 224     }
 225
 226     int pos = plat->i2c_bus[*bus].sda;
 227     if (plat->pins[pos].i2c.mux_total > 0)
 228         if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS)
 229              return MRAA_IO_SETUP_FAILURE;
 230
 231     pos = plat->i2c_bus[*bus].scl;
 232     if (plat->pins[pos].i2c.mux_total > 0)
 233         if (mraa_setup_mux_mapped(plat->pins[pos].i2c) != MRAA_SUCCESS)
 234              return MRAA_IO_SETUP_FAILURE;
 235
 236     return plat->i2c_bus[*bus].bus_id;
 237 }
 238
 239 mraa_spi_bus_t*
 240 mraa_setup_spi(int bus)
 241 {
 242     if (plat == NULL)
 243         return NULL;
 244
 245     if (plat->spi_bus_count >! 0) {
 246         syslog(LOG_ERR, "No spi buses defined in platform");
 247         return NULL;
 248     }
 249     if (plat->spi_bus_count == 1) {
 250         bus = plat->def_spi_bus;
 251     }
 252     if (bus >= plat->spi_bus_count) {
 253         syslog(LOG_ERR, "Above spi bus count");
 254         return NULL;
 255     }
 256
 257     int pos = plat->spi_bus[bus].sclk;
 258     if (plat->pins[pos].spi.mux_total > 0)
 259         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS)
 260              return NULL;
 261
 262     pos = plat->spi_bus[bus].mosi;
 263     if (plat->pins[pos].spi.mux_total > 0)
 264         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS)
 265              return NULL;
 266
 267     pos = plat->spi_bus[bus].miso;
 268     if (plat->pins[pos].spi.mux_total > 0)
 269         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS)
 270              return NULL;
 271
 272     pos = plat->spi_bus[bus].cs;
 273     if (plat->pins[pos].spi.mux_total > 0)
 274         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS)
 275              return NULL;
 276
 277     pos = plat->spi_bus[bus].cs;
 278     if (plat->pins[pos].spi.mux_total > 0)
 279         if (mraa_setup_mux_mapped(plat->pins[pos].spi) != MRAA_SUCCESS)
 280              return NULL;
 281
 282     mraa_spi_bus_t *spi = &(plat->spi_bus[bus]);
 283     return spi;
 284 }
 285
 286 mraa_pin_t*
 287 mraa_setup_pwm(int pin)
 288 {
 289     if (plat == NULL)
 290         return NULL;
 291
 292     if (plat->pins[pin].capabilites.pwm != 1)
 293         return NULL;
 294
 295     if (plat->pins[pin].capabilites.gpio == 1) {
 296         mraa_gpio_context mux_i;
 297         mux_i = mraa_gpio_init_raw(plat->pins[pin].gpio.pinmap);
 298         if (mux_i == NULL)
 299             return NULL;
 300         if (mraa_gpio_dir(mux_i, MRAA_GPIO_OUT) != MRAA_SUCCESS)
 301             return NULL;
 302         // Current REV D quirk. //TODO GEN 2
 303         if (mraa_gpio_write(mux_i, 1) != MRAA_SUCCESS)
 304             return NULL;
 305         if (mraa_gpio_close(mux_i) != MRAA_SUCCESS)
 306             return NULL;
 307     }
 308
 309     if (plat->pins[pin].pwm.mux_total > 0)
 310        if (mraa_setup_mux_mapped(plat->pins[pin].pwm) != MRAA_SUCCESS)
 311             return NULL;
 312
 313     mraa_pin_t *ret;
 314     ret = (mraa_pin_t*) malloc(sizeof(mraa_pin_t));
 315     ret->pinmap = plat->pins[pin].pwm.pinmap;
 316     ret->parent_id = plat->pins[pin].pwm.parent_id;
 317     return ret;
 318 }
 319
 320 void
 321 mraa_result_print(mraa_result_t result)
 322 {
 323     switch (result) {
 324         case MRAA_SUCCESS:
 325             fprintf(stdout, "MRAA: SUCCESS\n");
 326             break;
 327         case MRAA_ERROR_FEATURE_NOT_IMPLEMENTED:
 328             fprintf(stdout, "MRAA: Feature not implemented.\n");
 329             break;
 330         case MRAA_ERROR_FEATURE_NOT_SUPPORTED:
 331             fprintf(stdout, "MRAA: Feature not supported by Hardware.\n");
 332             break;
 333         case MRAA_ERROR_INVALID_VERBOSITY_LEVEL:
 334             fprintf(stdout, "MRAA: Invalid verbosity level.\n");
 335             break;
 336         case MRAA_ERROR_INVALID_PARAMETER:
 337             fprintf(stdout, "MRAA: Invalid parameter.\n");
 338             break;
 339         case MRAA_ERROR_INVALID_HANDLE:
 340             fprintf(stdout, "MRAA: Invalid Handle.\n");
 341             break;
 342         case MRAA_ERROR_NO_RESOURCES:
 343             fprintf(stdout, "MRAA: No resources.\n");
 344             break;
 345         case MRAA_ERROR_INVALID_RESOURCE:
 346             fprintf(stdout, "MRAA: Invalid resource.\n");
 347             break;
 348         case MRAA_ERROR_INVALID_QUEUE_TYPE:
 349             fprintf(stdout, "MRAA: Invalid Queue Type.\n");
 350             break;
 351         case MRAA_ERROR_NO_DATA_AVAILABLE:
 352             fprintf(stdout, "MRAA: No Data available.\n");
 353             break;
 354         case MRAA_ERROR_INVALID_PLATFORM:
 355             fprintf(stdout, "MRAA: Platform not recognised.\n");
 356             break;
 357         case MRAA_ERROR_PLATFORM_NOT_INITIALISED:
 358             fprintf(stdout, "MRAA: Platform not initialised.\n");
 359             break;
 360         case MRAA_ERROR_PLATFORM_ALREADY_INITIALISED:
 361             fprintf(stdout, "MRAA: Platform already initialised.\n");
 362             break;
 363         case MRAA_ERROR_UNSPECIFIED:
 364             fprintf(stdout, "MRAA: Unspecified Error.\n");
 365             break;
 366         default:
 367             fprintf(stdout, "MRAA: Unrecognised error.\n");
 368             break;
 369     }
 370 }
 371
 372 mraa_boolean_t
 373 mraa_pin_mode_test(int pin, mraa_pinmodes_t mode)
 374 {
 375     if (plat == NULL) {
 376         mraa_init();
 377         if (plat == NULL)
 378             return 0;
 379     }
 380     if (pin > plat->phy_pin_count || pin < 0)
 381         return 0;
 382
 383     switch(mode) {
 384         case MRAA_PIN_VALID:
 385             if (plat->pins[pin].capabilites.valid == 1)
 386                 return 1;
 387             break;
 388         case MRAA_PIN_GPIO:
 389             if (plat->pins[pin].capabilites.gpio ==1)
 390                 return 1;
 391             break;
 392         case MRAA_PIN_PWM:
 393             if (plat->pins[pin].capabilites.pwm ==1)
 394                 return 1;
 395             break;
 396         case MRAA_PIN_FAST_GPIO:
 397             if (plat->pins[pin].capabilites.fast_gpio ==1)
 398                 return 1;
 399             break;
 400         case MRAA_PIN_SPI:
 401             if (plat->pins[pin].capabilites.spi ==1)
 402                 return 1;
 403             break;
 404         case MRAA_PIN_I2C:
 405             if (plat->pins[pin].capabilites.i2c ==1)
 406                 return 1;
 407             break;
 408         case MRAA_PIN_AIO:
 409             if (pin < plat->aio_count)
 410                 pin = pin + plat->gpio_count;
 411             if (plat->pins[pin].capabilites.aio ==1)
 412                 return 1;
 413             break;
 414         default: break;
 415     }
 416     return 0;
 417 }
 418
 419 mraa_mmap_pin_t*
 420 mraa_setup_mmap_gpio(int pin)
 421 {
 422     if (plat == NULL)
 423         return NULL;
 424
 425     if (plat->pins[pin].capabilites.fast_gpio != 1)
 426         return NULL;
 427
 428     if (plat->pins[pin].mmap.gpio.mux_total > 0)
 429        if (mraa_setup_mux_mapped(plat->pins[pin].mmap.gpio) != MRAA_SUCCESS)
 430             return NULL;
 431
 432     if (mraa_setup_mux_mapped(plat->pins[pin].mmap.gpio) != MRAA_SUCCESS)
 433             return NULL;
 434     mraa_mmap_pin_t *ret = &(plat->pins[pin].mmap);
 435     return ret;
 436 }
 437
 438 mraa_platform_t mraa_get_platform_type()
 439 {
 440     return platform_type;
 441 }
 442
 443 unsigned int
 444 mraa_adc_raw_bits()
 445 {
 446     if (plat == NULL)
 447         return 0;
 448
 449     if (plat->aio_count == 0)
 450         return 0;
 451
 452     return plat->adc_raw;
 453 }
 454
 455 unsigned int
 456 mraa_adc_supported_bits()
 457 {
 458     if (plat == NULL)
 459         return 0;
 460
 461     if (plat->aio_count == 0)
 462         return 0;
 463
 464     return plat->adc_supported;
 465 }
 466
 467 mraa_result_t
 468 mraa_setup_uart(int index)
 469 {
 470     if (plat == NULL)
 471         return MRAA_ERROR_PLATFORM_NOT_INITIALISED;
 472
 473     if (plat->uart_dev_count == 0)
 474         return MRAA_ERROR_FEATURE_NOT_SUPPORTED;
 475
 476     if (plat->uart_dev_count <= index)
 477         return MRAA_ERROR_NO_RESOURCES;
 478
 479     int pos = plat->uart_dev[index].rx;
 480     if (pos >= 0) {
 481         if (plat->pins[pos].uart.mux_total > 0)
 482             if (mraa_setup_mux_mapped(plat->pins[pos].uart) != MRAA_SUCCESS)
 483                 return MRAA_ERROR_INVALID_RESOURCE;
 484     }
 485
 486     if (pos >= 0) {
 487         pos = plat->uart_dev[index].tx;
 488         if (plat->pins[pos].uart.mux_total > 0)
 489             if (mraa_setup_mux_mapped(plat->pins[pos].uart) != MRAA_SUCCESS)
 490                 return MRAA_ERROR_INVALID_RESOURCE;
 491     }
 492
 493     return MRAA_SUCCESS;
 494 }