src/x86/intel_edison_fab_c.c

   1 /*
   2  * Author: Thomas Ingleby <thomas.c.ingleby@intel.com>
   3  * Copyright (c) 2014 Intel Corporation.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <sys/stat.h>
  28 #include <sys/mman.h>
  29
  30 #include "common.h"
  31 #include "x86/intel_edison_fab_c.h"
  32
  33 #define PLATFORM_NAME "Intel Edison"
  34 #define SYSFS_CLASS_GPIO "/sys/class/gpio"
  35 #define SYSFS_PINMODE_PATH "/sys/kernel/debug/gpio_debug/gpio"
  36 #define MAX_SIZE 64
  37 #define MAX_MODE_SIZE 8
  38
  39 // This is an absolute path to a resource file found within sysfs.
  40 // Might not always be correct. First thing to check if mmap stops
  41 // working. Check the device for 0x1199 and Intel Vendor (0x8086)
  42 #define MMAP_PATH "/sys/devices/pci0000:00/0000:00:0c.0/resource0"
  43
  44 typedef struct {
  45     int sysfs;
  46     int mode;
  47 } mraa_intel_edision_pindef_t;
  48
  49 typedef struct {
  50     mraa_intel_edision_pindef_t gpio;
  51     mraa_intel_edision_pindef_t pwm;
  52     mraa_intel_edision_pindef_t i2c;
  53     mraa_intel_edision_pindef_t spi;
  54     mraa_intel_edision_pindef_t uart;
  55 } mraa_intel_edison_pinmodes_t;
  56
  57 static mraa_gpio_context tristate;
  58
  59 static mraa_intel_edison_pinmodes_t pinmodes[MRAA_INTEL_EDISON_PINCOUNT];
  60 static unsigned int outputen[] = {248,249,250,251,252,253,254,255,256,257,258,259,260,261,232,233,234,235,236,237};
  61 static unsigned int pullup_map[] = {216,217,218,219,220,221,222,223,224,225,226,227,228,229,208,209,210,211,212,213};
  62 static int miniboard = 0;
  63
  64 //MMAP
  65 static uint8_t *mmap_reg = NULL;
  66 static int mmap_fd = 0;
  67 static int mmap_size;
  68 static unsigned int mmap_count = 0;
  69
  70 static mraa_result_t
  71 mraa_intel_edison_pinmode_change(int sysfs, int mode)
  72 {
  73     if (mode < 0 ) {
  74         return MRAA_SUCCESS;
  75     }
  76
  77     char buffer[MAX_SIZE];
  78     snprintf(buffer, MAX_SIZE, SYSFS_PINMODE_PATH "%i/current_pinmux",sysfs);
  79     int modef = open(buffer, O_WRONLY);
  80     if (modef == -1) {
  81         syslog(LOG_ERR, "edison: Failed to open SoC pinmode for opening");
  82         return MRAA_ERROR_INVALID_RESOURCE;
  83     }
  84
  85     mraa_result_t ret = MRAA_SUCCESS;
  86     char mode_buf[MAX_MODE_SIZE];
  87     int length = sprintf(mode_buf, "mode%u",mode);
  88     if (write(modef, mode_buf, length*sizeof(char)) == -1) {
  89         ret = MRAA_ERROR_INVALID_RESOURCE;
  90     }
  91     close(modef);
  92
  93     return ret;
  94 }
  95
  96 mraa_result_t
  97 mraa_intel_edison_gpio_dir_pre(mraa_gpio_context dev, gpio_dir_t dir)
  98 {
  99     if (mraa_gpio_write(tristate, 0) != MRAA_SUCCESS) {
 100         // call can sometimes fail, this does not actually mean much except
 101         // that the kernel drivers don't always behave very well
 102         syslog(LOG_NOTICE, "edison: Failed to write to tristate");
 103     }
 104
 105     if (dev->phy_pin >= 0) {
 106         int pin = dev->phy_pin;
 107
 108         mraa_gpio_context output_e;
 109         output_e = mraa_gpio_init_raw(outputen[pin]);
 110         if (output_e == NULL) {
 111             return MRAA_ERROR_INVALID_RESOURCE;
 112         }
 113         if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
 114             mraa_gpio_close(output_e);
 115             return MRAA_ERROR_INVALID_RESOURCE;
 116         }
 117         int output_val = 0;
 118         if (dir == MRAA_GPIO_OUT) {
 119             output_val = 1;
 120         }
 121         if (mraa_gpio_write(output_e, output_val) != MRAA_SUCCESS) {
 122             mraa_gpio_close(output_e);
 123             return MRAA_ERROR_INVALID_RESOURCE;
 124         }
 125         mraa_gpio_close(output_e);
 126     }
 127
 128     return MRAA_SUCCESS;
 129 }
 130
 131 mraa_result_t
 132 mraa_intel_edison_gpio_dir_post(mraa_gpio_context dev, gpio_dir_t dir)
 133 {
 134     return mraa_gpio_write(tristate, 1);
 135 }
 136
 137 mraa_result_t
 138 mraa_intel_edison_gpio_init_post(mraa_gpio_context dev)
 139 {
 140     if (dev == NULL) {
 141         return MRAA_ERROR_INVALID_RESOURCE;
 142     }
 143
 144     int sysfs, mode;
 145     if (miniboard == 1) {
 146         sysfs = dev->pin;
 147         mode = 0;
 148     } else {
 149         sysfs = pinmodes[dev->phy_pin].gpio.sysfs;
 150         mode = pinmodes[dev->phy_pin].gpio.mode;
 151     }
 152
 153     return mraa_intel_edison_pinmode_change(sysfs, mode);
 154 }
 155
 156 mraa_result_t
 157 mraa_intel_edison_i2c_init_pre(unsigned int bus)
 158 {
 159     if (miniboard == 0) {
 160         if (bus != 6) {
 161             syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
 162             bus = 6;
 163         }
 164         mraa_gpio_write(tristate, 0);
 165         mraa_gpio_context io18_gpio = mraa_gpio_init_raw(14);
 166         mraa_gpio_context io19_gpio = mraa_gpio_init_raw(165);
 167         mraa_gpio_dir(io18_gpio, MRAA_GPIO_IN);
 168         mraa_gpio_dir(io19_gpio, MRAA_GPIO_IN);
 169         mraa_gpio_close(io18_gpio);
 170         mraa_gpio_close(io19_gpio);
 171
 172         mraa_gpio_context io18_enable = mraa_gpio_init_raw(236);
 173         mraa_gpio_context io19_enable = mraa_gpio_init_raw(237);
 174         mraa_gpio_dir(io18_enable, MRAA_GPIO_OUT);
 175         mraa_gpio_dir(io19_enable, MRAA_GPIO_OUT);
 176         mraa_gpio_write(io18_enable, 0);
 177         mraa_gpio_write(io19_enable, 0);
 178         mraa_gpio_close(io18_enable);
 179         mraa_gpio_close(io19_enable);
 180
 181         mraa_gpio_context io18_pullup = mraa_gpio_init_raw(212);
 182         mraa_gpio_context io19_pullup = mraa_gpio_init_raw(213);
 183         mraa_gpio_dir(io18_pullup, MRAA_GPIO_IN);
 184         mraa_gpio_dir(io19_pullup, MRAA_GPIO_IN);
 185         mraa_gpio_close(io18_pullup);
 186         mraa_gpio_close(io19_pullup);
 187
 188         mraa_intel_edison_pinmode_change(28, 1);
 189         mraa_intel_edison_pinmode_change(27, 1);
 190
 191         mraa_gpio_write(tristate, 1);
 192     } else {
 193         if(bus != 6 && bus != 1) {
 194             syslog(LOG_ERR, "edison: You can't use that bus, switching to bus 6");
 195             bus = 6;
 196         }
 197         int scl = plat->pins[plat->i2c_bus[bus].scl].gpio.pinmap;
 198         int sda = plat->pins[plat->i2c_bus[bus].sda].gpio.pinmap;
 199         mraa_intel_edison_pinmode_change(sda, 1);
 200         mraa_intel_edison_pinmode_change(scl, 1);
 201     }
 202
 203     return MRAA_SUCCESS;
 204 }
 205
 206 static mraa_result_t
 207 mraa_intel_edison_misc_spi()
 208 {
 209     mraa_gpio_write(tristate, 0);
 210
 211     mraa_gpio_context io10_p1 = mraa_gpio_init_raw(263);
 212     mraa_gpio_context io10_p2 = mraa_gpio_init_raw(240);
 213     mraa_gpio_context io11_p1 = mraa_gpio_init_raw(262);
 214     mraa_gpio_context io11_p2 = mraa_gpio_init_raw(241);
 215     mraa_gpio_context io12_p1 = mraa_gpio_init_raw(242);
 216     mraa_gpio_context io13_p1 = mraa_gpio_init_raw(243);
 217     mraa_gpio_dir(io10_p1, MRAA_GPIO_OUT);
 218     mraa_gpio_dir(io10_p2, MRAA_GPIO_OUT);
 219     mraa_gpio_dir(io11_p1, MRAA_GPIO_OUT);
 220     mraa_gpio_dir(io11_p2, MRAA_GPIO_OUT);
 221     mraa_gpio_dir(io12_p1, MRAA_GPIO_OUT);
 222     mraa_gpio_dir(io13_p1, MRAA_GPIO_OUT);
 223
 224     mraa_gpio_write(io10_p1, 1);
 225     mraa_gpio_write(io10_p2, 0);
 226     mraa_gpio_write(io11_p1, 1);
 227     mraa_gpio_write(io11_p2, 0);
 228     mraa_gpio_write(io12_p1, 0);
 229     mraa_gpio_write(io13_p1, 0);
 230
 231     mraa_gpio_close(io10_p1);
 232     mraa_gpio_close(io10_p2);
 233     mraa_gpio_close(io11_p1);
 234     mraa_gpio_close(io11_p2);
 235     mraa_gpio_close(io12_p1);
 236     mraa_gpio_close(io13_p1);
 237
 238     mraa_intel_edison_pinmode_change(111, 1);
 239     mraa_intel_edison_pinmode_change(115, 1);
 240     mraa_intel_edison_pinmode_change(114, 1);
 241     mraa_intel_edison_pinmode_change(109, 1);
 242     mraa_gpio_write(tristate, 1);
 243
 244     return MRAA_SUCCESS;
 245 }
 246
 247 mraa_result_t
 248 mraa_intel_edison_aio_get_fp(mraa_aio_context dev)
 249 {
 250     char file_path[64]= "";
 251
 252     snprintf(file_path, 64, "/sys/bus/iio/devices/iio:device1/in_voltage%d_raw",
 253             dev->channel );
 254
 255     dev->adc_in_fp = open(file_path, O_RDONLY);
 256     if (dev->adc_in_fp == -1) {
 257         syslog(LOG_ERR, "edison: Failed to open Analog input raw file %s for "
 258                 "reading!", file_path);
 259         return MRAA_ERROR_INVALID_RESOURCE;
 260     }
 261
 262     return MRAA_SUCCESS;
 263 }
 264
 265 mraa_result_t
 266 mraa_intel_edison_aio_init_pre(unsigned int aio)
 267 {
 268     if (aio > plat->aio_count) {
 269         syslog(LOG_ERR, "edison: Invalid analog input channel");
 270         return MRAA_ERROR_INVALID_RESOURCE;
 271     }
 272
 273     int pin = 14 + aio;
 274     mraa_gpio_context output_e;
 275     output_e = mraa_gpio_init_raw(outputen[pin]);
 276     if (output_e == NULL) {
 277         return MRAA_ERROR_INVALID_RESOURCE;
 278     }
 279     if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
 280         mraa_gpio_close(output_e);
 281         return MRAA_ERROR_INVALID_RESOURCE;
 282     }
 283     if (mraa_gpio_write(output_e, 0) != MRAA_SUCCESS) {
 284         mraa_gpio_close(output_e);
 285         return MRAA_ERROR_INVALID_RESOURCE;
 286     }
 287     mraa_gpio_close(output_e);
 288
 289     mraa_gpio_context pullup_pin;
 290     pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
 291     if (pullup_pin == NULL) {
 292         return MRAA_ERROR_INVALID_RESOURCE;
 293     }
 294     if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS) {
 295         mraa_gpio_close(pullup_pin);
 296         return MRAA_ERROR_INVALID_RESOURCE;
 297     }
 298     mraa_gpio_close(pullup_pin);
 299
 300     return MRAA_SUCCESS;
 301 }
 302
 303 mraa_result_t
 304 mraa_intel_edison_aio_init_post(mraa_aio_context dev)
 305 {
 306     return mraa_gpio_write(tristate, 1);
 307 }
 308
 309 mraa_result_t
 310 mraa_intel_edison_pwm_init_pre(int pin)
 311 {
 312     if (miniboard == 1) {
 313         return mraa_intel_edison_pinmode_change(plat->pins[pin].gpio.pinmap, 1);
 314     }
 315     if (pin < 0 || pin > 19) {
 316         return MRAA_ERROR_INVALID_RESOURCE;
 317     }
 318
 319     if (!plat->pins[pin].capabilites.pwm) {
 320         return MRAA_ERROR_INVALID_RESOURCE;
 321     }
 322
 323     mraa_gpio_context output_e;
 324     output_e = mraa_gpio_init_raw(outputen[pin]);
 325     if (output_e == NULL) {
 326         return MRAA_ERROR_INVALID_RESOURCE;
 327     }
 328     if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
 329         mraa_gpio_close(output_e);
 330         return MRAA_ERROR_INVALID_RESOURCE;
 331     }
 332     if (mraa_gpio_write(output_e, 1) != MRAA_SUCCESS) {
 333         mraa_gpio_close(output_e);
 334         return MRAA_ERROR_INVALID_RESOURCE;
 335     }
 336     mraa_gpio_close(output_e);
 337
 338     mraa_gpio_context pullup_pin;
 339     pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
 340     if (pullup_pin == NULL) {
 341         return MRAA_ERROR_INVALID_RESOURCE;
 342     }
 343     if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS) {
 344         mraa_gpio_close(pullup_pin);
 345         return MRAA_ERROR_INVALID_RESOURCE;
 346     }
 347     mraa_gpio_close(pullup_pin);
 348     mraa_intel_edison_pinmode_change(plat->pins[pin].gpio.pinmap, 1);
 349
 350     return MRAA_SUCCESS;
 351 }
 352
 353 mraa_result_t
 354 mraa_intel_edison_pwm_init_post(mraa_pwm_context pwm)
 355 {
 356     return mraa_gpio_write(tristate, 1);
 357 }
 358
 359 mraa_result_t
 360 mraa_intel_edison_spi_init_pre(int bus)
 361 {
 362     if (miniboard == 1) {
 363         mraa_intel_edison_pinmode_change(111, 1);
 364         mraa_intel_edison_pinmode_change(115, 1);
 365         mraa_intel_edison_pinmode_change(114, 1);
 366         mraa_intel_edison_pinmode_change(109, 1);
 367         return MRAA_SUCCESS;
 368     }
 369     mraa_gpio_write(tristate, 0);
 370
 371     mraa_gpio_context io10_out = mraa_gpio_init_raw(258);
 372     mraa_gpio_context io11_out = mraa_gpio_init_raw(259);
 373     mraa_gpio_context io12_out = mraa_gpio_init_raw(260);
 374     mraa_gpio_context io13_out = mraa_gpio_init_raw(261);
 375     mraa_gpio_dir(io10_out, MRAA_GPIO_OUT);
 376     mraa_gpio_dir(io11_out, MRAA_GPIO_OUT);
 377     mraa_gpio_dir(io12_out, MRAA_GPIO_OUT);
 378     mraa_gpio_dir(io13_out, MRAA_GPIO_OUT);
 379
 380     mraa_gpio_write(io10_out, 1);
 381     mraa_gpio_write(io11_out, 1);
 382     mraa_gpio_write(io12_out, 0);
 383     mraa_gpio_write(io13_out, 1);
 384
 385     mraa_gpio_close(io10_out);
 386     mraa_gpio_close(io11_out);
 387     mraa_gpio_close(io12_out);
 388     mraa_gpio_close(io13_out);
 389
 390     mraa_gpio_context io10_pull = mraa_gpio_init_raw(226);
 391     mraa_gpio_context io11_pull = mraa_gpio_init_raw(227);
 392     mraa_gpio_context io12_pull = mraa_gpio_init_raw(228);
 393     mraa_gpio_context io13_pull = mraa_gpio_init_raw(229);
 394
 395     mraa_gpio_dir(io10_pull, MRAA_GPIO_IN);
 396     mraa_gpio_dir(io11_pull, MRAA_GPIO_IN);
 397     mraa_gpio_dir(io12_pull, MRAA_GPIO_IN);
 398     mraa_gpio_dir(io13_pull, MRAA_GPIO_IN);
 399
 400     mraa_gpio_close(io10_pull);
 401     mraa_gpio_close(io11_pull);
 402     mraa_gpio_close(io12_pull);
 403     mraa_gpio_close(io13_pull);
 404
 405     return MRAA_SUCCESS;
 406 }
 407
 408 mraa_result_t
 409 mraa_intel_edison_spi_init_post(mraa_spi_context spi)
 410 {
 411     return mraa_gpio_write(tristate, 1);
 412 }
 413
 414 mraa_result_t
 415 mraa_intel_edison_gpio_mode_replace(mraa_gpio_context dev, gpio_mode_t mode)
 416 {
 417     if (dev->value_fp != -1) {
 418          if (close(dev->value_fp) != 0) {
 419              return MRAA_ERROR_INVALID_RESOURCE;
 420          }
 421          dev->value_fp = -1;
 422     }
 423
 424     mraa_gpio_context pullup_e;
 425     pullup_e = mraa_gpio_init_raw(pullup_map[dev->phy_pin]);
 426     if (pullup_e == NULL) {
 427         return MRAA_ERROR_INVALID_RESOURCE;
 428     }
 429     if (mraa_gpio_dir(pullup_e, MRAA_GPIO_IN) != MRAA_SUCCESS) {
 430         syslog(LOG_ERR, "edison: Failed to set gpio mode-pullup");
 431         mraa_gpio_close(pullup_e);
 432         return MRAA_ERROR_INVALID_RESOURCE;
 433     }
 434
 435     int value = -1;
 436     switch(mode) {
 437         case MRAA_GPIO_STRONG:
 438             break;
 439         case MRAA_GPIO_PULLUP:
 440             value = 1;
 441             break;
 442         case MRAA_GPIO_PULLDOWN:
 443             value = 0;
 444             break;
 445         case MRAA_GPIO_HIZ:
 446             return MRAA_SUCCESS;
 447             break;
 448         default:
 449             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 450     }
 451     if (value != -1) {
 452         if (mraa_gpio_dir(pullup_e, MRAA_GPIO_OUT) != MRAA_SUCCESS) {
 453             syslog(LOG_ERR, "edison: Error setting pullup");
 454             mraa_gpio_close(pullup_e);
 455             return MRAA_ERROR_INVALID_RESOURCE;
 456         }
 457         if (mraa_gpio_write(pullup_e, value)!= MRAA_SUCCESS) {
 458             syslog(LOG_ERR, "edison: Error setting pullup");
 459             mraa_gpio_close(pullup_e);
 460             return MRAA_ERROR_INVALID_RESOURCE;
 461         }
 462     }
 463
 464     return mraa_gpio_close(pullup_e);
 465 }
 466
 467 mraa_result_t
 468 mraa_intel_edsion_mb_gpio_mode(mraa_gpio_context dev, gpio_mode_t mode)
 469 {
 470     if (dev->value_fp != -1) {
 471          if (close(dev->value_fp) != 0) {
 472              return MRAA_ERROR_INVALID_RESOURCE;
 473          }
 474          dev->value_fp = -1;
 475     }
 476
 477     char filepath[MAX_SIZE];
 478     snprintf(filepath, MAX_SIZE,
 479              SYSFS_PINMODE_PATH "%d/current_pullmode", dev->pin);
 480
 481     int drive = open(filepath, O_WRONLY);
 482     if (drive == -1) {
 483         syslog(LOG_ERR, "edison: Failed to open drive for writing");
 484         return MRAA_ERROR_INVALID_RESOURCE;
 485     }
 486
 487     char bu[MAX_SIZE];
 488     int length;
 489     switch(mode) {
 490         case MRAA_GPIO_STRONG:
 491             close(drive);
 492             return MRAA_SUCCESS;
 493         case MRAA_GPIO_PULLUP:
 494             length = snprintf(bu, sizeof(bu), "pullup");
 495             break;
 496         case MRAA_GPIO_PULLDOWN:
 497             length = snprintf(bu, sizeof(bu), "pulldown");
 498             break;
 499         case MRAA_GPIO_HIZ:
 500             length = snprintf(bu, sizeof(bu), "nopull");
 501             break;
 502         default:
 503             close(drive);
 504             return MRAA_ERROR_FEATURE_NOT_IMPLEMENTED;
 505     }
 506     if (write(drive, bu, length*sizeof(char)) == -1) {
 507         syslog(LOG_ERR, "edison: Failed to write to drive mode");
 508         close(drive);
 509         return MRAA_ERROR_INVALID_RESOURCE;
 510     }
 511
 512     if (close(drive) != 0) {
 513         return MRAA_ERROR_INVALID_RESOURCE;
 514     }
 515     return MRAA_SUCCESS;
 516 }
 517
 518 mraa_result_t
 519 mraa_intel_edison_uart_init_pre(int index)
 520 {
 521     if (miniboard == 0) {
 522         mraa_gpio_write(tristate, 0);
 523         mraa_gpio_context io0_output = mraa_gpio_init_raw(248);
 524         mraa_gpio_context io0_pullup = mraa_gpio_init_raw(216);
 525         mraa_gpio_context io1_output = mraa_gpio_init_raw(249);
 526         mraa_gpio_context io1_pullup = mraa_gpio_init_raw(217);
 527         mraa_gpio_dir(io0_output, MRAA_GPIO_OUT);
 528         mraa_gpio_dir(io0_pullup, MRAA_GPIO_OUT);
 529         mraa_gpio_dir(io1_output, MRAA_GPIO_OUT);
 530         mraa_gpio_dir(io1_pullup, MRAA_GPIO_IN);
 531
 532         mraa_gpio_write(io0_output, 0);
 533         mraa_gpio_write(io0_pullup, 0);
 534         mraa_gpio_write(io1_output, 1);
 535
 536         mraa_gpio_close(io0_output);
 537         mraa_gpio_close(io0_pullup);
 538         mraa_gpio_close(io1_output);
 539         mraa_gpio_close(io1_pullup);
 540     }
 541     mraa_result_t ret;
 542     ret = mraa_intel_edison_pinmode_change(130,1); //IO0 RX
 543     ret = mraa_intel_edison_pinmode_change(131,1); //IO1 TX
 544     return ret;
 545 }
 546
 547 mraa_result_t
 548 mraa_intel_edison_uart_init_post(mraa_uart_context uart)
 549 {
 550     return mraa_gpio_write(tristate, 1);
 551 }
 552
 553 static mraa_result_t
 554 mraa_intel_edsion_mmap_unsetup()
 555 {
 556     if (mmap_reg == NULL) {
 557         syslog(LOG_ERR, "edison mmap: null register cant unsetup");
 558         return MRAA_ERROR_INVALID_RESOURCE;
 559     }
 560     munmap(mmap_reg, mmap_size);
 561     mmap_reg = NULL;
 562     if (close(mmap_fd) != 0) {
 563         return MRAA_ERROR_INVALID_RESOURCE;
 564     }
 565     return MRAA_SUCCESS;
 566 }
 567
 568 mraa_result_t
 569 mraa_intel_edison_mmap_write(mraa_gpio_context dev, int value)
 570 {
 571     uint8_t offset = ((dev->pin / 32) * sizeof(uint32_t));
 572     uint8_t valoff;
 573
 574     if (value) {
 575         valoff = 0x34;
 576     } else {
 577         valoff = 0x4c;
 578     }
 579
 580     *(volatile uint32_t*) (mmap_reg + offset + valoff) =
 581         (uint32_t)(1 << (dev->pin % 32));
 582
 583     return MRAA_SUCCESS;
 584 }
 585
 586 int
 587 mraa_intel_edison_mmap_read(mraa_gpio_context dev)
 588 {
 589     uint8_t offset = ((dev->pin / 32) * sizeof(uint32_t));
 590     uint32_t value;
 591
 592     value = *(volatile uint32_t*) (mmap_reg +0x04+ offset);
 593     if (value&(uint32_t)(1 << (dev->pin % 32))) {
 594         return 1;
 595     }
 596     return 0;
 597 }
 598
 599 mraa_result_t
 600 mraa_intel_edison_mmap_setup(mraa_gpio_context dev, mraa_boolean_t en)
 601 {
 602     if (dev == NULL) {
 603         syslog(LOG_ERR, "edison mmap: context not valid");
 604         return MRAA_ERROR_INVALID_HANDLE;
 605     }
 606
 607     if (en == 0) {
 608         if (dev->mmap_write == NULL && dev->mmap_read == NULL) {
 609             syslog(LOG_ERR, "edison mmap: can't disable disabled mmap gpio");
 610             return MRAA_ERROR_INVALID_PARAMETER;
 611         }
 612         dev->mmap_write = NULL;
 613         dev->mmap_read = NULL;
 614         mmap_count--;
 615         if (mmap_count == 0) {
 616             return mraa_intel_edsion_mmap_unsetup();
 617         }
 618         return MRAA_SUCCESS;
 619     }
 620
 621     if (dev->mmap_write != NULL && dev->mmap_read != NULL) {
 622         syslog(LOG_ERR, "edison mmap: can't enable enabled mmap gpio");
 623         return MRAA_ERROR_INVALID_PARAMETER;
 624     }
 625
 626     //Might need to make some elements of this thread safe.
 627     //For example only allow one thread to enter the following block
 628     //to prevent mmap'ing twice.
 629     if (mmap_reg == NULL) {
 630         if ((mmap_fd = open(MMAP_PATH, O_RDWR)) < 0) {
 631             syslog(LOG_ERR, "edison map: unable to open resource0 file");
 632             return MRAA_ERROR_INVALID_HANDLE;
 633         }
 634
 635         struct stat fd_stat;
 636         fstat(mmap_fd, &fd_stat);
 637         mmap_size = fd_stat.st_size;
 638
 639         mmap_reg = (uint8_t*) mmap(NULL, fd_stat.st_size,
 640                                    PROT_READ | PROT_WRITE,
 641                                    MAP_FILE | MAP_SHARED,
 642                                    mmap_fd, 0);
 643         if (mmap_reg == MAP_FAILED) {
 644             syslog(LOG_ERR, "edison mmap: failed to mmap");
 645             mmap_reg = NULL;
 646             close(mmap_fd);
 647             return MRAA_ERROR_NO_RESOURCES;
 648         }
 649     }
 650     dev->mmap_write = &mraa_intel_edison_mmap_write;
 651     dev->mmap_read = &mraa_intel_edison_mmap_read;
 652     mmap_count++;
 653
 654     return MRAA_SUCCESS;
 655 }
 656
 657 mraa_result_t
 658 mraa_intel_edison_miniboard(mraa_board_t* b)
 659 {
 660     miniboard = 1;
 661     b->phy_pin_count = 56;
 662     b->gpio_count = 56; // A bit of a hack I suppose
 663     b->aio_count = 0;
 664     b->pwm_default_period = 5000;
 665     b->pwm_max_period = 218453;
 666     b->pwm_min_period = 1;
 667
 668     b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t)*56);
 669     if (b->pins == NULL) {
 670         return MRAA_ERROR_UNSPECIFIED;
 671     }
 672
 673     advance_func->gpio_init_post = &mraa_intel_edison_gpio_init_post;
 674     advance_func->pwm_init_pre = &mraa_intel_edison_pwm_init_pre;
 675     advance_func->i2c_init_pre = &mraa_intel_edison_i2c_init_pre;
 676     advance_func->spi_init_pre = &mraa_intel_edison_spi_init_pre;
 677     advance_func->gpio_mode_replace = &mraa_intel_edsion_mb_gpio_mode;
 678     advance_func->uart_init_pre = &mraa_intel_edison_uart_init_pre;
 679     advance_func->gpio_mmap_setup = &mraa_intel_edison_mmap_setup;
 680
 681     int pos = 0;
 682     strncpy(b->pins[pos].name, "J17-1", 8);
 683     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
 684     b->pins[pos].gpio.pinmap = 182;
 685     b->pins[pos].gpio.mux_total = 0;
 686     b->pins[pos].pwm.pinmap = 2;
 687     b->pins[pos].pwm.parent_id = 0;
 688     b->pins[pos].pwm.mux_total = 0;
 689     pos++;
 690
 691     strncpy(b->pins[pos].name, "J17-2", 8);
 692     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 693     pos++;
 694     strncpy(b->pins[pos].name, "J17-3", 8);
 695     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 696     pos++;
 697     strncpy(b->pins[pos].name, "J17-4", 8);
 698     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 699     pos++;
 700
 701     strncpy(b->pins[pos].name, "J17-5", 8);
 702     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 703     b->pins[pos].gpio.pinmap = 135;
 704     b->pins[pos].gpio.mux_total = 0;
 705     pos++;
 706
 707     strncpy(b->pins[pos].name, "J17-6", 8);
 708     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 709     pos++;
 710
 711     strncpy(b->pins[pos].name, "J17-7", 8);
 712     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,0,0};
 713     b->pins[pos].gpio.pinmap = 27;
 714     b->pins[pos].gpio.mux_total = 0;
 715     b->pins[pos].i2c.pinmap = 1;
 716     b->pins[pos].i2c.mux_total = 0;
 717     pos++;
 718
 719     strncpy(b->pins[pos].name, "J17-8", 8);
 720     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,0,0};
 721     b->pins[pos].gpio.pinmap = 20;
 722     b->pins[pos].gpio.mux_total = 0;
 723     b->pins[pos].i2c.pinmap = 1;
 724     b->pins[pos].i2c.mux_total = 0;
 725     pos++;
 726
 727     strncpy(b->pins[pos].name, "J17-9", 8);
 728     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,0,0};
 729     b->pins[pos].gpio.pinmap = 28;
 730     b->pins[pos].gpio.mux_total = 0;
 731     b->pins[pos].i2c.pinmap = 1;
 732     b->pins[pos].i2c.mux_total = 0;
 733     pos++;
 734
 735     strncpy(b->pins[pos].name, "J17-10", 8);
 736     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 737     b->pins[pos].gpio.pinmap = 111;
 738     b->pins[pos].gpio.mux_total = 0;
 739     b->pins[pos].spi.pinmap = 5;
 740     b->pins[pos].spi.mux_total = 0;
 741     pos++;
 742
 743     strncpy(b->pins[pos].name, "J17-11", 8);
 744     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 745     b->pins[pos].gpio.pinmap = 109;
 746     b->pins[pos].gpio.mux_total = 0;
 747     b->pins[pos].spi.pinmap = 5;
 748     b->pins[pos].spi.mux_total = 0;
 749     pos++;
 750
 751     strncpy(b->pins[pos].name, "J17-12", 8);
 752     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 753     b->pins[pos].gpio.pinmap = 115;
 754     b->pins[pos].gpio.mux_total = 0;
 755     b->pins[pos].spi.pinmap = 5;
 756     b->pins[pos].spi.mux_total = 0;
 757     pos++;
 758     strncpy(b->pins[pos].name, "J17-13", 8);
 759     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 760     pos++;
 761
 762     strncpy(b->pins[pos].name, "J17-14", 8);
 763     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 764     b->pins[pos].gpio.pinmap = 128;
 765     b->pins[pos].gpio.parent_id = 0;
 766     b->pins[pos].gpio.mux_total = 0;
 767     pos++;
 768
 769     strncpy(b->pins[pos].name, "J18-1", 8);
 770     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
 771     b->pins[pos].gpio.pinmap = 13;
 772     b->pins[pos].gpio.mux_total = 0;
 773     b->pins[pos].pwm.pinmap = 1;
 774     b->pins[pos].pwm.parent_id = 0;
 775     b->pins[pos].pwm.mux_total = 0;
 776     pos++;
 777
 778     strncpy(b->pins[pos].name, "J18-2", 8);
 779     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 780     b->pins[pos].gpio.pinmap = 165;
 781     b->pins[pos].gpio.mux_total = 0;
 782     pos++;
 783     strncpy(b->pins[pos].name, "J18-3", 8);
 784     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 785     pos++;
 786     strncpy(b->pins[pos].name, "J18-4", 8);
 787     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 788     pos++;
 789     strncpy(b->pins[pos].name, "J18-5", 8);
 790     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 791     pos++;
 792
 793     strncpy(b->pins[pos].name, "J18-6", 8);
 794     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,0,0};
 795     b->pins[pos].gpio.pinmap = 19;
 796     b->pins[pos].gpio.mux_total = 0;
 797     b->pins[pos].i2c.pinmap = 1;
 798     b->pins[pos].i2c.mux_total = 0;
 799     pos++;
 800
 801     strncpy(b->pins[pos].name, "J18-7", 8);
 802     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
 803     b->pins[pos].gpio.pinmap = 12;
 804     b->pins[pos].gpio.mux_total = 0;
 805     b->pins[pos].pwm.pinmap = 0;
 806     b->pins[pos].pwm.parent_id = 0;
 807     b->pins[pos].pwm.mux_total = 0;
 808     pos++;
 809
 810     strncpy(b->pins[pos].name, "J18-8", 8);
 811     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
 812     b->pins[pos].gpio.pinmap = 183;
 813     b->pins[pos].gpio.mux_total = 0;
 814     b->pins[pos].pwm.pinmap = 3;
 815     b->pins[pos].pwm.parent_id = 0;
 816     b->pins[pos].pwm.mux_total = 0;
 817     pos++;
 818     strncpy(b->pins[pos].name, "J18-9", 8);
 819     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 820     pos++;
 821
 822     strncpy(b->pins[pos].name, "J18-10", 8);
 823     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 824     b->pins[pos].gpio.pinmap = 110;
 825     b->pins[pos].gpio.mux_total = 0;
 826     b->pins[pos].spi.pinmap = 5;
 827     b->pins[pos].spi.mux_total = 0;
 828     pos++;
 829     strncpy(b->pins[pos].name, "J18-11", 8);
 830     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 831     b->pins[pos].gpio.pinmap = 114;
 832     b->pins[pos].gpio.mux_total = 0;
 833     b->pins[pos].spi.pinmap = 5;
 834     b->pins[pos].spi.mux_total = 0;
 835     pos++;
 836
 837     strncpy(b->pins[pos].name, "J18-12", 8);
 838     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 839     b->pins[pos].gpio.pinmap = 129;
 840     b->pins[pos].gpio.mux_total = 0;
 841     pos++;
 842     strncpy(b->pins[pos].name, "J18-13", 8);
 843     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,1};
 844     b->pins[pos].gpio.pinmap = 130;
 845     b->pins[pos].gpio.mux_total = 0;
 846     b->pins[pos].uart.pinmap = 0;
 847     b->pins[pos].uart.parent_id = 0;
 848     b->pins[pos].uart.mux_total = 0;
 849
 850     pos++;
 851     strncpy(b->pins[pos].name, "J18-14", 8);
 852     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 853     pos++;
 854
 855     strncpy(b->pins[pos].name, "J19-1", 8);
 856     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 857     pos++;
 858     strncpy(b->pins[pos].name, "J19-2", 8);
 859     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 860     pos++;
 861     strncpy(b->pins[pos].name, "J19-3", 8);
 862     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 863     pos++;
 864
 865     strncpy(b->pins[pos].name, "J19-4", 8);
 866     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 867     b->pins[pos].gpio.pinmap = 44;
 868     b->pins[pos].gpio.mux_total = 0;
 869     pos++;
 870     strncpy(b->pins[pos].name, "J19-5", 8);
 871     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 872     b->pins[pos].gpio.pinmap = 46;
 873     b->pins[pos].gpio.mux_total = 0;
 874     pos++;
 875     strncpy(b->pins[pos].name, "J19-6", 8);
 876     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 877     b->pins[pos].gpio.pinmap = 48;
 878     b->pins[pos].gpio.mux_total = 0;
 879     pos++;
 880
 881     strncpy(b->pins[pos].name, "J19-7", 8);
 882     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 883     pos++;
 884
 885     strncpy(b->pins[pos].name, "J19-8", 8);
 886     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,1};
 887     b->pins[pos].gpio.pinmap = 131;
 888     b->pins[pos].gpio.mux_total = 0;
 889     b->pins[pos].uart.pinmap = 0;
 890     b->pins[pos].uart.parent_id = 0;
 891     b->pins[pos].uart.mux_total = 0;
 892     pos++;
 893
 894     strncpy(b->pins[pos].name, "J19-9", 8);
 895     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 896     b->pins[pos].gpio.pinmap = 14;
 897     b->pins[pos].gpio.mux_total = 0;
 898     pos++;
 899
 900     strncpy(b->pins[pos].name, "J19-10", 8);
 901     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 902     b->pins[pos].gpio.pinmap = 40;
 903     b->pins[pos].gpio.mux_total = 0;
 904     pos++;
 905     strncpy(b->pins[pos].name, "J19-11", 8);
 906     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 907     b->pins[pos].gpio.pinmap = 43;
 908     b->pins[pos].gpio.mux_total = 0;
 909     pos++;
 910     strncpy(b->pins[pos].name, "J19-12", 8);
 911     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 912     b->pins[pos].gpio.pinmap = 77;
 913     b->pins[pos].gpio.mux_total = 0;
 914     pos++;
 915     strncpy(b->pins[pos].name, "J19-13", 8);
 916     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 917     b->pins[pos].gpio.pinmap = 82;
 918     b->pins[pos].gpio.mux_total = 0;
 919     pos++;
 920     strncpy(b->pins[pos].name, "J19-14", 8);
 921     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 922     b->pins[pos].gpio.pinmap = 83;
 923     b->pins[pos].gpio.mux_total = 0;
 924     pos++;
 925
 926     strncpy(b->pins[pos].name, "J20-1", 8);
 927     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 928     pos++;
 929     strncpy(b->pins[pos].name, "J20-2", 8);
 930     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 931     pos++;
 932     strncpy(b->pins[pos].name, "J20-3", 8);
 933     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,0,0,0,0,0,0,0};
 934     pos++;
 935     strncpy(b->pins[pos].name, "J20-4", 8);
 936     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 937     b->pins[pos].gpio.pinmap = 45;
 938     b->pins[pos].gpio.mux_total = 0;
 939     pos++;
 940     strncpy(b->pins[pos].name, "J20-5", 8);
 941     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 942     b->pins[pos].gpio.pinmap = 47;
 943     b->pins[pos].gpio.mux_total = 0;
 944     pos++;
 945     strncpy(b->pins[pos].name, "J20-6", 8);
 946     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 947     b->pins[pos].gpio.pinmap = 49;
 948     b->pins[pos].gpio.mux_total = 0;
 949     pos++;
 950     strncpy(b->pins[pos].name, "J20-7", 8);
 951     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 952     b->pins[pos].gpio.pinmap = 15;
 953     b->pins[pos].gpio.mux_total = 0;
 954     pos++;
 955     strncpy(b->pins[pos].name, "J20-8", 8);
 956     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 957     b->pins[pos].gpio.pinmap = 84;
 958     b->pins[pos].gpio.mux_total = 0;
 959     pos++;
 960     strncpy(b->pins[pos].name, "J20-9", 8);
 961     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 962     b->pins[pos].gpio.pinmap = 42;
 963     b->pins[pos].gpio.mux_total = 0;
 964     pos++;
 965     strncpy(b->pins[pos].name, "J20-10", 8);
 966     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 967     b->pins[pos].gpio.pinmap = 41;
 968     b->pins[pos].gpio.mux_total = 0;
 969     pos++;
 970     strncpy(b->pins[pos].name, "J20-11", 8);
 971     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 972     b->pins[pos].gpio.pinmap = 78;
 973     b->pins[pos].gpio.mux_total = 0;
 974     pos++;
 975     strncpy(b->pins[pos].name, "J20-12", 8);
 976     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 977     b->pins[pos].gpio.pinmap = 79;
 978     b->pins[pos].gpio.mux_total = 0;
 979     pos++;
 980     strncpy(b->pins[pos].name, "J20-13", 8);
 981     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 982     b->pins[pos].gpio.pinmap = 80;
 983     b->pins[pos].gpio.mux_total = 0;
 984     pos++;
 985     strncpy(b->pins[pos].name, "J20-14", 8);
 986     b->pins[pos].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,0};
 987     b->pins[pos].gpio.pinmap = 81;
 988     b->pins[pos].gpio.mux_total = 0;
 989     pos++;
 990
 991     //BUS DEFINITIONS
 992     b->i2c_bus_count = 9;
 993     b->def_i2c_bus = 6;
 994     int ici;
 995     for (ici = 0; ici < 9; ici++) {
 996         b->i2c_bus[ici].bus_id = -1;
 997     }
 998     b->i2c_bus[1].bus_id = 1;
 999     b->i2c_bus[1].sda = 7;
1000     b->i2c_bus[1].scl = 19;
1001
1002     b->i2c_bus[6].bus_id = 6;
1003     b->i2c_bus[6].sda = 8;
1004     b->i2c_bus[6].scl = 6;
1005
1006     b->spi_bus_count = 1;
1007     b->def_spi_bus = 0;
1008     b->spi_bus[0].bus_id = 5;
1009     b->spi_bus[0].slave_s = 1;
1010     b->spi_bus[0].cs = 23;
1011     b->spi_bus[0].mosi = 11;
1012     b->spi_bus[0].miso = 24;
1013     b->spi_bus[0].sclk = 10;
1014
1015     b->uart_dev_count = 1;
1016     b->def_uart_dev = 0;
1017     b->uart_dev[0].rx = 26;
1018     b->uart_dev[0].tx = 35;
1019
1020     return MRAA_SUCCESS;
1021 }
1022
1023 mraa_board_t*
1024 mraa_intel_edison_fab_c()
1025 {
1026     mraa_board_t* b = (mraa_board_t*) malloc(sizeof(mraa_board_t));
1027     if (b == NULL) {
1028         return NULL;
1029     }
1030
1031     b->platform_name_length = strlen(PLATFORM_NAME) + 1;
1032     b->platform_name = (char*) malloc(sizeof(char) * b->platform_name_length);
1033     if (b->platform_name == NULL) {
1034         goto error;
1035     }
1036     strncpy(b->platform_name, PLATFORM_NAME, b->platform_name_length);
1037
1038     // This seciton will also check if the arduino board is there
1039     tristate = mraa_gpio_init_raw(214);
1040     if (tristate == NULL) {
1041         syslog(LOG_INFO, "edison: Failed to initialise Arduino board TriState,\
1042                 assuming Intel Edison Miniboard\n");
1043         if (mraa_intel_edison_miniboard(b) != MRAA_SUCCESS) {
1044             goto error;
1045         }
1046         return b;
1047     }
1048     // Now Assuming the edison is attached to the Arduino board.
1049     b->phy_pin_count = 20;
1050     b->gpio_count = 14;
1051     b->aio_count = 6;
1052
1053     advance_func->gpio_dir_pre = &mraa_intel_edison_gpio_dir_pre;
1054     advance_func->gpio_init_post = &mraa_intel_edison_gpio_init_post;
1055     advance_func->gpio_dir_post = &mraa_intel_edison_gpio_dir_post;
1056     advance_func->i2c_init_pre = &mraa_intel_edison_i2c_init_pre;
1057     advance_func->aio_get_valid_fp = &mraa_intel_edison_aio_get_fp;
1058     advance_func->aio_init_pre = &mraa_intel_edison_aio_init_pre;
1059     advance_func->aio_init_post = &mraa_intel_edison_aio_init_post;
1060     advance_func->pwm_init_pre = &mraa_intel_edison_pwm_init_pre;
1061     advance_func->pwm_init_post = &mraa_intel_edison_pwm_init_post;
1062     advance_func->spi_init_pre = &mraa_intel_edison_spi_init_pre;
1063     advance_func->spi_init_post = &mraa_intel_edison_spi_init_post;
1064     advance_func->gpio_mode_replace = &mraa_intel_edison_gpio_mode_replace;
1065     advance_func->uart_init_pre = &mraa_intel_edison_uart_init_pre;
1066     advance_func->uart_init_post = &mraa_intel_edison_uart_init_post;
1067     advance_func->gpio_mmap_setup = &mraa_intel_edison_mmap_setup;
1068
1069     b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t)*MRAA_INTEL_EDISON_PINCOUNT);
1070     if (b->pins == NULL) {
1071         goto error;
1072     }
1073
1074     mraa_gpio_dir(tristate, MRAA_GPIO_OUT);
1075     mraa_intel_edison_misc_spi();
1076
1077     b->adc_raw = 12;
1078     b->adc_supported = 10;
1079     b->pwm_default_period = 5000;
1080     b->pwm_max_period = 218453;
1081     b->pwm_min_period = 1;
1082
1083     strncpy(b->pins[0].name, "IO0", 8);
1084     b->pins[0].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,1};
1085     b->pins[0].gpio.pinmap = 130;
1086     b->pins[0].gpio.parent_id = 0;
1087     b->pins[0].gpio.mux_total = 0;
1088     b->pins[0].uart.pinmap = 0;
1089     b->pins[0].uart.parent_id = 0;
1090     b->pins[0].uart.mux_total = 0;
1091
1092     strncpy(b->pins[1].name, "IO1", 8);
1093     b->pins[1].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0,1};
1094     b->pins[1].gpio.pinmap = 131;
1095     b->pins[1].gpio.parent_id = 0;
1096     b->pins[1].gpio.mux_total = 0;
1097     b->pins[1].uart.pinmap = 0;
1098     b->pins[1].uart.parent_id = 0;
1099     b->pins[1].uart.mux_total = 0;
1100
1101     strncpy(b->pins[2].name, "IO2", 8);
1102     b->pins[2].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
1103     b->pins[2].gpio.pinmap = 128;
1104     b->pins[2].gpio.parent_id = 0;
1105     b->pins[2].gpio.mux_total = 0;
1106
1107     strncpy(b->pins[3].name, "IO3", 8);
1108     b->pins[3].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
1109     b->pins[3].gpio.pinmap = 12;
1110     b->pins[3].gpio.parent_id = 0;
1111     b->pins[3].gpio.mux_total = 0;
1112     b->pins[3].pwm.pinmap = 0;
1113     b->pins[3].pwm.parent_id = 0;
1114     b->pins[3].pwm.mux_total = 0;
1115
1116     strncpy(b->pins[4].name, "IO4", 8);
1117     b->pins[4].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
1118     b->pins[4].gpio.pinmap = 129;
1119     b->pins[4].gpio.parent_id = 0;
1120     b->pins[4].gpio.mux_total = 0;
1121
1122     strncpy(b->pins[5].name, "IO5", 8);
1123     b->pins[5].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
1124     b->pins[5].gpio.pinmap = 13;
1125     b->pins[5].gpio.parent_id = 0;
1126     b->pins[5].gpio.mux_total = 0;
1127     b->pins[5].pwm.pinmap = 1;
1128     b->pins[5].pwm.parent_id = 0;
1129     b->pins[5].pwm.mux_total = 0;
1130
1131     strncpy(b->pins[6].name, "IO6", 8);
1132     b->pins[6].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
1133     b->pins[6].gpio.pinmap = 182;
1134     b->pins[6].gpio.parent_id = 0;
1135     b->pins[6].gpio.mux_total = 0;
1136     b->pins[6].pwm.pinmap = 2;
1137     b->pins[6].pwm.parent_id = 0;
1138     b->pins[6].pwm.mux_total = 0;
1139
1140     strncpy(b->pins[7].name, "IO7", 8);
1141     b->pins[7].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
1142     b->pins[7].gpio.pinmap = 48;
1143     b->pins[7].gpio.parent_id = 0;
1144     b->pins[7].gpio.mux_total = 0;
1145
1146     strncpy(b->pins[8].name, "IO8", 8);
1147     b->pins[8].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
1148     b->pins[8].gpio.pinmap = 49;
1149     b->pins[8].gpio.parent_id = 0;
1150     b->pins[8].gpio.mux_total = 0;
1151
1152     strncpy(b->pins[9].name, "IO9", 8);
1153     b->pins[9].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
1154     b->pins[9].gpio.pinmap = 183;
1155     b->pins[9].gpio.parent_id = 0;
1156     b->pins[9].gpio.mux_total = 0;
1157     b->pins[9].pwm.pinmap = 3;
1158     b->pins[9].pwm.parent_id = 0;
1159     b->pins[9].pwm.mux_total = 0;
1160
1161     strncpy(b->pins[10].name, "IO10", 8);
1162     b->pins[10].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
1163     b->pins[10].gpio.pinmap = 41;
1164     b->pins[10].gpio.parent_id = 0;
1165     b->pins[10].gpio.mux_total = 2;
1166     b->pins[10].gpio.mux[0].pin = 263;
1167     b->pins[10].gpio.mux[0].value = 1;
1168     b->pins[10].gpio.mux[1].pin = 240;
1169     b->pins[10].gpio.mux[1].value = 0;
1170     b->pins[10].spi.pinmap = 5;
1171     b->pins[10].spi.mux_total = 2;
1172     b->pins[10].spi.mux[0].pin = 263;
1173     b->pins[10].spi.mux[0].value = 1;
1174     b->pins[10].spi.mux[1].pin = 240;
1175     b->pins[10].spi.mux[1].value = 1;
1176
1177     strncpy(b->pins[11].name, "IO11", 8);
1178     b->pins[11].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
1179     b->pins[11].gpio.pinmap = 43;
1180     b->pins[11].gpio.parent_id = 0;
1181     b->pins[11].gpio.mux_total = 2;
1182     b->pins[11].gpio.mux[0].pin = 262;
1183     b->pins[11].gpio.mux[0].value = 1;
1184     b->pins[11].gpio.mux[1].pin = 241;
1185     b->pins[11].gpio.mux[1].value = 0;
1186     b->pins[11].spi.pinmap = 5;
1187     b->pins[11].spi.mux_total = 2;
1188     b->pins[11].spi.mux[0].pin = 262;
1189     b->pins[11].spi.mux[0].value = 1;
1190     b->pins[11].spi.mux[1].pin = 241;
1191     b->pins[11].spi.mux[1].value = 1;
1192
1193     strncpy(b->pins[12].name, "IO12", 8);
1194     b->pins[12].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
1195     b->pins[12].gpio.pinmap = 42;
1196     b->pins[12].gpio.parent_id = 0;
1197     b->pins[12].gpio.mux_total = 1;
1198     b->pins[12].gpio.mux[0].pin = 242;
1199     b->pins[12].gpio.mux[0].value = 0;
1200     b->pins[12].spi.pinmap = 5;
1201     b->pins[12].spi.mux_total = 1;
1202     b->pins[12].spi.mux[0].pin = 242;
1203     b->pins[12].spi.mux[0].value = 1;
1204
1205     strncpy(b->pins[13].name, "IO13", 8);
1206     b->pins[13].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
1207     b->pins[13].gpio.pinmap = 40;
1208     b->pins[13].gpio.parent_id = 0;
1209     b->pins[13].gpio.mux_total = 1;
1210     b->pins[13].gpio.mux[0].pin = 243;
1211     b->pins[13].gpio.mux[0].value = 0;
1212     b->pins[13].spi.pinmap = 5;
1213     b->pins[13].spi.mux_total = 1;
1214     b->pins[13].spi.mux[0].pin = 243;
1215     b->pins[13].spi.mux[0].value = 1;
1216
1217     strncpy(b->pins[14].name, "A0", 8);
1218     b->pins[14].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
1219     b->pins[14].aio.pinmap = 0;
1220     b->pins[14].aio.mux_total = 1;
1221     b->pins[14].aio.mux[0].pin = 200;
1222     b->pins[14].aio.mux[0].value = 1;
1223     b->pins[14].gpio.pinmap = 44;
1224     b->pins[14].gpio.mux_total = 1;
1225     b->pins[14].gpio.mux[0].pin = 200;
1226     b->pins[14].gpio.mux[0].value = 0;
1227
1228     strncpy(b->pins[15].name, "A1", 8);
1229     b->pins[15].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
1230     b->pins[15].aio.pinmap = 1;
1231     b->pins[15].aio.mux_total = 1;
1232     b->pins[15].aio.mux[0].pin = 201;
1233     b->pins[15].aio.mux[0].value = 1;
1234     b->pins[15].gpio.pinmap = 45;
1235     b->pins[15].gpio.mux_total = 1;
1236     b->pins[15].gpio.mux[0].pin = 201;
1237     b->pins[15].gpio.mux[0].value = 0;
1238
1239     strncpy(b->pins[16].name, "A2", 8);
1240     b->pins[16].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
1241     b->pins[16].aio.pinmap = 2;
1242     b->pins[16].aio.mux_total = 1;
1243     b->pins[16].aio.mux[0].pin = 202;
1244     b->pins[16].aio.mux[0].value = 1;
1245     b->pins[16].gpio.pinmap = 46;
1246     b->pins[16].gpio.mux_total = 1;
1247     b->pins[16].gpio.mux[0].pin = 202;
1248     b->pins[16].gpio.mux[0].value = 0;
1249
1250     strncpy(b->pins[17].name, "A3", 8);
1251     b->pins[17].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
1252     b->pins[17].aio.pinmap = 3;
1253     b->pins[17].aio.mux_total = 1;
1254     b->pins[17].aio.mux[0].pin = 203;
1255     b->pins[17].aio.mux[0].value = 1;
1256     b->pins[17].gpio.pinmap = 47;
1257     b->pins[17].gpio.mux_total = 1;
1258     b->pins[17].gpio.mux[0].pin = 203;
1259     b->pins[17].gpio.mux[0].value = 0;
1260
1261     strncpy(b->pins[18].name, "A4", 8);
1262     b->pins[18].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,1,0};
1263     b->pins[18].i2c.pinmap = 1;
1264     b->pins[18].i2c.mux_total = 1;
1265     b->pins[18].i2c.mux[0].pin = 204;
1266     b->pins[18].i2c.mux[0].value = 0;
1267     b->pins[18].aio.pinmap = 4;
1268     b->pins[18].aio.mux_total = 1;
1269     b->pins[18].aio.mux[0].pin = 204;
1270     b->pins[18].aio.mux[0].value = 1;
1271     b->pins[18].gpio.pinmap = 14;
1272     b->pins[18].gpio.mux_total = 1;
1273     b->pins[18].gpio.mux[0].pin = 204;
1274     b->pins[18].gpio.mux[0].value = 0;
1275
1276     strncpy(b->pins[19].name, "A5", 8);
1277     b->pins[19].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,1,0};
1278     b->pins[19].i2c.pinmap = 1;
1279     b->pins[19].i2c.mux_total = 1;
1280     b->pins[19].i2c.mux[0].pin = 205;
1281     b->pins[19].i2c.mux[0].value = 0;
1282     b->pins[19].aio.pinmap = 5;
1283     b->pins[19].aio.mux_total = 1;
1284     b->pins[19].aio.mux[0].pin = 205;
1285     b->pins[19].aio.mux[0].value = 1;
1286     b->pins[19].gpio.pinmap = 165;
1287     b->pins[19].gpio.mux_total = 1;
1288     b->pins[19].gpio.mux[0].pin = 205;
1289     b->pins[19].gpio.mux[0].value = 0;
1290
1291     //BUS DEFINITIONS
1292     b->i2c_bus_count = 9;
1293     b->def_i2c_bus = 6;
1294     int ici;
1295     for (ici = 0; ici < 9; ici++) {
1296         b->i2c_bus[ici].bus_id = -1;
1297     }
1298     b->i2c_bus[6].bus_id = 6;
1299     b->i2c_bus[6].sda = 18;
1300     b->i2c_bus[6].scl = 19;
1301
1302     b->spi_bus_count = 1;
1303     b->def_spi_bus = 0;
1304     b->spi_bus[0].bus_id = 5;
1305     b->spi_bus[0].slave_s = 1;
1306     b->spi_bus[0].cs = 10;
1307     b->spi_bus[0].mosi = 11;
1308     b->spi_bus[0].miso = 12;
1309     b->spi_bus[0].sclk = 13;
1310
1311     b->uart_dev_count = 1;
1312     b->def_uart_dev = 0;
1313     b->uart_dev[0].rx = 0;
1314     b->uart_dev[0].tx = 1;
1315
1316     int il;
1317     for (il =0; il < MRAA_INTEL_EDISON_PINCOUNT; il++) {
1318         pinmodes[il].gpio.sysfs = -1;
1319         pinmodes[il].gpio.mode = -1;
1320         pinmodes[il].pwm.sysfs = -1;
1321         pinmodes[il].pwm.mode = -1;
1322         pinmodes[il].i2c.sysfs = -1;
1323         pinmodes[il].i2c.mode = -1;
1324         pinmodes[il].spi.sysfs = -1;
1325         pinmodes[il].spi.mode = -1;
1326         pinmodes[il].uart.sysfs = -1;
1327         pinmodes[il].uart.mode = -1;
1328     }
1329     pinmodes[0].gpio.sysfs = 130;
1330     pinmodes[0].gpio.mode = 0;
1331     pinmodes[0].uart.sysfs = 130;
1332     pinmodes[0].uart.mode = 1;
1333     pinmodes[1].gpio.sysfs = 131;
1334     pinmodes[1].gpio.mode = 0;
1335     pinmodes[1].uart.sysfs = 131;
1336     pinmodes[1].uart.mode = 1;
1337     pinmodes[2].gpio.sysfs = 128;
1338     pinmodes[2].gpio.mode = 0;
1339     pinmodes[2].uart.sysfs = 128;
1340     pinmodes[2].uart.mode = 1;
1341     pinmodes[3].gpio.sysfs = 12;
1342     pinmodes[3].gpio.mode = 0;
1343     pinmodes[3].pwm.sysfs = 12;
1344     pinmodes[3].pwm.mode = 1;
1345
1346     pinmodes[4].gpio.sysfs = 129;
1347     pinmodes[4].gpio.mode = 0;
1348     pinmodes[4].uart.sysfs = 129;
1349     pinmodes[4].uart.mode = 1;
1350     pinmodes[5].gpio.sysfs = 13;
1351     pinmodes[5].gpio.mode = 0;
1352     pinmodes[5].pwm.sysfs = 13;
1353     pinmodes[5].pwm.mode = 1;
1354     pinmodes[6].gpio.sysfs = 182;
1355     pinmodes[6].gpio.mode = 0;
1356     pinmodes[6].pwm.sysfs = 182;
1357     pinmodes[6].pwm.mode = 1;
1358
1359     //7 and 8 are provided by something on i2c, very simplepinmodes[3].gpio.sysfs = 12;
1360     pinmodes[9].gpio.sysfs = 183;
1361     pinmodes[9].gpio.mode = 0;
1362     pinmodes[9].pwm.sysfs = 183;
1363     pinmodes[9].pwm.mode = 1;
1364
1365     pinmodes[10].gpio.sysfs = 41;
1366     pinmodes[10].gpio.mode = 0;
1367     pinmodes[10].spi.sysfs = 111; // Different pin provides, switched at mux level.
1368     pinmodes[10].spi.mode = 1;
1369
1370     pinmodes[11].gpio.sysfs = 43;
1371     pinmodes[11].gpio.mode = 0;
1372     pinmodes[11].spi.sysfs = 115; // Different pin provides, switched at mux level.
1373     pinmodes[11].spi.mode = 1;
1374
1375     pinmodes[12].gpio.sysfs = 42;
1376     pinmodes[12].gpio.mode = 0;
1377     pinmodes[12].spi.sysfs = 114; // Different pin provides, switched at mux level.
1378     pinmodes[12].spi.mode = 1;
1379
1380     pinmodes[13].gpio.sysfs = 40;
1381     pinmodes[13].gpio.mode = 0;
1382     pinmodes[13].spi.sysfs = 109; // Different pin provides, switched at mux level.
1383     pinmodes[13].spi.mode = 1;
1384     //Everything else but A4 A5 LEAVE
1385     pinmodes[18].gpio.sysfs = 14;
1386     pinmodes[18].gpio.mode = 0;
1387     pinmodes[18].i2c.sysfs = 28;
1388     pinmodes[18].i2c.mode = 1;
1389
1390     pinmodes[19].gpio.sysfs = 165;
1391     pinmodes[19].gpio.mode = 0;
1392     pinmodes[19].i2c.sysfs = 27;
1393     pinmodes[19].i2c.mode = 1;
1394
1395     return b;
1396 error:
1397     syslog(LOG_CRIT, "edison: Arduino board failed to initialise");
1398     free(b);
1399     return NULL;
1400 }