heuzef
/
WiringPi
réplica de https://github.com/WiringPi/WiringPi.git
1
0
Fork 0
Código Incidencias 0 Lanzamientos 9 Wiki Actividad
No puede seleccionar más de 25 temas Los temas deben comenzar con una letra o número, pueden incluir guiones ('-') y pueden tener hasta 35 caracteres de largo.
159 Commits
10 Ramas
53 MiB
 
 
 
 
 
Árbol: 101320eddb
Ramas Etiquetas
${ item.name }
Crear rama ${ searchTerm }
desde '101320eddb'
${ noResults }
WiringPi/wiringPi/khadas_vim2.c

613 líneas
20 KiB
Original Blame Histórico 

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

  2. /*																						*/

  3. /*				WiringPi KHADAS VIM2 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_vim2.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. 	270,275,		//   0 | 1  :					  GPIODV_21 | GPIODV_26

  34. 	271,272,		//   2 | 3  :					  GPIODV_22 | GPIODV_22

  35. 	222,223,		//	 4 | 5  :					  			| GPIOH_7

  36. 	225, -1,		//	 6 | 7  :						GPIOH_9 |

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

  38. 	224,236,		//  10 | 11 :						GPIOH_8 | GPIOAO_6

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

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

  41. 	276, -1,		// 	16 | 17 :					  GPIODV_27 |

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

  43. 	 -1,235,		//	20 | 21 :								| GPIOAO_5

  44. 	234, -1,		// 	22 | 23 :					   GPIOAO_4 |

  45. 	231,230, 		//	24 | 25 :					   GPIOAO_1 | GPIOAO_0

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

  47. 	262,273,		//	28 | 29 :					  GPIODV_13 |

  48. 	278,221,		//	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,274,			//	 2 | 22 :						 5V	| GPIODV_25

  60. 	 -1,273,			//	 3 | 23 :					 USB_DM | GPIODV_24

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

  62. 	 -1,276,			//	 5 | 25 :						GND	| GPIODV_27

  63. 	270,275,			//	 6 | 26 :				  GPIODV_21	| GPIODV_26

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

  65. 	272, -1,			//	 8 | 28 :				  GPIODV_23	| GND

  66. 	 -1,223,			//	 9 | 29 :						GND	| GPIOH7

  67. 	 -1,222,			//	10 | 30 :					   ADC0	| GPIOH6

  68. 	 -1,225,			//	11 | 31 :					   1.8V	| GPIOH9

  69. 	 -1,224,			//	12 | 32 :					   ADC1	| GPIOH8

  70. 	 -1,236,			//	13 | 33 :					  SPDIF	| GPIOAO_6

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

  72. 	235,278,			//	15 | 35 :	 (GPIOAO_5)UART_RX_AO_B | GPIODV_29

  73. 	234, -1,			//	16 | 36 :	 (GPIOAO_4)UART_TX_AO_B | RTC_CLK

  74. 	 -1,221,			//	17 | 37 :						GND	| GPIOH5

  75. 	231, -1,			//	18 | 38 :		 (GPIOAO_1)Linux_RX	| EXP_INT

  76. 	230,262,			//	19 | 39 :		 (GPIOAO_0)Linux_TX | GPIODV_13

  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. 

  115. /*--------------------------------------------------------------------------------------*/

  116. /*								 wiringPi core function									*/

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

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

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

  120. static int      _getAlt         (int pin);

  121. static int      _getPUPD        (int pin);

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

  123. static int      _digitalRead        (int pin);

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

  125. static int      _analogRead     (int pin);

  126. static void     _digitalWriteByte   (const int value);

  127. static unsigned int _digitalReadByte    (void);

  128. 

  129. /*--------------------------------------------------------------------------------------*/

  130. /*								board init function										*/

  131. /*--------------------------------------------------------------------------------------*/

  132. static  int init_gpio_mmap (void);

  133. //static  void init_adc_fds   (void);

  134. void init_khadas_vim2(struct libkhadas *libwiring);

  135. 

  136. /*--------------------------------------------------------------------------------------*/

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

  138. /*--------------------------------------------------------------------------------------*/

  139. static int gpioToGPSETReg (int pin)

  140. {

  141.     if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  142. 		return VIM2_GPIODV_OUTP_REG_OFFSET;

  143. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  144. 		return VIM2_GPIOH_OUTP_REG_OFFSET;

  145. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END)

  146. 		return VIM2_GPIOAO_OUTP_REG_OFFSET;

  147. 	return -1; 

  148. }

  149. 

  150. /*------------------------------------------------------------------------------------------*/

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

  152. /*------------------------------------------------------------------------------------------*/

  153. static int gpioToGPLEVReg (int pin)

  154. {

  155. 	if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  156. 		return VIM2_GPIODV_INP_REG_OFFSET;

  157. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  158. 		return VIM2_GPIOH_INP_REG_OFFSET;

  159. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END)

  160. 		return VIM2_GPIOAO_INP_REG_OFFSET;

  161. 	return -1; 

  162. }

  163. 

  164. /*------------------------------------------------------------------------------------------*/

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

  166. /*------------------------------------------------------------------------------------------*/

  167. static int gpioToPUENReg(int pin)

  168. {

  169.     if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  170. 		return VIM2_GPIODV_PUEN_REG_OFFSET;

  171. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  172. 		return VIM2_GPIOH_PUEN_REG_OFFSET;

  173. 	return -1;

  174. }

  175. 

  176. /*------------------------------------------------------------------------------------------*/

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

  178. /*------------------------------------------------------------------------------------------*/

  179. static int gpioToPUPDReg(int pin)

  180. {

  181.     if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  182. 		return VIM2_GPIODV_PUPD_REG_OFFSET;

  183. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  184. 		return VIM2_GPIOH_PUPD_REG_OFFSET;

  185. 	return -1;

  186. }

  187. 

  188. /*------------------------------------------------------------------------------------------*/

  189. /*                          offset to the GPIO bit                                          */

  190. /*------------------------------------------------------------------------------------------*/

  191. static int gpioToShiftReg (int pin)

  192. {

  193.     if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  194. 		return pin - VIM2_GPIODV_PIN_START;

  195. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  196. 		return pin - VIM2_GPIOH_PIN_START +20;

  197. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END)

  198. 		return pin - VIM2_GPIOAO_PIN_START;

  199. 	return -1;

  200. }

  201. 

  202. /*------------------------------------------------------------------------------------------*/

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

  204. /*------------------------------------------------------------------------------------------*/

  205. static int gpioToGPFSELReg(int pin)

  206. {

  207.     if(pin >= VIM2_GPIODV_PIN_START && pin <= VIM2_GPIODV_PIN_END)

  208. 	    return VIM2_GPIODV_FSEL_REG_OFFSET;

  209. 	if(pin >= VIM2_GPIOH_PIN_START && pin <= VIM2_GPIOH_PIN_END)

  210. 		return VIM2_GPIOH_FSEL_REG_OFFSET;

  211. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END)

  212. 		return VIM2_GPIOAO_FSEL_REG_OFFSET;

  213. 	return -1;

  214. }

  215. 

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

  217. {

  218. 	int retPin = -1;

  219. 	switch(mode){

  220. 		/* Native gpio number */

  221. 		case MODE_GPIO:

  222. 			retPin = pin;

  223. 			break;

  224. 		/* Native gpio number for sysfs */

  225. 		case MODE_GPIO_SYS:

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

  227. 			break;

  228. 		/* wiringPi number */

  229. 		case MODE_PINS:

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

  231. 			break;

  232. 		/* header pin number */

  233. 		case MODE_PHYS:

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

  235. 			break;

  236. 		default:

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

  238. 			return -1;

  239. 	}

  240. 	/* To check I2C module loaded */

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

  242. //		if(moduleLoaded(AML_MODULE_I2C))

  243. //			return -1;

  244. //	}

  245. 	return retPin;

  246. }

  247. 

  248. /*--------------------------------------------------------------------------------------*/

  249. 

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

  251. {

  252. 	int fsel, shift, origPin = pin;

  253. 

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

  255. 		return;

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

  257. 		return;

  258. 

  259. 	softPwmStop  (origPin);

  260. 	softToneStop (origPin);

  261. 

  262. 	fsel  = gpioToGPFSELReg(pin);

  263. 	shift = gpioToShiftReg (pin);

  264. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){

  265. 		switch (mode) {

  266. 			case INPUT:

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

  268. 				break;

  269. 			case OUTPUT:

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

  271. 				break;

  272. 			case SOFT_PWM_OUTPUT:

  273. 				softPwmCreate (pin, 0, 100);

  274. 				break;

  275. 			case SOFT_TONE_OUTPUT:

  276. 				softToneCreate (pin);

  277. 				break;

  278. 			default:

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

  280. 				break;

  281. 		}

  282. 	}else{

  283. 		switch (mode) {

  284. 			case INPUT:

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

  286. 				break;

  287. 			case OUTPUT:

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

  289. 				break;

  290. 			case SOFT_PWM_OUTPUT:

  291. 				softPwmCreate (pin, 0, 100);

  292. 				break;

  293. 			case SOFT_TONE_OUTPUT:

  294. 				softToneCreate (pin);

  295. 				break;

  296. 			default:

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

  298. 				break;

  299. 		}

  300. 	}

  301. }

  302. 

  303. /*--------------------------------------------------------------------------------------*/

  304. static int _getAlt(int pin)

  305. {

  306. 	int fsel, shift;

  307. 	int mode = 0;

  308. 

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

  310. 		return 0;

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

  312. 		return 2;

  313. 

  314. 	fsel = gpioToGPFSELReg(pin);

  315. 	shift = gpioToShiftReg(pin);

  316. 

  317. 	switch(pin){

  318. 		case VIM2_GPIODV_PIN_START ...VIM2_GPIODV_PIN_END:

  319. 			switch(shift){

  320. 				case 13:

  321. 					if(*(gpio + VIM2_MUX_3_REG_OFFSET) & (1 << 7))     { mode = 2; break; }

  322. 					if(*(gpio + VIM2_MUX_1_REG_OFFSET) & (1 << 29))    { mode = 5; break; }

  323. 					break;

  324. 				case 21:

  325. 					if(*(gpio + VIM2_MUX_3_REG_OFFSET) & (1 << 5))     { mode = 2; break; }

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

  327. 					break;

  328. 				case 22:

  329. 					if(*(gpio + VIM2_MUX_3_REG_OFFSET) & (1 << 5))     { mode = 2; break; }

  330. 					if(*(gpio + VIM2_MUX_2_REG_OFFSET) & (1 << 18))    { mode = 4; break; }

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

  332. 					break;

  333. 				case 23:

  334. 					if(*(gpio + VIM2_MUX_3_REG_OFFSET) & (1 << 5))     { mode = 2; break; }

  335. 					if(*(gpio + VIM2_MUX_2_REG_OFFSET) & (1 << 17))    { mode = 4; break; }

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

  337. 					break;

  338. 				case 26:

  339. 					if(*(gpio + VIM2_MUX_1_REG_OFFSET) & (1 << 20))    { mode = 2; break; }

  340. 					if(*(gpio + VIM2_MUX_1_REG_OFFSET) & (1 << 13))    { mode = 3; break; }

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

  342. 					break;

  343. 				case 27:

  344. 					if(*(gpio + VIM2_MUX_1_REG_OFFSET) & (1 << 18))    { mode = 2; break; }

  345. 					if(*(gpio + VIM2_MUX_1_REG_OFFSET) & (1 << 12))    { mode = 3; break; }

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

  347. 					break;

  348. 				case 29:

  349. 					if(*(gpio + VIM2_MUX_2_REG_OFFSET) & (1 << 11))    { mode = 2; break; }

  350. 					if(*(gpio + VIM2_MUX_2_REG_OFFSET) & (1 << 10))    { mode = 3; break; }

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

  352. 					break;

  353. 			}

  354. 			break;

  355. 		case VIM2_GPIOH_PIN_START ...VIM2_GPIOH_PIN_END:

  356. 			switch(shift){

  357. 				case 26:

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

  359. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 20))    { mode = 6; break; }

  360. 					break;

  361. 				case 27:

  362. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 25))    { mode = 4; break; }

  363. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 22))    { mode = 5; break; }

  364. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 19))    { mode = 6; break; }

  365. 					break;

  366. 				case 28:

  367. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 24))    { mode = 4; break; }

  368. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 21))    { mode = 5; break; }

  369. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 18))    { mode = 6; break; }

  370. 					break;

  371. 				case 29:	

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

  373. 					if(*(gpio + VIM2_MUX_6_REG_OFFSET) & (1 << 17))    { mode = 6; break; }

  374. 					break;

  375. 			}

  376. 			break;

  377. 		case VIM2_GPIOAO_PIN_START ...VIM2_GPIOAO_PIN_END:

  378. 			switch(shift){

  379. 				case 0:

  380. 					if(*(gpio1 + VIM2_AO_MUX_1_REG_OFFSET) & (1 << 12))    { mode = 2; break; }

  381. 					if(*(gpio1 + VIM2_AO_MUX_1_REG_OFFSET) & (1 << 26))    { mode = 3; break; }

  382. 					break;

  383. 				case 1:

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

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

  386. 					break;

  387. 				case 4:

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

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

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

  391. 					break;

  392. 				case 5:

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

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

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

  396. 					break;

  397. 				case 6:

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

  399. 					if(*(gpio1 + VIM2_AO_MUX_1_REG_OFFSET) & (1 << 18))    { mode = 5; break; }

  400. 					break;

  401. 			}

  402. 			break;

  403. 		default:

  404. 			return -1;

  405. 	}

  406. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){	

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

  408. 	}else{

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

  410. 	}

  411. }

  412. 

  413. /*------------------------------------------------------------------------------------------*/

  414. static int _getPUPD(int pin)

  415. {

  416. 	int puen, pupd, shift;

  417. 

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

  419. 		return -1;

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

  421. 		return -1;

  422. 	

  423. 	puen  = gpioToPUENReg(pin);

  424. 	pupd  = gpioToPUPDReg(pin);

  425. 	shift = gpioToShiftReg(pin);

  426. 	

  427. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){

  428. 		return 0;

  429. 	}else{

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

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

  432. 		}else{

  433. 			return 0;

  434. 		}

  435. 	}

  436. }

  437. 

  438. /*------------------------------------------------------------------------------------------*/

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

  440. {

  441. 	int shift = 0;

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

  443. 		return;

  444. 

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

  446. 		return;

  447. 	

  448. 	shift = gpioToShiftReg(pin);

  449. 

  450. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){

  451. 	

  452. 	}else{

  453. 		if(pud){

  454. 			//Enable Pull/Pull-down resister

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

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

  457. 

  458. 			if (pud == PUD_UP)

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

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

  461. 

  462. 			else

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

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

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

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

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

  468. 	}

  469. }

  470. 

  471. /*------------------------------------------------------------------------------------------*/

  472. static int _digitalRead(int pin)

  473. {

  474. 	char c;

  475. 

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

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

  478. 			return LOW;

  479. 

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

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

  482. 

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

  484. 	}

  485. 

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

  487. 		return 0;

  488. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){

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

  490. 			return HIGH;

  491. 		else

  492. 			return LOW;

  493. 	}else{

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

  495. 			return HIGH;

  496. 		else

  497. 			return LOW;

  498. 	}

  499. }

  500. 

  501. /*------------------------------------------------------------------------------------------*/

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

  503. {

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

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

  506. 			if(value == LOW)

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

  508. 			else

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

  510. 		}

  511. 		return;

  512. 	}

  513. 

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

  515. 		return;

  516. 

  517. 	if(pin >= VIM2_GPIOAO_PIN_START && pin <= VIM2_GPIOAO_PIN_END){

  518. 		if (value == LOW)

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

  520. 		else

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

  522. 	}else{

  523. 		if (value == LOW)

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

  525. 		else

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

  527. 	}

  528. }

  529. 

  530. /*------------------------------------------------------------------------------------------*/

  531. static int _analogRead (int UNU pin)

  532. {

  533. 	return -1;

  534. }

  535. 

  536. /*-------------------------------------------------------------------------------------------*/

  537. static void _digitalWriteByte(const int UNU value)

  538. {

  539. 	return;

  540. }

  541. static unsigned int _digitalReadByte (void)

  542. {

  543. 	return -1;

  544. }

  545. 

  546. /*------------------------------------------------------------------------------------------*/

  547. static int init_gpio_mmap(void)

  548. {

  549. 	int fd;

  550. 

  551. 	/* GPIO mmap setup */

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

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

  554. 			return msg (MSG_ERR,

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

  556. 					strerror (errno));

  557. 	}else{

  558. 		if (geteuid () != 0)

  559. 			return msg (MSG_ERR,

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

  561. 

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

  563. 			return msg (MSG_ERR,

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

  565. 					strerror (errno));

  566. 	}

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

  568. 						MAP_SHARED, fd, VIM2_GPIOAO_BASE);

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

  570. 						MAP_SHARED, fd, VIM2_GPIO_BASE);

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

  572. 		return msg (MSG_ERR,

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

  574. 				strerror (errno));

  575. 	return 0;

  576. }

  577. 

  578. /*------------------------------------------------------------------------------------------

  579. static void init_adc_fds(void)

  580. {

  581. }

  582. */

  583. 

  584. /*------------------------------------------------------------------------------------------*/

  585. void init_khadas_vim2(struct libkhadas *libwiring)

  586. {

  587. 	init_gpio_mmap();

  588. 

  589. 	pinToGpio = pinToGpio_rev;

  590. 	phyToGpio = phyToGpio_rev;

  591. 

  592. 	/* wiringPi core function initialize */

  593. 	libwiring->getModeToGpio    = _getModeToGpio;

  594. 	libwiring->pinMode      = _pinMode;

  595. 	libwiring->getAlt       = _getAlt;

  596. 	libwiring->getPUPD      = _getPUPD;

  597. 	libwiring->pullUpDnControl  = _pullUpDnControl;

  598. 	libwiring->digitalRead      = _digitalRead;

  599. 	libwiring->digitalWrite     = _digitalWrite;

  600. 	libwiring->analogRead       = _analogRead;

  601. 	libwiring->digitalWriteByte = _digitalWriteByte;

  602. 	libwiring->digitalReadByte  = _digitalReadByte;

  603. 

  604. 	/* specify pin base number */

  605. 	libwiring->pinBase = VIM2_GPIO_PIN_BASE;

  606. 

  607. 	/* global variable setup */

  608. 	lib = libwiring;

  609. }

  610. 

  611. /*------------------------------------------------------------------------------------------*/

  612. /*------------------------------------------------------------------------------------------*/