Patrick
/
Nife_v0
1
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
Nife version Beta
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
7 Commity
1 Gałąź
566 KiB
 
 
 
 
Drzewo: e27194ff7e
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z 'e27194ff7e'
${ noResults }
Nife_v0/src/i2c.c

375 wiersze
12 KiB
Czysty Wina Historia 

  1. /* Copyright (C) 2011-2014  Patrick H. E. Foubet - S.E.R.I.A.N.E.

  2. 

  3. This program is free software: you can redistribute it and/or modify

  4. it under the terms of the GNU General Public License as published by

  5. the Free Software Foundation, either version 3 of the License, or any

  6. later version.

  7. 

  8. This program is distributed in the hope that it will be useful,

  9. but WITHOUT ANY WARRANTY; without even the implied warranty of

  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11. GNU General Public License for more details.

  12. 

  13. You should have received a copy of the GNU General Public License

  14. along with this program.  If not, see <http://www.gnu.org/licenses/>

  15. *******************************************************************/

  16. /* i2c.c */

  17. 

  18. #ifdef HAVE_CONFIG_H

  19. #include "../config.h"

  20. #endif

  21. 

  22. #ifdef HAVE_LINUX_I2C_DEV_H

  23. #include <linux/i2c-dev.h>

  24. #ifdef I2C_FUNC_I2C

  25. #define _WITH_I2C

  26. #endif

  27. #endif

  28. 

  29. #include <stdio.h>

  30. #include <stdlib.h>

  31. #include <string.h>

  32. 

  33. #ifdef _WITH_I2C

  34. /*

  35.     This part is a merge of Linux i2c-tools code and Nife code.

  36.     i2c-tools are user-space programs to detect, scan I2C devices, 

  37.     and read and/or write an I2C register.

  38.     Copyright (C) 2005-2012  Jean Delvare <jdelvare@suse.de>

  39. 

  40.     Copyright (C) 2001-2003  Frodo Looijaard <frodol@dds.nl>, and

  41.                              Mark D. Studebaker <mdsxyz123@yahoo.com>

  42.     Copyright (C) 2004-2005  Jean Delvare

  43. 

  44.     This program is free software; you can redistribute it and/or modify

  45.     it under the terms of the GNU General Public License as published by

  46.     the Free Software Foundation; either version 2 of the License, or

  47.     (at your option) any later version.

  48. 

  49.     This program is distributed in the hope that it will be useful,

  50.     but WITHOUT ANY WARRANTY; without even the implied warranty of

  51.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  52.     GNU General Public License for more details.

  53. */

  54. #include "i2cbusses.c"  /* add code for I2C on Linux */

  55. 

  56. #define MODE_AUTO       0

  57. #define MODE_QUICK      1

  58. #define MODE_READ       2

  59. #define MODE_FUNC       3

  60. 

  61. /*

  62.  * Print the installed i2c busses. The format is those of Linux 2.4's

  63.  * /proc/bus/i2c for historical compatibility reasons.

  64.  */

  65. static void print_i2c_busses(void)

  66. {

  67.         struct i2c_adap *adapters;

  68.         int count;

  69. 

  70.         adapters = gather_i2c_busses();

  71.         if (adapters == NULL) {

  72.                 fprintf(stderr, "Error: Out of memory!\n");

  73.                 return;

  74.         }

  75.         printf("i2c-id\tfunction  \tadapter name\t\t\t\talgorithm\n");

  76.         for (count = 0; adapters[count].name; count++) {

  77.                 printf("%d\t%-10s\t%-32s\t%s\n",

  78.                         adapters[count].nr, adapters[count].funcs,

  79.                         adapters[count].name, adapters[count].algo);

  80.         }

  81.         free_adapters(adapters);

  82. }

  83. 

  84. static int scan_i2c_bus(int file, int mode, int first, int last)

  85. {

  86. int i, j;

  87. int res;

  88.         printf("     0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\n");

  89.         for (i = 0; i < 128; i += 16) {

  90.                 printf("%02x: ", i);

  91.                 for(j = 0; j < 16; j++) {

  92.                         fflush(stdout);

  93. 

  94.                         /* Skip unwanted addresses */

  95.                         if (i+j < first || i+j > last) {

  96.                                 printf("   ");

  97.                                 continue;

  98.                         }

  99. 

  100.                         /* Set slave address */

  101.                         if (ioctl(file, I2C_SLAVE, i+j) < 0) {

  102.                                 if (errno == EBUSY) {

  103.                                         printf("UU ");

  104.                                         continue;

  105.                                 } else {

  106.                                         fprintf(stderr, "Error: Could not set "

  107.                                                 "address to 0x%02x: %s\n", i+j,

  108.                                                 strerror(errno));

  109.                                         return -1;

  110.                                 }

  111.                         }

  112. 

  113.                         /* Probe this address */

  114.                         switch (mode) {

  115.                         case MODE_QUICK:

  116.                                 /* This is known to corrupt the Atmel AT24RF08

  117.                                    EEPROM */

  118.                                 res = i2c_smbus_write_quick(file,

  119.                                       I2C_SMBUS_WRITE);

  120.                                 break;

  121.                         case MODE_READ:

  122.                                 /* This is known to lock SMBus on various

  123.                                    write-only chips (mainly clock chips) */

  124.                                 res = i2c_smbus_read_byte(file);

  125.                                 break;

  126.                         default:

  127.                                 if ((i+j >= 0x30 && i+j <= 0x37)

  128.                                  || (i+j >= 0x50 && i+j <= 0x5F))

  129.                                         res = i2c_smbus_read_byte(file);

  130.                                 else

  131.                                         res = i2c_smbus_write_quick(file,

  132.                                               I2C_SMBUS_WRITE);

  133.                         }

  134.                         if (res < 0)

  135.                                 printf("-- ");

  136.                         else

  137.                                 printf("%02x ", i+j);

  138.                 }

  139.                 printf("\n");

  140.         }

  141.         return 0;

  142. }

  143. 

  144. static int check_write_funcs(int file, int size, int pec)

  145. {

  146. unsigned long funcs;

  147.         /* check adapter functionality */

  148.         if (ioctl(file, I2C_FUNCS, &funcs) < 0) {

  149.                 fprintf(stderr, "Error: Could not get the adapter "

  150.                         "functionality matrix: %s\n", strerror(errno));

  151.                 return -1;

  152.         }

  153.         switch (size) {

  154.         case I2C_SMBUS_BYTE:

  155.                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE)) {

  156.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus send byte");

  157.                         return -1;

  158.                 }

  159.                 break;

  160.         case I2C_SMBUS_BYTE_DATA:

  161.                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BYTE_DATA)) {

  162.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus write byte");

  163.                         return -1;

  164.                 }

  165.                 break;

  166.         case I2C_SMBUS_WORD_DATA:

  167.                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_WORD_DATA)) {

  168.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus write word");

  169.                         return -1;

  170.                 }

  171.                 break;

  172.         case I2C_SMBUS_BLOCK_DATA:

  173.                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_BLOCK_DATA)) {

  174.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus block write");

  175.                         return -1;

  176.                 }

  177.                 break;

  178.         case I2C_SMBUS_I2C_BLOCK_DATA:

  179.                 if (!(funcs & I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {

  180.                         fprintf(stderr, MISSING_FUNC_FMT, "I2C block write");

  181.                         return -1;

  182.                 }

  183.                 break;

  184.         }

  185.         if (pec && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C))) {

  186.                 fprintf(stderr, "Warning: Adapter does "

  187.                         "not seem to support PEC\n");

  188.         }

  189.         return 0;

  190. }

  191. 

  192. static int check_read_funcs(int file, int size, int daddress, int pec)

  193. {

  194. unsigned long funcs;

  195.         /* check adapter functionality */

  196.         if (ioctl(file, I2C_FUNCS, &funcs) < 0) {

  197.                 fprintf(stderr, "Error: Could not get the adapter "

  198.                         "functionality matrix: %s\n", strerror(errno));

  199.                 return -1;

  200.         }

  201.         switch (size) {

  202.         case I2C_SMBUS_BYTE:

  203.                 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE)) {

  204.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus receive byte");

  205.                         return -1;

  206.                 }

  207.                 if (daddress >= 0

  208.                  && !(funcs & I2C_FUNC_SMBUS_WRITE_BYTE)) {

  209.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus send byte");

  210.                         return -1;

  211.                 }

  212.                 break;

  213.         case I2C_SMBUS_BYTE_DATA:

  214.                 if (!(funcs & I2C_FUNC_SMBUS_READ_BYTE_DATA)) {

  215.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus read byte");

  216.                         return -1;

  217.                 }

  218.                 break;

  219.         case I2C_SMBUS_WORD_DATA:

  220.                 if (!(funcs & I2C_FUNC_SMBUS_READ_WORD_DATA)) {

  221.                         fprintf(stderr, MISSING_FUNC_FMT, "SMBus read word");

  222.                         return -1;

  223.                 }

  224.                 break;

  225.         }

  226.         if (pec

  227.          && !(funcs & (I2C_FUNC_SMBUS_PEC | I2C_FUNC_I2C))) {

  228.                 fprintf(stderr, "Warning: Adapter does "

  229.                         "not seem to support PEC\n");

  230.         }

  231.         return 0;

  232. }

  233. 

  234. #endif  /* for _WITH_I2C */

  235. /* *********************************************************************/

  236. 

  237. #include "stackN.h"

  238. #include "i2c.h"

  239. #include "err.h"

  240. 

  241. void IF_listI2C (void)

  242. {

  243. #ifdef _WITH_I2C

  244.     print_i2c_busses();

  245. #else

  246.     messErr(49);

  247. #endif

  248. }

  249. 

  250. void IF_showI2C (void)

  251. {

  252. long n;

  253.     if (!getParLong(&n)) return;

  254. 

  255. #ifdef _WITH_I2C

  256. int i2cbus, file;

  257. int mode=MODE_AUTO;

  258. int first = 0x03, last = 0x77;

  259. unsigned long funcs;

  260. char Bus[10], filename[20];

  261.      sprintf(Bus, "%ld",n);

  262.      i2cbus = lookup_i2c_bus(Bus);

  263.      if (i2cbus < 0) messErr(50);

  264.      else {

  265.         file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);

  266.         if (file < 0) messErr(51);

  267.         else {

  268.            if (ioctl(file, I2C_FUNCS, &funcs) < 0)  messErr(52);

  269.            else scan_i2c_bus(file, mode, first, last);

  270.            close(file);

  271.         }

  272.      }

  273. #else

  274.      messErr(49);

  275. #endif

  276. }

  277. 

  278. static void i2c_read(int id, int add, int off)

  279. {

  280. #ifdef _WITH_I2C

  281. int i2cbus, file, address, res;

  282. int size = I2C_SMBUS_BYTE_DATA;

  283. int pec = 0,force = 0;

  284. char Buf[10], filename[20];

  285.      sprintf(Buf, "%ld",id);

  286.      i2cbus = lookup_i2c_bus(Buf);

  287.      if (i2cbus < 0) messErr(50);

  288.      else {

  289.         sprintf(Buf, "%ld",add);

  290.         address = parse_i2c_address(Buf);

  291.         if (address < 0) messErr(53);

  292.         else {

  293.             if (off == -1) size = I2C_SMBUS_BYTE;

  294.             if (off < -1 || off > 0xff) messErr(54);

  295.             else {

  296.                file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);

  297.                if (file < 0

  298.                    || check_read_funcs(file, size, off, pec)

  299.                    || set_slave_addr(file, address, force)) messErr(51);

  300.                else {

  301.                   if (size == I2C_SMBUS_BYTE)

  302.                      res = i2c_smbus_read_byte(file);

  303.                   else

  304.                      res = i2c_smbus_read_byte_data(file, off);

  305.                   close(file);

  306.                   if (res < 0) messErr(57);

  307.                   else putLong((long long)res);

  308.                }

  309.             }

  310.         }

  311.      }

  312. #else

  313.     messErr(49);

  314. #endif

  315. }

  316. 

  317. void IF_I2CRead (void)

  318. {

  319. long id, add, off;

  320.     if (!getParLong(&id)) return;  /* I2C ID */

  321.     if (!getParLong(&add)) return; /* CHIP ADDRESS */

  322.     if (!getParLong(&off)) return; /* DATA ADDRESS (OFFSET) */

  323.     i2c_read(id, add, off);

  324. }

  325. 

  326. static void i2c_write(int id, int add, int off, int val)

  327. {

  328. #ifdef _WITH_I2C

  329. int i2cbus, file, address, res;

  330. int size = I2C_SMBUS_BYTE_DATA;

  331. int pec = 0,force = 0;

  332. char Buf[10], filename[20];

  333.      sprintf(Buf, "%ld",id);

  334.      i2cbus = lookup_i2c_bus(Buf);

  335.      if (i2cbus < 0) messErr(50);

  336.      else {

  337.         sprintf(Buf, "%ld",add);

  338.         address = parse_i2c_address(Buf);

  339.         if (address < 0) messErr(53);

  340.         else {

  341.             if (off < 0 || off > 0xff) messErr(54);

  342.             else {

  343.                if (val > 0xff) messErr(55);

  344.                else {

  345.                   file = open_i2c_dev(i2cbus, filename, sizeof(filename), 0);

  346.                   if (file < 0

  347.                       || check_write_funcs(file, size, pec)

  348.                       || set_slave_addr(file, address, force)) messErr(51);

  349.                   else {

  350.                      res = i2c_smbus_write_byte_data(file, off, val);

  351.                      close(file);

  352.                      if (res < 0) messErr(56);

  353.                   }

  354.                }

  355.             }

  356.         }

  357.      }

  358. #else

  359.     messErr(49);

  360. #endif

  361. }

  362. 

  363. void IF_I2CWrite (void)

  364. {

  365. long id, add, off, val;

  366.     if (!getParLong(&id)) return;  /* I2C ID */

  367.     if (!getParLong(&add)) return; /* CHIP ADDRESS */

  368.     if (!getParLong(&off)) return; /* DATA ADDRESS (OFFSET) */

  369.     if (!getParLong(&val)) return; /* DATA BYTE */

  370.     i2c_write(id, add, off, val);

  371.     return;

  372. }

  373.