src/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
  28 #include "common.h"
  29 #include "intel_edison_fab_c.h"
  30
  31 #define SYSFS_PINMODE_PATH "/sys/kernel/debug/gpio_debug/gpio"
  32 #define MAX_SIZE 64
  33 #define MAX_MODE_SIZE 8
  34
  35 typedef struct {
  36     int sysfs;
  37     int mode;
  38 } mraa_intel_edision_pindef_t;
  39
  40 typedef struct {
  41     mraa_intel_edision_pindef_t gpio;
  42     mraa_intel_edision_pindef_t pwm;
  43     mraa_intel_edision_pindef_t i2c;
  44     mraa_intel_edision_pindef_t spi;
  45     mraa_intel_edision_pindef_t uart;
  46 } mraa_intel_edison_pinmodes_t;
  47
  48 static mraa_gpio_context tristate;
  49
  50 static mraa_intel_edison_pinmodes_t pinmodes[MRAA_INTEL_EDISON_PINCOUNT];
  51 static unsigned int outputen[] = {248,249,250,251,252,253,254,255,256,257,258,259,260,261,232,233,234,235,236,237};
  52 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};
  53
  54 static mraa_result_t
  55 mraa_intel_edison_pinmode_change(int sysfs, int mode)
  56 {
  57     if (mode < 0 ) {
  58         return MRAA_SUCCESS;
  59     }
  60     char buffer[MAX_SIZE];
  61     snprintf(buffer, MAX_SIZE, SYSFS_PINMODE_PATH "%i/current_pinmux",sysfs);
  62     int modef = open(buffer, O_WRONLY);
  63     if (modef == -1) {
  64         fprintf(stderr, "Failed to open SoC pinmode for opening\n");
  65         return MRAA_ERROR_INVALID_RESOURCE;
  66     }
  67
  68     char mode_buf[MAX_MODE_SIZE];
  69     int length = sprintf(mode_buf, "mode%u",mode);
  70     if (write(modef, mode_buf, length*sizeof(char)) == -1) {
  71         return MRAA_ERROR_INVALID_RESOURCE;
  72     }
  73     close(modef);
  74
  75     return MRAA_SUCCESS;
  76 }
  77
  78 mraa_result_t
  79 mraa_intel_edison_gpio_dir_pre(mraa_gpio_context dev, gpio_dir_t dir)
  80 {
  81     mraa_gpio_write(tristate, 0);
  82     if (dev->phy_pin >= 0) {
  83         int pin = dev->phy_pin;
  84
  85         mraa_gpio_context output_e;
  86         output_e = mraa_gpio_init_raw(outputen[pin]);
  87         if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS)
  88             return MRAA_ERROR_INVALID_RESOURCE;
  89         int output_val = 0;
  90         if (dir == MRAA_GPIO_OUT)
  91             output_val = 1;
  92         if (mraa_gpio_write(output_e, output_val) != MRAA_SUCCESS)
  93             return MRAA_ERROR_INVALID_RESOURCE;
  94     }
  95     return MRAA_SUCCESS;
  96 }
  97
  98 mraa_result_t
  99 mraa_intel_edison_gpio_dir_post(mraa_gpio_context dev, gpio_dir_t dir)
 100 {
 101     mraa_gpio_write(tristate, 1);
 102     return MRAA_SUCCESS;
 103 }
 104
 105 mraa_result_t
 106 mraa_intel_edison_gpio_init_post(mraa_gpio_context dev)
 107 {
 108     if (dev == NULL)
 109         return MRAA_ERROR_INVALID_RESOURCE;
 110
 111     int sysfs = pinmodes[dev->phy_pin].gpio.sysfs;
 112     int mode = pinmodes[dev->phy_pin].gpio.mode;
 113     mraa_result_t ret = mraa_intel_edison_pinmode_change(sysfs, mode);
 114
 115     return ret;
 116 }
 117
 118 mraa_result_t
 119 mraa_intel_edison_i2c_init_pre(unsigned int bus)
 120 {
 121     if(bus != 6) {
 122         fprintf(stderr, "Edison: You can use that bus, ERR\n");
 123         return MRAA_ERROR_INVALID_RESOURCE;
 124     }
 125     mraa_gpio_write(tristate, 0);
 126     mraa_gpio_context io18_gpio = mraa_gpio_init_raw(14);
 127     mraa_gpio_context io19_gpio = mraa_gpio_init_raw(165);
 128     mraa_gpio_dir(io18_gpio, MRAA_GPIO_IN);
 129     mraa_gpio_dir(io19_gpio, MRAA_GPIO_IN);
 130     mraa_gpio_close(io18_gpio);
 131     mraa_gpio_close(io19_gpio);
 132
 133     mraa_gpio_context io18_enable = mraa_gpio_init_raw(236);
 134     mraa_gpio_context io19_enable = mraa_gpio_init_raw(237);
 135     mraa_gpio_dir(io18_enable, MRAA_GPIO_OUT);
 136     mraa_gpio_dir(io19_enable, MRAA_GPIO_OUT);
 137     mraa_gpio_write(io18_enable, 0);
 138     mraa_gpio_write(io19_enable, 0);
 139     mraa_gpio_close(io18_enable);
 140     mraa_gpio_close(io19_enable);
 141
 142     mraa_gpio_context io18_pullup = mraa_gpio_init_raw(212);
 143     mraa_gpio_context io19_pullup = mraa_gpio_init_raw(213);
 144     mraa_gpio_dir(io18_pullup, MRAA_GPIO_IN);
 145     mraa_gpio_dir(io19_pullup, MRAA_GPIO_IN);
 146     mraa_gpio_close(io18_pullup);
 147     mraa_gpio_close(io19_pullup);
 148
 149     mraa_intel_edison_pinmode_change(28, 1);
 150     mraa_intel_edison_pinmode_change(27, 1);
 151
 152     mraa_gpio_write(tristate, 1);
 153     return MRAA_SUCCESS;
 154 }
 155
 156 static mraa_result_t
 157 mraa_intel_edison_misc_spi()
 158 {
 159     mraa_gpio_write(tristate, 0);
 160
 161     mraa_gpio_context io10_p1 = mraa_gpio_init_raw(263);
 162     mraa_gpio_context io10_p2 = mraa_gpio_init_raw(240);
 163     mraa_gpio_context io11_p1 = mraa_gpio_init_raw(262);
 164     mraa_gpio_context io11_p2 = mraa_gpio_init_raw(241);
 165     mraa_gpio_context io12_p1 = mraa_gpio_init_raw(242);
 166     mraa_gpio_context io13_p1 = mraa_gpio_init_raw(243);
 167     mraa_gpio_dir(io10_p1, MRAA_GPIO_OUT);
 168     mraa_gpio_dir(io10_p2, MRAA_GPIO_OUT);
 169     mraa_gpio_dir(io11_p1, MRAA_GPIO_OUT);
 170     mraa_gpio_dir(io11_p2, MRAA_GPIO_OUT);
 171     mraa_gpio_dir(io12_p1, MRAA_GPIO_OUT);
 172     mraa_gpio_dir(io13_p1, MRAA_GPIO_OUT);
 173
 174     mraa_gpio_write(io10_p1, 1);
 175     mraa_gpio_write(io10_p2, 0);
 176     mraa_gpio_write(io11_p1, 1);
 177     mraa_gpio_write(io11_p2, 0);
 178     mraa_gpio_write(io12_p1, 0);
 179     mraa_gpio_write(io13_p1, 0);
 180
 181     mraa_gpio_close(io10_p1);
 182     mraa_gpio_close(io10_p2);
 183     mraa_gpio_close(io11_p1);
 184     mraa_gpio_close(io11_p2);
 185     mraa_gpio_close(io12_p1);
 186     mraa_gpio_close(io13_p1);
 187
 188     mraa_intel_edison_pinmode_change(111, 1);
 189     mraa_intel_edison_pinmode_change(115, 1);
 190     mraa_intel_edison_pinmode_change(114, 1);
 191     mraa_intel_edison_pinmode_change(109, 1);
 192     mraa_gpio_write(tristate, 1);
 193
 194     return MRAA_SUCCESS;
 195 }
 196
 197 mraa_result_t
 198 mraa_intel_edison_aio_get_fp(mraa_aio_context dev)
 199 {
 200     char file_path[64]= "";
 201
 202     snprintf(file_path, 64, "/sys/bus/iio/devices/iio:device1/in_voltage%d_raw",
 203         dev->channel );
 204
 205     dev->adc_in_fp = open(file_path, O_RDONLY);
 206     if (dev->adc_in_fp == -1) {
 207     fprintf(stderr, "Failed to open Analog input raw file %s for "
 208         "reading!\n", file_path); return( MRAA_ERROR_INVALID_RESOURCE);
 209     }
 210
 211     return MRAA_SUCCESS;
 212 }
 213
 214 mraa_result_t
 215 mraa_intel_edison_aio_init_pre(unsigned int aio)
 216 {
 217     if (aio > plat->aio_count) {
 218         fprintf(stderr, "Invalid analog input channel\n");
 219         return MRAA_ERROR_INVALID_RESOURCE;
 220     }
 221
 222     int pin = 14 + aio;
 223     mraa_gpio_context output_e;
 224     output_e = mraa_gpio_init_raw(outputen[pin]);
 225     if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS)
 226         return MRAA_ERROR_INVALID_RESOURCE;
 227     if (mraa_gpio_write(output_e, 0) != MRAA_SUCCESS)
 228         return MRAA_ERROR_INVALID_RESOURCE;
 229     mraa_gpio_close(output_e);
 230
 231     mraa_gpio_context pullup_pin;
 232     pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
 233     if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS)
 234         return MRAA_ERROR_INVALID_RESOURCE;
 235     mraa_gpio_close(pullup_pin);
 236
 237     return MRAA_SUCCESS;
 238 }
 239
 240 mraa_result_t
 241 mraa_intel_edison_aio_init_post(mraa_aio_context dev)
 242 {
 243     mraa_gpio_write(tristate, 1);
 244     return MRAA_SUCCESS;
 245 }
 246
 247 mraa_result_t
 248 mraa_intel_edison_pwm_init_pre(int pin)
 249 {
 250     if (pin < 0 || pin > 19)
 251         return MRAA_ERROR_INVALID_RESOURCE;
 252
 253     if (!plat->pins[pin].capabilites.pwm)
 254         return MRAA_ERROR_INVALID_RESOURCE;
 255
 256     mraa_gpio_context output_e;
 257     output_e = mraa_gpio_init_raw(outputen[pin]);
 258     if (mraa_gpio_dir(output_e, MRAA_GPIO_OUT) != MRAA_SUCCESS)
 259         return MRAA_ERROR_INVALID_RESOURCE;
 260     if (mraa_gpio_write(output_e, 1) != MRAA_SUCCESS)
 261         return MRAA_ERROR_INVALID_RESOURCE;
 262     mraa_gpio_close(output_e);
 263
 264     mraa_gpio_context pullup_pin;
 265     pullup_pin = mraa_gpio_init_raw(pullup_map[pin]);
 266     if (mraa_gpio_dir(pullup_pin, MRAA_GPIO_IN) != MRAA_SUCCESS)
 267         return MRAA_ERROR_INVALID_RESOURCE;
 268     mraa_gpio_close(pullup_pin);
 269     mraa_intel_edison_pinmode_change(plat->pins[pin].gpio.pinmap, 1);
 270
 271     return MRAA_SUCCESS;
 272 }
 273
 274 mraa_result_t
 275 mraa_intel_edison_pwm_init_post(mraa_pwm_context pwm)
 276 {
 277     mraa_gpio_write(tristate, 1);
 278     return MRAA_SUCCESS;
 279 }
 280
 281 mraa_result_t
 282 mraa_intel_edison_spi_init_pre(int bus)
 283 {
 284     mraa_gpio_write(tristate, 0);
 285
 286     mraa_gpio_context io10_out = mraa_gpio_init_raw(258);
 287     mraa_gpio_context io11_out = mraa_gpio_init_raw(259);
 288     mraa_gpio_context io12_out = mraa_gpio_init_raw(260);
 289     mraa_gpio_context io13_out = mraa_gpio_init_raw(261);
 290     mraa_gpio_dir(io10_out, MRAA_GPIO_OUT);
 291     mraa_gpio_dir(io11_out, MRAA_GPIO_OUT);
 292     mraa_gpio_dir(io12_out, MRAA_GPIO_OUT);
 293     mraa_gpio_dir(io13_out, MRAA_GPIO_OUT);
 294
 295     mraa_gpio_write(io10_out, 1);
 296     mraa_gpio_write(io11_out, 1);
 297     mraa_gpio_write(io12_out, 0);
 298     mraa_gpio_write(io13_out, 1);
 299
 300     mraa_gpio_close(io10_out);
 301     mraa_gpio_close(io11_out);
 302     mraa_gpio_close(io12_out);
 303     mraa_gpio_close(io13_out);
 304
 305     mraa_gpio_context io10_pull = mraa_gpio_init_raw(226);
 306     mraa_gpio_context io11_pull = mraa_gpio_init_raw(227);
 307     mraa_gpio_context io12_pull = mraa_gpio_init_raw(228);
 308     mraa_gpio_context io13_pull = mraa_gpio_init_raw(229);
 309
 310     mraa_gpio_dir(io10_pull, MRAA_GPIO_IN);
 311     mraa_gpio_dir(io11_pull, MRAA_GPIO_IN);
 312     mraa_gpio_dir(io12_pull, MRAA_GPIO_IN);
 313     mraa_gpio_dir(io13_pull, MRAA_GPIO_IN);
 314
 315     mraa_gpio_close(io10_pull);
 316     mraa_gpio_close(io11_pull);
 317     mraa_gpio_close(io12_pull);
 318     mraa_gpio_close(io13_pull);
 319
 320     return MRAA_SUCCESS;
 321 }
 322
 323 mraa_result_t
 324 mraa_intel_edison_spi_init_post(mraa_spi_context spi)
 325 {
 326     mraa_gpio_write(tristate, 1);
 327     return MRAA_SUCCESS;
 328 }
 329
 330 mraa_board_t*
 331 mraa_intel_edison_fab_c()
 332 {
 333     mraa_board_t* b = (mraa_board_t*) malloc(sizeof(mraa_board_t));
 334     if (b == NULL)
 335         return NULL;
 336
 337     b->phy_pin_count = 20;
 338     b->gpio_count = 14;
 339     b->aio_count = 6;
 340
 341     advance_func->gpio_dir_pre = &mraa_intel_edison_gpio_dir_pre;
 342     advance_func->gpio_init_post = &mraa_intel_edison_gpio_init_post;
 343     advance_func->gpio_dir_post = &mraa_intel_edison_gpio_dir_post;
 344     advance_func->i2c_init_pre = &mraa_intel_edison_i2c_init_pre;
 345     advance_func->aio_get_valid_fp = &mraa_intel_edison_aio_get_fp;
 346     advance_func->aio_init_pre = &mraa_intel_edison_aio_init_pre;
 347     advance_func->aio_init_post = &mraa_intel_edison_aio_init_post;
 348     advance_func->pwm_init_pre = &mraa_intel_edison_pwm_init_pre;
 349     advance_func->pwm_init_post = &mraa_intel_edison_pwm_init_post;
 350     advance_func->spi_init_pre = &mraa_intel_edison_spi_init_pre;
 351     advance_func->spi_init_post = &mraa_intel_edison_spi_init_post;
 352
 353     b->pins = (mraa_pininfo_t*) malloc(sizeof(mraa_pininfo_t)*MRAA_INTEL_EDISON_PINCOUNT);
 354
 355     tristate = mraa_gpio_init_raw(214);
 356     if (tristate == NULL) {
 357         fprintf(stderr, "Intel Edison Failed to initialise Arduino board TriState,\
 358                          check i2c devices! FATAL\n");
 359         return NULL;
 360     }
 361     mraa_gpio_dir(tristate, MRAA_GPIO_OUT);
 362     mraa_intel_edison_misc_spi();
 363
 364     strncpy(b->pins[0].name, "IO0", 8);
 365     b->pins[0].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 366     b->pins[0].gpio.pinmap = 130;
 367     b->pins[0].gpio.parent_id = 0;
 368     b->pins[0].gpio.mux_total = 0;
 369
 370     strncpy(b->pins[1].name, "IO1", 8);
 371     b->pins[1].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 372     b->pins[1].gpio.pinmap = 131;
 373     b->pins[1].gpio.parent_id = 0;
 374     b->pins[1].gpio.mux_total = 0;
 375
 376     strncpy(b->pins[2].name, "IO2", 8);
 377     b->pins[2].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 378     b->pins[2].gpio.pinmap = 128;
 379     b->pins[2].gpio.parent_id = 0;
 380     b->pins[2].gpio.mux_total = 0;
 381
 382     strncpy(b->pins[3].name, "IO3", 8);
 383     b->pins[3].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0};
 384     b->pins[3].gpio.pinmap = 12;
 385     b->pins[3].gpio.parent_id = 0;
 386     b->pins[3].gpio.mux_total = 0;
 387     b->pins[3].pwm.pinmap = 0;
 388     b->pins[3].pwm.parent_id = 0;
 389     b->pins[3].pwm.mux_total = 0;
 390
 391     strncpy(b->pins[4].name, "IO4", 8);
 392     b->pins[4].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 393     b->pins[4].gpio.pinmap = 129;
 394     b->pins[4].gpio.parent_id = 0;
 395     b->pins[4].gpio.mux_total = 0;
 396
 397     strncpy(b->pins[5].name, "IO5", 8);
 398     b->pins[5].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
 399     b->pins[5].gpio.pinmap = 13;
 400     b->pins[5].gpio.parent_id = 0;
 401     b->pins[5].gpio.mux_total = 0;
 402     b->pins[5].pwm.pinmap = 1;
 403     b->pins[5].pwm.parent_id = 0;
 404     b->pins[5].pwm.mux_total = 0;
 405
 406     strncpy(b->pins[6].name, "IO6", 8);
 407     b->pins[6].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
 408     b->pins[6].gpio.pinmap = 182;
 409     b->pins[6].gpio.parent_id = 0;
 410     b->pins[6].gpio.mux_total = 0;
 411     b->pins[6].pwm.pinmap = 2;
 412     b->pins[6].pwm.parent_id = 0;
 413     b->pins[6].pwm.mux_total = 0;
 414
 415     strncpy(b->pins[7].name, "IO7", 8);
 416     b->pins[7].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 417     b->pins[7].gpio.pinmap = 48;
 418     b->pins[7].gpio.parent_id = 0;
 419     b->pins[7].gpio.mux_total = 0;
 420
 421     strncpy(b->pins[8].name, "IO8", 8);
 422     b->pins[8].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,0};
 423     b->pins[8].gpio.pinmap = 49;
 424     b->pins[8].gpio.parent_id = 0;
 425     b->pins[8].gpio.mux_total = 0;
 426
 427     strncpy(b->pins[9].name, "IO9", 8);
 428     b->pins[9].capabilites = (mraa_pincapabilities_t) {1,1,1,0,0,0,0,0};
 429     b->pins[9].gpio.pinmap = 183;
 430     b->pins[9].gpio.parent_id = 0;
 431     b->pins[9].gpio.mux_total = 0;
 432     b->pins[9].pwm.pinmap = 3;
 433     b->pins[9].pwm.parent_id = 0;
 434     b->pins[9].pwm.mux_total = 0;
 435
 436     strncpy(b->pins[10].name, "IO10", 8);
 437     b->pins[10].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 438     b->pins[10].gpio.pinmap = 41;
 439     b->pins[10].gpio.parent_id = 0;
 440     b->pins[10].gpio.mux_total = 2;
 441     b->pins[10].gpio.mux[0].pin = 263;
 442     b->pins[10].gpio.mux[0].value = 1;
 443     b->pins[10].gpio.mux[1].pin = 240;
 444     b->pins[10].gpio.mux[1].value = 0;
 445     b->pins[10].spi.pinmap = 5;
 446     b->pins[10].spi.mux_total = 2;
 447     b->pins[10].spi.mux[0].pin = 263;
 448     b->pins[10].spi.mux[0].value = 1;
 449     b->pins[10].spi.mux[1].pin = 240;
 450     b->pins[10].spi.mux[1].value = 1;
 451
 452     strncpy(b->pins[11].name, "IO11", 8);
 453     b->pins[11].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 454     b->pins[11].gpio.pinmap = 43;
 455     b->pins[11].gpio.parent_id = 0;
 456     b->pins[11].gpio.mux_total = 2;
 457     b->pins[11].gpio.mux[0].pin = 262;
 458     b->pins[11].gpio.mux[0].value = 1;
 459     b->pins[11].gpio.mux[1].pin = 241;
 460     b->pins[11].gpio.mux[1].value = 0;
 461     b->pins[11].spi.pinmap = 5;
 462     b->pins[11].spi.mux_total = 2;
 463     b->pins[11].spi.mux[0].pin = 262;
 464     b->pins[11].spi.mux[0].value = 1;
 465     b->pins[11].spi.mux[1].pin = 241;
 466     b->pins[11].spi.mux[1].value = 1;
 467
 468     strncpy(b->pins[12].name, "IO12", 8);
 469     b->pins[12].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 470     b->pins[12].gpio.pinmap = 42;
 471     b->pins[12].gpio.parent_id = 0;
 472     b->pins[12].gpio.mux_total = 1;
 473     b->pins[12].gpio.mux[0].pin = 242;
 474     b->pins[12].gpio.mux[0].value = 0;
 475     b->pins[12].spi.pinmap = 5;
 476     b->pins[12].spi.mux_total = 1;
 477     b->pins[12].spi.mux[0].pin = 242;
 478     b->pins[12].spi.mux[0].value = 1;
 479
 480     strncpy(b->pins[13].name, "IO13", 8);
 481     b->pins[13].capabilites = (mraa_pincapabilities_t) {1,1,0,0,1,0,0,0};
 482     b->pins[13].gpio.pinmap = 40;
 483     b->pins[13].gpio.parent_id = 0;
 484     b->pins[13].gpio.mux_total = 1;
 485     b->pins[13].gpio.mux[0].pin = 243;
 486     b->pins[13].gpio.mux[0].value = 0;
 487     b->pins[13].spi.pinmap = 5;
 488     b->pins[13].spi.mux_total = 1;
 489     b->pins[13].spi.mux[0].pin = 243;
 490     b->pins[13].spi.mux[0].value = 1;
 491
 492     strncpy(b->pins[14].name, "A0", 8);
 493     b->pins[14].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
 494     b->pins[14].aio.pinmap = 0;
 495     b->pins[14].aio.mux_total = 1;
 496     b->pins[14].aio.mux[0].pin = 200;
 497     b->pins[14].aio.mux[0].value = 1;
 498     b->pins[14].gpio.pinmap = 44;
 499     b->pins[14].gpio.mux_total = 1;
 500     b->pins[14].gpio.mux[0].pin = 200;
 501     b->pins[14].gpio.mux[0].value = 0;
 502
 503     strncpy(b->pins[15].name, "A1", 8);
 504     b->pins[15].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
 505     b->pins[15].aio.pinmap = 1;
 506     b->pins[15].aio.mux_total = 1;
 507     b->pins[15].aio.mux[0].pin = 201;
 508     b->pins[15].aio.mux[0].value = 1;
 509     b->pins[15].gpio.pinmap = 45;
 510     b->pins[15].gpio.mux_total = 1;
 511     b->pins[15].gpio.mux[0].pin = 201;
 512     b->pins[15].gpio.mux[0].value = 0;
 513
 514     strncpy(b->pins[16].name, "A2", 8);
 515     b->pins[16].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
 516     b->pins[16].aio.pinmap = 2;
 517     b->pins[16].aio.mux_total = 1;
 518     b->pins[16].aio.mux[0].pin = 202;
 519     b->pins[16].aio.mux[0].value = 1;
 520     b->pins[16].gpio.pinmap = 46;
 521     b->pins[16].gpio.mux_total = 1;
 522     b->pins[16].gpio.mux[0].pin = 202;
 523     b->pins[16].gpio.mux[0].value = 0;
 524
 525     strncpy(b->pins[17].name, "A3", 8);
 526     b->pins[17].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,0,1,0};
 527     b->pins[17].aio.pinmap = 3;
 528     b->pins[17].aio.mux_total = 1;
 529     b->pins[17].aio.mux[0].pin = 203;
 530     b->pins[17].aio.mux[0].value = 1;
 531     b->pins[17].gpio.pinmap = 47;
 532     b->pins[17].gpio.mux_total = 1;
 533     b->pins[17].gpio.mux[0].pin = 203;
 534     b->pins[17].gpio.mux[0].value = 0;
 535
 536     strncpy(b->pins[18].name, "A4", 8);
 537     b->pins[18].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,1,0};
 538     b->pins[18].i2c.pinmap = 1;
 539     b->pins[18].i2c.mux_total = 1;
 540     b->pins[18].i2c.mux[0].pin = 204;
 541     b->pins[18].i2c.mux[0].value = 0;
 542     b->pins[18].aio.pinmap = 4;
 543     b->pins[18].aio.mux_total = 1;
 544     b->pins[18].aio.mux[0].pin = 204;
 545     b->pins[18].aio.mux[0].value = 1;
 546     b->pins[18].gpio.pinmap = 14;
 547     b->pins[18].gpio.mux_total = 1;
 548     b->pins[18].gpio.mux[0].pin = 204;
 549     b->pins[18].gpio.mux[0].value = 0;
 550
 551     strncpy(b->pins[19].name, "A5", 8);
 552     b->pins[19].capabilites = (mraa_pincapabilities_t) {1,1,0,0,0,1,1,0};
 553     b->pins[19].i2c.pinmap = 1;
 554     b->pins[19].i2c.mux_total = 1;
 555     b->pins[19].i2c.mux[0].pin = 205;
 556     b->pins[19].i2c.mux[0].value = 0;
 557     b->pins[19].aio.pinmap = 5;
 558     b->pins[19].aio.mux_total = 1;
 559     b->pins[19].aio.mux[0].pin = 205;
 560     b->pins[19].aio.mux[0].value = 1;
 561     b->pins[19].gpio.pinmap = 165;
 562     b->pins[19].gpio.mux_total = 1;
 563     b->pins[19].gpio.mux[0].pin = 205;
 564     b->pins[19].gpio.mux[0].value = 0;
 565
 566     //BUS DEFINITIONS
 567     b->i2c_bus_count = 9;
 568     b->def_i2c_bus = 6;
 569     int ici;
 570     for (ici = 0; ici < 9; ici++) {
 571         b->i2c_bus[ici].bus_id = -1;
 572     }
 573     b->i2c_bus[6].bus_id = 6;
 574     b->i2c_bus[6].sda = 18;
 575     b->i2c_bus[6].scl = 19;
 576
 577     b->spi_bus_count = 1;
 578     b->def_spi_bus = 0;
 579     b->spi_bus[0].bus_id = 5;
 580     b->spi_bus[0].slave_s = 1;
 581     b->spi_bus[0].cs = 10;
 582     b->spi_bus[0].mosi = 11;
 583     b->spi_bus[0].miso = 12;
 584     b->spi_bus[0].sclk = 13;
 585
 586     int il;
 587
 588     for(il =0; il < MRAA_INTEL_EDISON_PINCOUNT; il++) {
 589         pinmodes[il].gpio.sysfs = -1;
 590         pinmodes[il].gpio.mode = -1;
 591         pinmodes[il].pwm.sysfs = -1;
 592         pinmodes[il].pwm.mode = -1;
 593         pinmodes[il].i2c.sysfs = -1;
 594         pinmodes[il].i2c.mode = -1;
 595         pinmodes[il].spi.sysfs = -1;
 596         pinmodes[il].spi.mode = -1;
 597         pinmodes[il].uart.sysfs = -1;
 598         pinmodes[il].uart.mode = -1;
 599     }
 600     pinmodes[0].gpio.sysfs = 130;
 601     pinmodes[0].gpio.mode = 0;
 602     pinmodes[0].uart.sysfs = 130;
 603     pinmodes[0].uart.mode = 1;
 604     pinmodes[1].gpio.sysfs = 131;
 605     pinmodes[1].gpio.mode = 0;
 606     pinmodes[1].uart.sysfs = 131;
 607     pinmodes[1].uart.mode = 1;
 608     pinmodes[2].gpio.sysfs = 128;
 609     pinmodes[2].gpio.mode = 0;
 610     pinmodes[2].uart.sysfs = 128;
 611     pinmodes[2].uart.mode = 1;
 612     pinmodes[3].gpio.sysfs = 12;
 613     pinmodes[3].gpio.mode = 0;
 614     pinmodes[3].pwm.sysfs = 12;
 615     pinmodes[3].pwm.mode = 1;
 616
 617     pinmodes[4].gpio.sysfs = 129;
 618     pinmodes[4].gpio.mode = 0;
 619     pinmodes[4].uart.sysfs = 129;
 620     pinmodes[4].uart.mode = 1;
 621     pinmodes[5].gpio.sysfs = 13;
 622     pinmodes[5].gpio.mode = 0;
 623     pinmodes[5].pwm.sysfs = 13;
 624     pinmodes[5].pwm.mode = 1;
 625     pinmodes[6].gpio.sysfs = 182;
 626     pinmodes[6].gpio.mode = 0;
 627     pinmodes[6].pwm.sysfs = 182;
 628     pinmodes[6].pwm.mode = 1;
 629
 630     //7 and 8 are provided by something on i2c, very simplepinmodes[3].gpio.sysfs = 12;
 631     pinmodes[9].gpio.sysfs = 183;
 632     pinmodes[9].gpio.mode = 0;
 633     pinmodes[9].pwm.sysfs = 183;
 634     pinmodes[9].pwm.mode = 1;
 635
 636     pinmodes[10].gpio.sysfs = 41;
 637     pinmodes[10].gpio.mode = 0;
 638     pinmodes[10].spi.sysfs = 111; // Different pin provides, switched at mux level.
 639     pinmodes[10].spi.mode = 1;
 640
 641     pinmodes[11].gpio.sysfs = 43;
 642     pinmodes[11].gpio.mode = 0;
 643     pinmodes[11].spi.sysfs = 115; // Different pin provides, switched at mux level.
 644     pinmodes[11].spi.mode = 1;
 645
 646     pinmodes[12].gpio.sysfs = 42;
 647     pinmodes[12].gpio.mode = 0;
 648     pinmodes[12].spi.sysfs = 114; // Different pin provides, switched at mux level.
 649     pinmodes[12].spi.mode = 1;
 650
 651     pinmodes[13].gpio.sysfs = 40;
 652     pinmodes[13].gpio.mode = 0;
 653     pinmodes[13].spi.sysfs = 109; // Different pin provides, switched at mux level.
 654     pinmodes[13].spi.mode = 1;
 655     //Everything else but A4 A5 LEAVE
 656     pinmodes[18].gpio.sysfs = 14;
 657     pinmodes[18].gpio.mode = 0;
 658     pinmodes[18].i2c.sysfs = 28;
 659     pinmodes[18].i2c.mode = 1;
 660
 661     pinmodes[19].gpio.sysfs = 165;
 662     pinmodes[19].gpio.mode = 0;
 663     pinmodes[19].i2c.sysfs = 27;
 664     pinmodes[19].i2c.mode = 1;
 665
 666     return b;
 667 }