heuzef
/
WiringPi
zrcadlo https://github.com/WiringPi/WiringPi.git
1
0
Rozštěpit 0
Zdrojový kód Úkoly 0 Vydání 9 Wiki Aktivita
Nelze vybrat více než 25 témat Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
159 Revize
10 Větve
53 MiB
 
 
 
 
 
Strom: 101320eddb
Větve Značky
${ item.name }
Vytvořit větev ${ searchTerm }
z „101320eddb“
${ noResults }
WiringPi/wiringPi/khadas_vim1.c

595 řádky
19 KiB
Surový Blame Historie 

  1. /************************************************************************************/

  2. /*																					*/

  3. /* 				WiringPi KHADAS VIM1 Board control file								*/

  4. /*																					*/

  5. /************************************************************************************/

  6. 

  7. /*----------------------------------------------------------------------------------*/

  8. #include <stdio.h>

  9. #include <stdlib.h>

  10. #include <stdint.h>

  11. #include <unistd.h>

  12. #include <string.h>

  13. #include <errno.h>

  14. #include <fcntl.h>

  15. #include <sys/ioctl.h>

  16. #include <asm/ioctl.h>

  17. #include <sys/mman.h>

  18. #include <sys/utsname.h>

  19. 

  20. #include "softPwm.h"

  21. #include "softTone.h"

  22. #include "wiringPi.h"

  23. #include "khadas_vim1.h"

  24. /*----------------------------------------------------------------------------------*/

  25. 

  26. /*----------------------------------------------------------------------------------

  27. 	wiringPi gpio map define

  28.   ----------------------------------------------------------------------------------*/

  29. 

  30.   static const int pinToGpio_rev[64] = {

  31.   	//wiringPi number to native gpio number

  32. 		-1,475,		//	0 |  1 :					 | GPIODV_26

  33. 		-1,	-1,		//	2 |  3 :

  34. 	   422,423,		//	4 |  5 : 					 | GPIOH_7 

  35. 	   425,	-1,		//	6 |  7 :			 GPIOH_9 |

  36. 		-1,	-1,		//	8 |  9 :

  37. 	   424,436,		// 10 | 11 :			 GPIOH_8 | GPIOAO_6

  38. 		-1,	-1,		// 12 | 13 :

  39. 		-1,474,		// 14 | 15 :

  40. 	   476,	-1,		// 16 | 17 :      	   GPIODV_27 |

  41. 		-1,	-1,		// 18 | 19 :

  42. 		-1,435,		// 20 | 21 :					 | GPIOAO_5

  43. 	   434,	-1,		// 22 | 23 :	  		GPIOAO_4 |

  44. 	   421,432,		// 24 | 25 :	   		GPIOAO_1 | GPIOAO_2

  45. 		-1,	-1,		// 26 | 27 :		

  46. 		-1,473,		// 28 | 29 :

  47. 		-1,421,		// 30 | 31 :

  48. 		// Padding:

  49. 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,	-1,	-1, //32to47

  50. 		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //48to63

  51.   };

  52. 

  53. 

  54.   static const int phyToGpio_rev[64] = {

  55.   	//physical header pin number to native gpio number

  56. 	-1,			//  0

  57. 	-1,	-1,		//  1 | 21 :   			   	     5v | GND

  58. 	-1,474,		//  2 | 22 : 		  		     5V | I2C_SCK_A(GPIODV_25)

  59. 	-1,473,		//  3 | 23 :   	 		    HUB_DM1 | I2C_SDA_A(GPIODV_24)

  60. 	-1,	-1,		//  4 | 24 :   	  		    HUB_DP1 | GND

  61. 	-1,476,		//  5 | 25 :	  	  		    GND | I2C_SCK_B(GPIODV_27)

  62. 	-1,475,		// 	6 | 26 :     	  		     5V | I2C_SDA_B(GPIODV_26)

  63. 	-1,	-1,		// 	7 | 27 :  			    HUB_DM2 | 3.3V

  64. 	-1,	-1,		// 	8 | 28 :    		    HUB_DP2 | GND

  65. 	-1,423,		// 	9 | 29 :     		   	    GND | GPIOH_7

  66. 	-1,422,		// 10 | 30 :   			    ADC_CH0 | GPIOH_6

  67. 	-1,425,		// 11 | 31 :     			    GND | GPIOH_9

  68. 	-1,424,		// 12 | 32 :  			    ADC_CH2 | GPIOH_8

  69. 	-1,436,		// 13 | 33 :      			  SPDIF | GPIOAO_6

  70. 	-1,	-1,		// 14 | 34 : 			        GND | GND

  71.    435,	-1,		// 15 | 35 : (GPIOAO_5)UART_RX_AO_B | PWM_AO_A(GPIOAO_3)

  72.    434,	-1,		// 16 | 36 : (GPIOAO_4)UART_TX_AO_B | RTC_CLK

  73. 	-1,421,		// 17 | 37 :  		  			GND | GPIOH_5

  74.    431,	-1,		// 18 | 38 :	 (GPIOAO_1)Linux_RX | PWR_EN

  75.    432,	-1,		// 19 | 39 :     (GPIOAO_2)Linux_Tx | PWM_F

  76. 	-1,	-1,		// 20 | 40 : 				   3.3V | GND

  77. 	//  Not used

  78. 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,

  79. 	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,	-1,

  80. 	-1,	-1,	-1,								//41-63

  81.   };

  82. 

  83. 

  84. /*------------------------------------------------------------------------------------------*/

  85. /*																							*/

  86. /*								Global variable define										*/

  87. /*																							*/

  88. /*------------------------------------------------------------------------------------------*/

  89. 

  90. /*------------------------------------------------------------------------------------------*/

  91. /*								wiringPi Pinmap control arrary								*/

  92. /*------------------------------------------------------------------------------------------*/

  93. const int *pinToGpio, *phyToGpio;

  94. 

  95. /*	ADC file descriptor	*/

  96. //static char *adcFds[2];

  97. 

  98. /*	GPIO mmap control	*/

  99. static volatile uint32_t *gpio, *gpio1;

  100. 

  101. /*	wiringPi Global library	*/

  102. static struct libkhadas *lib = NULL;

  103. 

  104. /*------------------------------------------------------------------------------------------*/

  105. /*									Function prototype define								*/

  106. /*------------------------------------------------------------------------------------------*/

  107. static int  gpioToGPSETReg  (int pin);

  108. static int  gpioToGPLEVReg  (int pin);

  109. static int  gpioToPUENReg   (int pin);

  110. static int  gpioToPUPDReg   (int pin);

  111. static int  gpioToShiftReg  (int pin);

  112. static int  gpioToGPFSELReg (int pin);

  113. 

  114. /*------------------------------------------------------------------------------------------*/

  115. /*									wiringPi core function									*/

  116. /*------------------------------------------------------------------------------------------*/

  117. static int      _getModeToGpio      (int mode, int pin);

  118. static void     _pinMode        (int pin, int mode);

  119. static int      _getAlt         (int pin);

  120. static int      _getPUPD        (int pin);

  121. static void     _pullUpDnControl    (int pin, int pud);

  122. static int      _digitalRead        (int pin);

  123. static void     _digitalWrite       (int pin, int value);

  124. static int      _analogRead     (int pin);

  125. static void     _digitalWriteByte   (const int value);

  126. static unsigned int _digitalReadByte    (void);

  127. 

  128. /*------------------------------------------------------------------------------------------*/

  129. /*									board init function										*/

  130. /*------------------------------------------------------------------------------------------*/

  131. static  int init_gpio_mmap (void);

  132. //static  void init_adc_fds   (void);

  133. void init_khadas_vim1(struct libkhadas *libwiring);

  134. 

  135. /*------------------------------------------------------------------------------------------*/

  136. /*							offset to the GPIO Set regsiter									*/

  137. /*------------------------------------------------------------------------------------------*/

  138. static int gpioToGPSETReg (int pin)

  139. {

  140. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  141. 		return VIM1_GPIODV_OUTP_REG_OFFSET;

  142. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  143. 		return VIM1_GPIOH_OUTP_REG_OFFSET;

  144. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END)

  145. 		return VIM1_GPIOAO_OUTP_REG_OFFSET;

  146. 	return -1;

  147. }

  148. 

  149. /*------------------------------------------------------------------------------------------*/

  150. /*							offset to the GPIO Input regsiter								*/

  151. /*------------------------------------------------------------------------------------------*/

  152. static int gpioToGPLEVReg (int pin)

  153. {

  154. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  155. 		return VIM1_GPIODV_INP_REG_OFFSET;

  156. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  157. 		return VIM1_GPIOH_INP_REG_OFFSET;

  158. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END)

  159. 		return VIM1_GPIOAO_INP_REG_OFFSET;

  160. 	return -1;

  161. }

  162. 

  163. /*------------------------------------------------------------------------------------------*/

  164. /*						offset to the GPIO Pull up/down enable regsiter						*/

  165. /*------------------------------------------------------------------------------------------*/

  166. static int gpioToPUENReg(int pin)

  167. {

  168. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  169. 		return VIM1_GPIODV_PUEN_REG_OFFSET;

  170. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  171. 		return VIM1_GPIOH_PUEN_REG_OFFSET;

  172. 	return -1;

  173. }

  174. 

  175. /*------------------------------------------------------------------------------------------*/

  176. /*							offset to the GPIO Pull up/down regsiter						*/

  177. /*------------------------------------------------------------------------------------------*/

  178. static int gpioToPUPDReg(int pin)

  179. {

  180. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  181. 		return VIM1_GPIODV_PUPD_REG_OFFSET;

  182. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  183. 		return VIM1_GPIOH_PUPD_REG_OFFSET;

  184. 	return -1;

  185. }

  186. 

  187. /*------------------------------------------------------------------------------------------*/

  188. /*							offset to the GPIO bit											*/

  189. /*------------------------------------------------------------------------------------------*/

  190. static int gpioToShiftReg (int pin)

  191. {

  192. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  193. 		return pin - VIM1_GPIODV_PIN_START;

  194. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  195. 		return pin - VIM1_GPIOH_PIN_START +20;

  196. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END)

  197. 		return pin - VIM1_GPIOAO_PIN_START;

  198. 	return -1;

  199. }

  200. 

  201. /*------------------------------------------------------------------------------------------*/

  202. /*							offset to the GPIO Function register							*/

  203. /*------------------------------------------------------------------------------------------*/

  204. static int gpioToGPFSELReg(int pin)

  205. {

  206. 	if(pin >= VIM1_GPIODV_PIN_START && pin <= VIM1_GPIODV_PIN_END)

  207. 		return VIM1_GPIODV_FSEL_REG_OFFSET;

  208. 	if(pin >= VIM1_GPIOH_PIN_START && pin <= VIM1_GPIOH_PIN_END)

  209. 		return VIM1_GPIOH_FSEL_REG_OFFSET;

  210. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END)

  211. 		return VIM1_GPIOAO_FSEL_REG_OFFSET;

  212. 	return -1;

  213. }

  214. 

  215. static int _getModeToGpio(int mode, int pin)

  216. {

  217. 	int retPin = -1;

  218. 	switch(mode){

  219. 		/* Native gpio number */

  220. 		case MODE_GPIO:

  221. 			retPin = pin;

  222. 			break;

  223. 		/* Native gpio number for sysfs */

  224. 		case MODE_GPIO_SYS:

  225. 			retPin = lib->sysFds[pin] != -1 ? pin : -1;

  226. 			break;

  227. 		/* wiringPi number */

  228. 		case MODE_PINS:

  229. 			retPin = pin < 64 ? pinToGpio[pin] : -1;

  230. 			break;

  231. 		/* header pin number */

  232. 		case MODE_PHYS:

  233. 			retPin = pin < 64 ? phyToGpio[pin] : -1;

  234. 			break;

  235. 		default:

  236. 			msg(MSG_WARN, "%s : Unknown Mode %d\n", __func__, mode);

  237. 			return -1;

  238. 	}

  239. 

  240. 	/* To check I2C module loaded */

  241. //	if(retPin == 207 || retPin == 208) {

  242. //		if(moduleLoaded(AML_MODULE_I2C))

  243. //			return -1;

  244. //	}

  245. 

  246. 	return retPin;

  247. }

  248. 

  249. /*------------------------------------------------------------------------------------------*/

  250. 

  251. 

  252. /*------------------------------------------------------------------------------------------*/

  253. static void _pinMode(int pin, int mode)

  254. {

  255. 	int fsel, shift, origPin = pin;

  256. 

  257. 	if (lib->mode == MODE_GPIO_SYS)

  258. 		return;

  259. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  260. 		return;

  261. 

  262. 	softPwmStop  (origPin);

  263. 	softToneStop (origPin);

  264. 

  265. 	fsel  = gpioToGPFSELReg(pin);

  266. 	shift = gpioToShiftReg (pin);

  267. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  268. 		switch (mode) {

  269. 			case INPUT:

  270. 				*(gpio1 + fsel) = (*(gpio1 + fsel) |  (1 << shift));

  271. 				break;

  272. 			case OUTPUT:

  273. 				*(gpio1 + fsel) = (*(gpio1 + fsel) & ~(1 << shift));

  274. 				break;

  275. 			case SOFT_PWM_OUTPUT:

  276. 				softPwmCreate (pin, 0, 100);

  277. 				break;

  278. 			case SOFT_TONE_OUTPUT:

  279. 				softToneCreate (pin);

  280. 				break;

  281. 			default:

  282. 				msg(MSG_WARN, "%s : Unknown Mode %d\n", __func__, mode);

  283. 				break;

  284. 		}

  285. 	}else{

  286. 		switch (mode) {

  287. 			case INPUT:

  288. 				*(gpio + fsel) = (*(gpio + fsel) |  (1 << shift));

  289. 				break;

  290. 			case OUTPUT:

  291. 				*(gpio + fsel) = (*(gpio + fsel) & ~(1 << shift));

  292. 				break;

  293. 			case SOFT_PWM_OUTPUT:

  294. 				softPwmCreate (pin, 0, 100);

  295. 				break;

  296. 			case SOFT_TONE_OUTPUT:

  297. 				softToneCreate (pin);

  298. 				break;

  299. 			default:

  300. 				msg(MSG_WARN, "%s : Unknown Mode %d\n", __func__, mode);

  301. 				break;

  302. 		}

  303. 	}

  304. }

  305. 

  306. /*------------------------------------------------------------------------------------------*/

  307. static int _getAlt (int pin)

  308. {

  309. 	int fsel, shift;

  310. 	int mode = 0;

  311. 

  312. 	if (lib->mode == MODE_GPIO_SYS)

  313. 		return 0;

  314. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  315. 		return 2;

  316. 

  317. 	fsel  = gpioToGPFSELReg(pin);

  318. 	shift = gpioToShiftReg(pin);

  319. 

  320. 	switch(pin){

  321. 		case VIM1_GPIODV_PIN_START ...VIM1_GPIODV_PIN_END:

  322. 			switch(shift){

  323. 				case 24:

  324. 					if(*(gpio + VIM1_MUX_2_REG_OFFSET) & (1 << 16))		{ mode = 2; break; }

  325. 					if(*(gpio + VIM1_MUX_1_REG_OFFSET) & (1 << 15))     { mode = 4; break; }

  326. 					break;

  327. 				case 25:

  328. 					if(*(gpio + VIM1_MUX_2_REG_OFFSET) & (1 << 15))     { mode = 2; break; }

  329. 					if(*(gpio + VIM1_MUX_1_REG_OFFSET) & (1 << 14))     { mode = 4; break; }

  330. 					break;

  331. 				case 26:

  332. 					if(*(gpio + VIM1_MUX_2_REG_OFFSET) & (1 << 14))		{ mode = 2; break; }

  333. 					if(*(gpio + VIM1_MUX_1_REG_OFFSET) & (1 << 13))     { mode = 4; break; }

  334. 					break;

  335. 				case 27:

  336. 					if(*(gpio + VIM1_MUX_2_REG_OFFSET) & (1 << 13))     { mode = 2; break; }

  337. 					if(*(gpio + VIM1_MUX_1_REG_OFFSET) & (1 << 12))     { mode = 4; break; }

  338. 					break;

  339. 			}

  340. 			break;

  341. 		case VIM1_GPIOH_PIN_START ...VIM1_GPIOH_PIN_END:

  342. 			switch(shift){

  343. 				case 26:	//GPIOH6

  344. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 26)) 	{ mode = 4; break; }

  345. 					break;

  346. 				case 27:	//GPIOH7

  347. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 22)) 	{ mode = 4; break; }

  348. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 25))		{ mode = 5; break; }

  349. 					break;

  350. 				case 28:	//GPIOH8

  351. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 21)) 	{ mode = 4; break; }

  352. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 24)) 	{ mode = 5; break; }

  353. 					break;

  354. 				case 29:	//GPIOH9

  355. 					if(*(gpio + VIM1_MUX_6_REG_OFFSET) & (1 << 23)) 	{ mode = 4; break; }

  356. 					break;

  357. 			}

  358. 			break;

  359. 		case VIM1_GPIOAO_PIN_START ...VIM1_GPIOAO_PIN_END:

  360. 			switch(shift){

  361. 				case 1:

  362. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 11))	{ mode = 2; break; }

  363. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 25))	{ mode = 3; break; }

  364. 					break;

  365. 				case 2:

  366. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 10))	{ mode = 2; break; }

  367. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 8))	{ mode = 3; break; }

  368. 					break;

  369. 				case 4:

  370. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 24))	{ mode = 2; break; }

  371. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 6))	{ mode = 3; break; }

  372. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 2))	{ mode = 4; break; }

  373. 					break;

  374. 				case 5:

  375. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 23))	{ mode = 2; break; }

  376. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 5))	{ mode = 3; break; }

  377. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 1))	{ mode = 4; break; }

  378. 					break;

  379. 				case 6:

  380. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 16))	{ mode = 4; break; }

  381. 					if(*(gpio1 + VIM1_AO_MUX_1_REG_OFFSET) & (1 << 1))	{ mode = 5; break; }

  382. 					break;

  383. 			}

  384. 			break; 

  385. 		default:

  386. 			return -1;

  387. 	}

  388. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  389. 		return mode ? mode + 1 : (*(gpio1 + fsel) & (1 << shift)) ? 0 : 1;

  390. 	}else{

  391. 		return mode ? mode + 1 : (*(gpio + fsel) & (1 << shift)) ? 0 : 1;

  392. 	}

  393. }

  394. 

  395. /*-------------------------------------------------------------------------------------------*/

  396. static int _getPUPD(int pin)

  397. {

  398. 	int puen, pupd, shift;

  399. 

  400. 	if (lib->mode == MODE_GPIO_SYS)

  401. 		return -1;

  402. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  403. 		return -1;

  404. 

  405. 	puen  = gpioToPUENReg(pin);

  406. 	pupd  = gpioToPUPDReg(pin);

  407. 	shift = gpioToShiftReg(pin);

  408. 	

  409. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  410. 		return 0;

  411. 	}else{

  412. 		if (*(gpio + puen) & (1 << shift)){

  413. 			return *(gpio + pupd) & (1 << shift) ? 1 : 2;

  414. 		}

  415. 		else

  416. 			return 0;

  417. 	}

  418. 

  419. }

  420. 

  421. /*------------------------------------------------------------------------------------------*/

  422. static void _pullUpDnControl(int pin, int pud)

  423. {

  424. 	int shift = 0;

  425. 	if (lib->mode == MODE_GPIO_SYS)

  426. 		return;

  427. 

  428. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  429. 		return;

  430. 	

  431. 	 shift = gpioToShiftReg(pin);

  432. 

  433. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  434. 	

  435. 	}else{

  436. 		 if(pud){

  437. 	 		 // Enable Pull/Pull-down resister

  438. 		 	*(gpio + gpioToPUENReg(pin)) =

  439. 			 	(*(gpio + gpioToPUENReg(pin)) | (1 << shift));

  440. 

  441. 			if (pud == PUD_UP)

  442. 				*(gpio + gpioToPUPDReg(pin)) =

  443. 					(*(gpio + gpioToPUPDReg(pin)) | (1 << shift));

  444. 			else

  445. 				*(gpio + gpioToPUPDReg(pin)) =

  446. 					(*(gpio + gpioToPUPDReg(pin)) & ~(1 << shift));

  447. 		 }else // Disable Pull/Pull-down resister

  448. 	 		*(gpio + gpioToPUENReg(pin)) =

  449. 				(*(gpio + gpioToPUENReg(pin)) & ~(1 << shift));

  450. 	}

  451. }

  452. 

  453. /*------------------------------------------------------------------------------------------*/

  454. static int _digitalRead(int pin)

  455. {

  456. 	char c;

  457. 

  458. 	if (lib->mode == MODE_GPIO_SYS) {

  459. 		if (lib->sysFds[pin] == -1)

  460. 			return LOW;

  461. 

  462. 		lseek(lib->sysFds[pin], 0L, SEEK_SET);

  463. 		read(lib->sysFds[pin], &c, 1);

  464. 

  465. 		return (c=='0') ? LOW : HIGH;

  466. 	}

  467. 

  468. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  469. 		return 0;

  470. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  471. 		if ((*(gpio1 + gpioToGPLEVReg(pin)) & (1 << gpioToShiftReg(pin))) != 0)

  472. 			return HIGH;

  473. 		else

  474. 			return LOW;

  475. 	}else{

  476. 		if ((*(gpio + gpioToGPLEVReg(pin)) & (1 << gpioToShiftReg(pin))) != 0)

  477. 			return HIGH;

  478. 		else

  479. 			return LOW;

  480. 	}

  481. }

  482. 

  483. /*------------------------------------------------------------------------------------------*/

  484. static void _digitalWrite(int pin, int value)

  485. {

  486. 	if (lib->mode == MODE_GPIO_SYS) {

  487. 		if (lib->sysFds[pin] != -1) {

  488. 			if (value == LOW)

  489. 				write (lib->sysFds[pin], "0\n", 2);

  490. 			else

  491. 				write (lib->sysFds[pin], "1\n", 2);

  492. 		}

  493. 		return;

  494. 	}

  495. 

  496. 	if ((pin = _getModeToGpio(lib->mode, pin)) < 0)

  497. 		return;

  498. 

  499. 	if(pin >= VIM1_GPIOAO_PIN_START && pin <= VIM1_GPIOAO_PIN_END){

  500. 		if (value == LOW)

  501. 			*(gpio1 + gpioToGPSETReg(pin)) &= ~(1 << (gpioToShiftReg(pin) + 16));

  502. 		else

  503. 			*(gpio1 + gpioToGPSETReg(pin)) |=  (1 << (gpioToShiftReg(pin) + 16));

  504. 	}else{

  505. 		if (value == LOW)

  506. 			*(gpio + gpioToGPSETReg(pin)) &= ~(1 << gpioToShiftReg(pin));

  507. 		else

  508. 			*(gpio + gpioToGPSETReg(pin)) |=  (1 << gpioToShiftReg(pin));

  509. 	}	

  510. }

  511. 

  512. 

  513. /*------------------------------------------------------------------------------------------*/

  514. static int _analogRead (int UNU pin)

  515. {

  516. 	return -1;

  517. }

  518. 

  519. /*------------------------------------------------------------------------------------------*/

  520. static void _digitalWriteByte(const int UNU value)

  521. {

  522. 	return;

  523. }

  524. static unsigned int _digitalReadByte (void)

  525. {

  526. 	return -1;

  527. }

  528. 

  529. /*------------------------------------------------------------------------------------------*/

  530. 

  531. static int init_gpio_mmap(void)

  532. {

  533. 	int fd;

  534. 

  535. 	/* GPIO mmap setup */

  536. 	if(access("/dev/gpiomem",0) == 0){

  537. 		if ((fd = open ("/dev/gpiomem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)

  538. 			return msg (MSG_ERR,

  539. 				"wiringPiSetup: Unable to open /dev/gpiomem: %s\n",

  540. 				strerror (errno)) ;

  541. 	}else{

  542. 		if (geteuid () != 0)

  543. 			return msg (MSG_ERR,

  544. 				"wiringPiSetup: Must be root. (Did you forget sudo?)\n");

  545. 		

  546. 		if ((fd = open ("/dev/mem", O_RDWR | O_SYNC | O_CLOEXEC) ) < 0)

  547. 			return msg (MSG_ERR,

  548. 				"wiringPiSetup: Unable to open /dev/mem: %s\n",

  549. 				strerror (errno)) ;

  550. 	}

  551. 	gpio1  = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE,

  552. 					MAP_SHARED, fd, VIM1_GPIOAO_BASE);

  553. 	gpio  = (uint32_t *)mmap(0, BLOCK_SIZE, PROT_READ|PROT_WRITE,

  554. 					MAP_SHARED, fd, VIM1_GPIO_BASE);

  555. 	if (((int32_t)gpio == -1) || ((int32_t)gpio1 == -1))

  556. 		return msg (MSG_ERR,

  557. 			"wiringPiSetup: mmap (GPIO) failed: %s\n",

  558. 			strerror (errno));

  559. 	return 0;

  560. }

  561. /*------------------------------------------------------------------------------------------

  562. static void init_adc_fds(void)

  563. {

  564. 

  565. }*/

  566. /*------------------------------------------------------------------------------------------*/

  567. void init_khadas_vim1(struct libkhadas *libwiring)

  568. {

  569. 	init_gpio_mmap();

  570. 	

  571. 	pinToGpio = pinToGpio_rev;

  572. 	phyToGpio = phyToGpio_rev;

  573. 

  574. 	/* wiringPi core function initialize */

  575. 	libwiring->getModeToGpio    = _getModeToGpio;

  576. 	libwiring->pinMode      = _pinMode;

  577. 	libwiring->getAlt       = _getAlt;

  578. 	libwiring->getPUPD      = _getPUPD;

  579. 	libwiring->pullUpDnControl  = _pullUpDnControl;

  580. 	libwiring->digitalRead      = _digitalRead;

  581. 	libwiring->digitalWrite     = _digitalWrite;

  582. 	libwiring->analogRead       = _analogRead;

  583. 	libwiring->digitalWriteByte = _digitalWriteByte;

  584. 	libwiring->digitalReadByte  = _digitalReadByte;

  585. 

  586. 	/* specify pin base number */

  587. 	libwiring->pinBase = VIM1_GPIO_PIN_BASE;

  588. 

  589. 	/* global variable setup */

  590. 	lib = libwiring;

  591. }

  592. 

  593. /*------------------------------------------------------------------------------------------*/

  594. /*------------------------------------------------------------------------------------------*/