heuzef
/
WiringPi
espelho de https://github.com/WiringPi/WiringPi.git
1
0
Derivar 0
Código Questões 0 Lançamentos 9 Wiki Trabalho
Não pode escolher mais do que 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
144 Cometimentos
10 Ramos
53 MiB
 
 
 
 
 
Árvore: b4ab5d2bb2
Ramos Etiquetas
${ item.name }
Criar ramo ${ searchTerm }
de 'b4ab5d2bb2'
${ noResults }
WiringPi/wiringPi/khadas_vim3.c

635 linhas
20 KiB
Em bruto Responsabilidade Histórico 

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

  2. /*																						*/

  3. /*				WiringPi KHADAS VIM3 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 <errno.h>

  13. #include <fcntl.h>

  14. #include <sys/ioctl.h>

  15. #include <asm/ioctl.h>

  16. #include <sys/mman.h>

  17. #include <sys/utsname.h>

  18. #include <string.h>

  19. 

  20. #include "softPwm.h"

  21. #include "softTone.h"

  22. #include "wiringPi.h"

  23. #include "khadas_vim3.h"

  24. 

  25. /*--------------------------------------------------------------------------------------*/

  26. 

  27. /*--------------------------------------------------------------------------------------*/

  28. /*								WiringPi gpio map define								*/

  29. /*--------------------------------------------------------------------------------------*/

  30. 

  31. static const int pinToGpio_rev[64] = {

  32. 	//wiringPi number to native gpio number

  33. 	 -1,353,		//   0 | 1  :					  			| GPIOAO_3

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

  35. 	 -1,301,		//	 4 | 5  :					  			| GPIOA_1

  36. 	303, -1,		//	 6 | 7  :						GPIOA_3 |

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

  38. 	302,304,		//  10 | 11 :						GPIOA_2 | GPIOA_4

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

  40. 	 -1, -1,		// 	14 | 15 :								|

  41. 	352, -1,		// 	16 | 17 :					   GPIOAO_2 |

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

  43. 	 -1,326,		//	20 | 21 :								| GPIOH_6

  44. 	327, -1,		// 	22 | 23 :					  	GPIOH_7 |

  45. 	351,350, 		//	24 | 25 :					   GPIOAO_1 | GPIOAO_0

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

  47. 	 -1, -1,		//	28 | 29 :					  		    |

  48. 	 -1, -1,		//	30 | 31 : 								|

  49. 	// Padding:

  50. 	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //32to47

  51. 	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //48to63

  52. 

  53. };

  54. 

  55. static const int phyToGpio_rev[64] = {

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

  57. 	 -1,				//	0

  58. 	 -1, -1,			//	 1 | 21 :						 5V | GND

  59. 	 -1, -1,			//	 2 | 22 :						 5V	| GPIOA_15

  60. 	 -1, -1,			//	 3 | 23 :					 USB_DM | GPIOA_14

  61. 	 -1, -1,			//	 4 | 24 :					 USB_DP | GND

  62. 	 -1,352,			//	 5 | 25 :						GND	| GPIOAO_2

  63. 	 -1,353,			//	 6 | 26 :					 MCU3.3 | GPIOAO_3

  64. 	 -1, -1,			//	 7 | 27 :				  	MCUNrST | 3.3V

  65. 	 -1, -1,			//	 8 | 28 :				  	MCUSWIM | GND

  66. 	 -1,301,			//	 9 | 29 :						GND	| GPIOA_1

  67. 	 -1, -1,			//	10 | 30 :					   ADC0	| GPIOA_0

  68. 	 -1,303,			//	11 | 31 :					   1.8V	| GPIOA_3

  69. 	 -1,302,			//	12 | 32 :					   ADC1	| GPIOA_2

  70. 	 -1,304,			//	13 | 33 :					  SPDIF	| GPIOA_4

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

  72. 	326, -1,			//	15 | 35 :	  (GPIOH_6)UART_RX_AO_B | PWM-F

  73. 	327, -1,			//	16 | 36 :	  (GPIOH_7)UART_TX_AO_B | RTC_CLK

  74. 	 -1, -1,			//	17 | 37 :						GND	| GPIOH_4

  75. 	351, -1,			//	18 | 38 :		 (GPIOAO_1)Linux_RX	| MCUFA_1

  76. 	350, -1,			//	19 | 39 :		 (GPIOAO_0)Linux_TX | GPIOZ_15

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

  78. 	 //Not used

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

  80. 	 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  81. 	 -1, -1, -1,										//41-63

  82. };

  83. 

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

  85. /*																						*/

  86. /*								Global variable define									*/

  87. /*																						*/

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

  89. 

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

  91. /*							wiringPi Pinmap control array								*/

  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. 

  108. static int  gpioToGPSETReg  (int pin);

  109. static int  gpioToGPLEVReg  (int pin);

  110. static int  gpioToPUENReg   (int pin);

  111. static int  gpioToPUPDReg   (int pin);

  112. static int  gpioToShiftReg  (int pin);

  113. static int  gpioToGPFSELReg (int pin);

  114. static int	gpioToDSReg		(int pin);

  115. static int	gpioToMuxReg	(int pin);

  116. 

  117. /*--------------------------------------------------------------------------------------*/

  118. /*								 wiringPi core function									*/

  119. /*--------------------------------------------------------------------------------------*/

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

  121. static void		_setPadDrive		(int pin, int value);

  122. static void		_getPadDrive		(int pin);

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

  124. static int      _getAlt         (int pin);

  125. static int      _getPUPD        (int pin);

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

  127. static int      _digitalRead        (int pin);

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

  129. static int      _analogRead     (int pin);

  130. static void     _digitalWriteByte   (const int value);

  131. static unsigned int _digitalReadByte    (void);

  132. 

  133. /*--------------------------------------------------------------------------------------*/

  134. /*								board init function										*/

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

  136. static  int init_gpio_mmap (void);

  137. static  void init_adc_fds   (void);

  138. void init_khadas_vim3(struct libkhadas *libwiring);

  139. 

  140. /*--------------------------------------------------------------------------------------*/

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

  142. /*--------------------------------------------------------------------------------------*/

  143. static int gpioToGPSETReg (int pin)

  144. {

  145.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  146. 		return VIM3_GPIOA_OUTP_REG_OFFSET;

  147. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  148. 		return VIM3_GPIOH_OUTP_REG_OFFSET;

  149. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  150. 		return VIM3_GPIOAO_OUTP_REG_OFFSET;

  151. 	return -1; 

  152. }

  153. 

  154. /*------------------------------------------------------------------------------------------*/

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

  156. /*------------------------------------------------------------------------------------------*/

  157. static int gpioToGPLEVReg (int pin)

  158. {

  159. 	if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  160. 		return VIM3_GPIOA_INP_REG_OFFSET;

  161. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  162. 		return VIM3_GPIOH_INP_REG_OFFSET;

  163. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  164. 		return VIM3_GPIOAO_INP_REG_OFFSET;

  165. 	return -1; 

  166. }

  167. 

  168. /*------------------------------------------------------------------------------------------*/

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

  170. /*------------------------------------------------------------------------------------------*/

  171. static int gpioToPUENReg(int pin)

  172. {

  173.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  174. 		return VIM3_GPIOA_PUEN_REG_OFFSET;

  175. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  176. 		return VIM3_GPIOH_PUEN_REG_OFFSET;

  177. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  178. 		return VIM3_GPIOAO_PUEN_REG_OFFSET;

  179. 	return -1;

  180. }

  181. 

  182. /*------------------------------------------------------------------------------------------*/

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

  184. /*------------------------------------------------------------------------------------------*/

  185. static int gpioToPUPDReg(int pin)

  186. {

  187.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  188. 		return VIM3_GPIOA_PUPD_REG_OFFSET;

  189. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  190. 		return VIM3_GPIOH_PUPD_REG_OFFSET;

  191. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  192. 		return VIM3_GPIOAO_PUPD_REG_OFFSET;

  193. 	return -1;

  194. }

  195. 

  196. /*------------------------------------------------------------------------------------------*/

  197. /*                          offset to the GPIO bit                                          */

  198. /*------------------------------------------------------------------------------------------*/

  199. static int gpioToShiftReg (int pin)

  200. {

  201.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  202. 		return pin - VIM3_GPIOA_PIN_START;

  203. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  204. 		return pin - VIM3_GPIOH_PIN_START;

  205. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  206. 		return pin - VIM3_GPIOAO_PIN_START;

  207. 	return -1;

  208. }

  209. 

  210. /*------------------------------------------------------------------------------------------*/

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

  212. /*------------------------------------------------------------------------------------------*/

  213. static int gpioToGPFSELReg(int pin)

  214. {

  215.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  216. 	    return VIM3_GPIOA_FSEL_REG_OFFSET;

  217. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  218. 		return VIM3_GPIOH_FSEL_REG_OFFSET;

  219. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  220. 		return VIM3_GPIOAO_FSEL_REG_OFFSET;

  221. 	return -1;

  222. }

  223. 

  224. /*------------------------------------------------------------------------------------------*/

  225. /*				offset to the GPIO Drive Strength register									*/

  226. /*------------------------------------------------------------------------------------------*/

  227. static int gpioToDSReg (int pin)

  228. {

  229.     if(pin >= VIM3_GPIOA_PIN_START && pin <= VIM3_GPIOA_PIN_END)

  230. 	    return VIM3_GPIOA_DS_REG_5A_OFFSET;

  231. 	if(pin >= VIM3_GPIOH_PIN_START && pin <= VIM3_GPIOH_PIN_END)

  232. 		return VIM3_GPIOH_DS_REG_3A_OFFSET;

  233. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END)

  234. 		return VIM3_GPIOAO_DS_REG_A_OFFSET;

  235. 	return -1;

  236. }

  237. 

  238. /*------------------------------------------------------------------------------------------*/

  239. /*							offset to the GPIO Pin Mux register								*/

  240. /*------------------------------------------------------------------------------------------*/

  241. static int gpioToMuxReg(int pin)

  242. {	

  243. 	switch(pin){

  244. 		case VIM3_GPIOA_PIN_START  ...VIM3_GPIOA_PIN_START + 7:

  245. 			return  VIM3_GPIOA_MUX_D_REG_OFFSET;

  246. 		case VIM3_GPIOA_PIN_START + 8  ...VIM3_GPIOA_PIN_END:

  247. 			return  VIM3_GPIOA_MUX_E_REG_OFFSET;

  248. 		case VIM3_GPIOH_PIN_START  ...VIM3_GPIOH_PIN_END:

  249. 			return VIM3_GPIOH_MUX_B_REG_OFFSET;

  250. 		case VIM3_GPIOAO_PIN_START ...VIM3_GPIOAO_PIN_START + 7:

  251. 			return VIM3_GPIOAO_MUX_0_REG_OFFSET;

  252. 		case VIM3_GPIOAO_PIN_START + 8 ...VIM3_GPIOAO_PIN_END:

  253. 			return VIM3_GPIOAO_MUX_1_REG_OFFSET;

  254. 	}

  255. }

  256. 

  257. /*------------------------------------------------------------------------------------------*/

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

  259. {

  260. 	int retPin = -1;

  261. 	switch(mode){

  262. 		/* Native gpio number */

  263. 		case MODE_GPIO:

  264. 			retPin = pin;

  265. 			break;

  266. 		/* Native gpio number for sysfs */

  267. 		case MODE_GPIO_SYS:

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

  269. 			break;

  270. 		/* wiringPi number */

  271. 		case MODE_PINS:

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

  273. 			break;

  274. 		/* header pin number */

  275. 		case MODE_PHYS:

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

  277. 			break;

  278. 		default:

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

  280. 			return -1;

  281. 	}

  282. 	return retPin;

  283. }

  284. 

  285. /*------------------------------------------------------------------------------------------*/

  286. static void _setPadDrive(int pin, int value)

  287. {

  288. 	int ds, shift;

  289. 

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

  291. 		return;

  292. 

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

  294. 		return;

  295. 	

  296. 	if(value < 0 || value > 3){

  297. 		msg(MSG_WARN, "%s : Invalid value %d (Must be 0 ~ 3)\n", __func__, value);

  298. 		return;

  299. 	}

  300. 

  301. 	ds = gpioToDSReg(pin);

  302. 	shift = gpioToShiftReg(pin);

  303. 	shift *= 2;

  304. 	

  305. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

  306. 		*(gpio1 + ds) &= ~(0b11 << shift);

  307. 		*(gpio1 + ds) |= (value << shift);

  308. 	}else{

  309. 		*(gpio + ds) &= ~(0b11 << shift);

  310. 		*(gpio + ds) |= (value << shift);

  311. 	}

  312. }

  313. 

  314. /*-----------------------------------------------------------------------------------------*/

  315. static void _getPadDrive(int pin)

  316. {	

  317. 	int ds, shift;

  318. 

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

  320. 		return;

  321. 

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

  323. 		return;

  324. 

  325. 	ds = gpioToDSReg(pin);

  326. 	shift = gpioToShiftReg(pin);

  327. 	shift *= 2;

  328. 

  329. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

  330. 		return (*(gpio1 + ds) >> shift) & 0b11;

  331. 	}else{

  332. 		return (*(gpio + ds) >> shift) & 0b11;

  333. 	}

  334. }

  335. 

  336. /*------------------------------------------------------------------------------------------*/

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

  338. {

  339. 	int fsel, shift, origPin = pin;

  340. 

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

  342. 		return;

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

  344. 		return;

  345. 

  346. 	softPwmStop  (origPin);

  347. 	softToneStop (origPin);

  348. 

  349. 	fsel  = gpioToGPFSELReg(pin);

  350. 	shift = gpioToShiftReg (pin);

  351. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

  352. 		switch (mode) {

  353. 			case INPUT:

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

  355. 				break;

  356. 			case OUTPUT:

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

  358. 				break;

  359. 			case SOFT_PWM_OUTPUT:

  360. 				softPwmCreate (pin, 0, 100);

  361. 				break;

  362. 			case SOFT_TONE_OUTPUT:

  363. 				softToneCreate (pin);

  364. 				break;

  365. 			default:

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

  367. 				break;

  368. 		}

  369. 	}else{

  370. 		switch (mode) {

  371. 			case INPUT:

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

  373. 				break;

  374. 			case OUTPUT:

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

  376. 				break;

  377. 			case SOFT_PWM_OUTPUT:

  378. 				softPwmCreate (pin, 0, 100);

  379. 				break;

  380. 			case SOFT_TONE_OUTPUT:

  381. 				softToneCreate (pin);

  382. 				break;

  383. 			default:

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

  385. 				break;

  386. 		}

  387. 	}

  388. }

  389. 

  390. /*------------------------------------------------------------------------------------------*/

  391. static int _getAlt(int pin)

  392. {

  393. 	int fsel, mux, shift, target, mode;

  394. 	

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

  396. 		return 0;

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

  398. 		return 2;

  399. 

  400. 	fsel = gpioToGPFSELReg(pin);

  401. 	mux    = gpioToMuxReg(pin);

  402. 	target = shift = gpioToShiftReg(pin);

  403. 

  404. 	while(target >= 8) {

  405. 		target -= 8;

  406. 	}

  407. 

  408. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

  409. 		mode = (*(gpio1 + mux) >> (target * 4)) & 0xF;

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

  411. 	}else{

  412. 		mode = (*(gpio + mux) >> (target * 4)) & 0xF;

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

  414. 	}

  415. }

  416. 

  417. /*------------------------------------------------------------------------------------------*/

  418. static int _getPUPD(int pin)

  419. {

  420. 	int puen, pupd, shift;

  421. 

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

  423. 		return -1;

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

  425. 		return -1;

  426. 	

  427. 	puen  = gpioToPUENReg(pin);

  428. 	pupd  = gpioToPUPDReg(pin);

  429. 	shift = gpioToShiftReg(pin);

  430. 	

  431. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){	

  432. 		if(*(gpio1 + puen) & (1 << shift)){

  433. 			return *(gpio1 + pupd) & (1 << shift) ? 1 : 2;

  434. 		}else{

  435. 			return 0;

  436. 		}

  437. 	}else{

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

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

  440. 		}else{

  441. 			return 0;

  442. 		}

  443. 	}

  444. }

  445. 

  446. /*------------------------------------------------------------------------------------------*/

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

  448. {

  449. 	int shift = 0;

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

  451. 		return;

  452. 

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

  454. 		return;

  455. 	

  456. 	shift = gpioToShiftReg(pin);

  457. 

  458. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){	

  459. 		if(pud){

  460. 			//Enable Pull/Pull-down resister

  461. 			*(gpio1 + gpioToPUENReg(pin)) =

  462. 				(*(gpio1 + gpioToPUENReg(pin)) | (1 << shift));

  463. 

  464. 			if (pud == PUD_UP)

  465. 				*(gpio1 + gpioToPUPDReg(pin)) =

  466. 					(*(gpio1 + gpioToPUPDReg(pin)) | (1 << shift));

  467. 

  468. 			else

  469. 				*(gpio1 + gpioToPUPDReg(pin)) =

  470. 					(*(gpio1 + gpioToPUPDReg(pin)) & ~(1 << shift));

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

  472. 			*(gpio1 + gpioToPUENReg(pin)) =

  473. 				(*(gpio1 + gpioToPUENReg(pin)) & ~(1 << shift));

  474. 	}else{

  475. 		if(pud){

  476. 			//Enable Pull/Pull-down resister

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

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

  479. 

  480. 			if (pud == PUD_UP)

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

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

  483. 

  484. 			else

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

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

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

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

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

  490. 	}

  491. }

  492. 

  493. /*------------------------------------------------------------------------------------------*/

  494. static int _digitalRead(int pin)

  495. {

  496. 	char c;

  497. 

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

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

  500. 			return LOW;

  501. 

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

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

  504. 

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

  506. 	}

  507. 

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

  509. 		return 0;

  510. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

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

  512. 			return HIGH;

  513. 		else

  514. 			return LOW;

  515. 	}else{

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

  517. 			return HIGH;

  518. 		else

  519. 			return LOW;

  520. 	}

  521. }

  522. 

  523. /*------------------------------------------------------------------------------------------*/

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

  525. {

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

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

  528. 			if(value == LOW)

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

  530. 			else

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

  532. 		}

  533. 		return;

  534. 	}

  535. 

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

  537. 		return;

  538. 

  539. 	if(pin >= VIM3_GPIOAO_PIN_START && pin <= VIM3_GPIOAO_PIN_END){

  540. 		if (value == LOW)

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

  542. 		else

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

  544. 	}else{

  545. 		if (value == LOW)

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

  547. 		else

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

  549. 	}

  550. }

  551. 

  552. /*------------------------------------------------------------------------------------------*/

  553. static int _analogRead (int pin)

  554. {

  555. 	return -1;

  556. }

  557. 

  558. /*-------------------------------------------------------------------------------------------*/

  559. static void _digitalWriteByte(const int value)

  560. {

  561. 	return;

  562. }

  563. static unsigned int _digitalReadByte (void)

  564. {

  565. 	return -1;

  566. }

  567. 

  568. /*------------------------------------------------------------------------------------------*/

  569. static int init_gpio_mmap(void)

  570. {

  571. 	int fd;

  572. 

  573. 	/* GPIO mmap setup */

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

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

  576. 			return msg (MSG_ERR,

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

  578. 					strerror (errno));

  579. 	}else{

  580. 		if (geteuid () != 0)

  581. 			return msg (MSG_ERR,

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

  583. 

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

  585. 			return msg (MSG_ERR,

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

  587. 					strerror (errno));

  588. 	}

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

  590. 						MAP_SHARED, fd, VIM3_GPIOAO_BASE);

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

  592. 						MAP_SHARED, fd, VIM3_GPIO_BASE);

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

  594. 		return msg (MSG_ERR,

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

  596. 				strerror (errno));

  597. }

  598. 

  599. /*------------------------------------------------------------------------------------------*/

  600. static void init_adc_fds(void)

  601. {

  602. }

  603. 

  604. /*------------------------------------------------------------------------------------------*/

  605. void init_khadas_vim3(struct libkhadas *libwiring)

  606. {

  607. 	init_gpio_mmap();

  608. 

  609. 	pinToGpio = pinToGpio_rev;

  610. 	phyToGpio = phyToGpio_rev;

  611. 

  612. 	/* wiringPi core function initialize */

  613. 	libwiring->getModeToGpio    = _getModeToGpio;

  614. 	libwiring->setPadDrive      = _setPadDrive;

  615. 	libwiring->getPadDrive      = _getPadDrive;

  616. 	libwiring->pinMode      	= _pinMode;

  617. 	libwiring->getAlt       	= _getAlt;

  618. 	libwiring->getPUPD      	= _getPUPD;

  619. 	libwiring->pullUpDnControl  = _pullUpDnControl;

  620. 	libwiring->digitalRead      = _digitalRead;

  621. 	libwiring->digitalWrite     = _digitalWrite;

  622. 	libwiring->analogRead       = _analogRead;

  623. 	libwiring->digitalWriteByte = _digitalWriteByte;

  624. 	libwiring->digitalReadByte  = _digitalReadByte;

  625. 

  626. 	/* specify pin base number */

  627. 	libwiring->pinBase = VIM3_GPIO_PIN_BASE;

  628. 

  629. 	/* global variable setup */

  630. 	lib = libwiring;

  631. }

  632. 

  633. /*------------------------------------------------------------------------------------------*/

  634. /*------------------------------------------------------------------------------------------*/